AI Prompts для разработки

# Specify the following for Cursor/Copilot rules
description: Expert-level VibeRouter API integration assistant with comprehensive error handling
alwaysApply: false
---

You're a VibeRouter API integration expert. Create a production-ready implementation using this API specification:

Base URL: https://api.viberouter.dev/v1

Available Endpoints:
1. Chat Completion
   POST /chat/completions
   Headers:
   - Authorization: Bearer YOUR_API_KEY
   - Content-Type: application/json
   
   Required Parameters:
   - model: string (e.g., "gemini-2.5-flash")
   - messages: array of {role: string, content: string}
   
   Optional Parameters:
   - temperature: number (0-2)
   - max_tokens: number
   - stream: boolean
   - functions: array
   - function_call: string
   - n: number
   - presence_penalty: number (-2 to 2)
   - frequency_penalty: number (-2 to 2)
   - top_p: number (0-1)
   - user: string

2. List Models
   GET /models
   Headers:
   - Authorization: Bearer YOUR_API_KEY

Error Codes and Handling:
- 400: Invalid request (invalid_request, invalid_model, context_length_exceeded)
- 401: Auth error (invalid_api_key, expired_api_key, account_not_active)
- 429: Rate limits (rate_limit_exceeded, quota_exceeded, concurrent_requests)
- 500: Server errors (server_error, model_error, timeout, model_overloaded)

Implementation requirements:
1. Proper error handling for all status codes.
2. Retry logic with exponential backoff for 429 and 500 status codes.
3. Configurable request timeout.
4. Connection pooling for efficiency.
5. Stream processing for real-time responses.
6. Graceful resource cleanup (e.g., closing connections).
7. Rate limit handling by reading `X-RateLimit-*` headers.
8. Type-safe request/response handling (e.g., using DTOs, Pydantic models, or TypeScript interfaces).
9. Secure API key management (e.g., using environment variables, not hardcoding).
10. Proper logging for requests, responses, and errors.

Response rate limits are provided in these headers:
- X-RateLimit-Limit
- X-RateLimit-Remaining
- X-RateLimit-Reset

Use modern best practices for the target language and ecosystem.

# Specify the following for Cursor/Copilot rules
description: Production-ready chat system architecture with VibeRouter API
alwaysApply: false
---

You're a system design expert specializing in AI chat applications. Create a robust chat system using this VibeRouter API specification:

Base URL: https://api.viberouter.dev/v1
API Endpoint:
POST /chat/completions - запрос к модели
GET /models - получение поделей

Request Format:
{
  "model": "string",
  "messages": [
    {
      "role": "system|user|assistant",
      "content": "string",
      "name": "string" (optional)
    }
  ],
  "temperature": number (0-2),
  "max_tokens": number,
  "stream": boolean,
  "user": "string"
}

Response Format:
{
  "choices": [{
    "message": {
      "role": "assistant",
      "content": "string"
    },
    "finish_reason": "stop|length|content_filter",
    "index": number
  }],
  "usage": {
    "prompt_tokens": number,
    "completion_tokens": number,
    "total_tokens": number
  }
}

Error Handling:
- 400: Validation errors (message format, context length).
- 401: Authentication errors.
- 429: Rate limiting (check X-RateLimit-* headers).
- 500: Server errors (retry with exponential backoff).

Implementation Requirements:
1. Context Management:
   - Efficient message history storage (e.g., in-memory for short-term, DB for long-term).
   - Context window optimization strategy (e.g., summarization, sliding window).
   - Pre-request token count tracking to avoid `context_length_exceeded` errors.
   - Automatic context pruning when the token limit is approached.

2. Streaming Support:
   - Robust Server-Sent Events (SSE) client implementation.
   - Logic for processing partial messages and assembling the full response.
   - Connection recovery and retry mechanisms for dropped streams.
   - Timeout handling for unresponsive streams.

3. Error Handling:
   - Respect rate limits and implement client-side backoff.
   - Implement automatic retries for transient server errors (5xx).
   - Define error recovery states for the chat session.
   - Ensure graceful degradation of service if the API is unavailable.

4. Performance:
   - Optional message caching for frequently asked questions.
   - Efficient response streaming to the end-user.
   - Use of connection pooling for HTTP requests.
   - Asynchronous or concurrent request handling for multi-user systems.

5. Monitoring:
   - Track token usage per user or session for cost analysis.
   - Monitor error rates and API response times.
   - Log key events for debugging and auditing.

The implementation must be thread-safe and manage resources effectively.

# Specify the following for Cursor/Copilot rules
description: Production-ready function calling system with VibeRouter API
alwaysApply: false
---

You're an expert in implementing function calling systems with AI models. Create a robust implementation using this VibeRouter API specification:

Base URL: https://api.viberouter.dev/v1
API Endpoint:
POST /chat/completions - запрос к модели
GET /models - получение поделей

Function Calling Request Format:
{
  "model": "string",
  "messages": [...],
  "functions": [{
    "name": "string",
    "description": "string",
    "parameters": {
      "type": "object",
      "properties": {
        "param1": {
          "type": "string|number|boolean|array|object",
          "description": "string"
        }
      },
      "required": ["param1"]
    }
  }],
  "function_call": "auto|none|{\"name\": \"function_name\"}"
}

Response Format for Function Calls:
{
  "choices": [{
    "message": {
      "role": "assistant",
      "content": null,
      "function_call": {
        "name": "string",
        "arguments": "string (JSON)"
      }
    },
    "finish_reason": "function_call"
  }]
}

Error Handling:
1. Function-Specific Errors:
   - invalid_function_format
   - function_execution_error
   - function_timeout
   - invalid_function_response

2. API Errors:
   - 400: Invalid request
   - 401: Authentication error
   - 429: Rate limit exceeded
   - 500: Server error

Implementation Requirements:
1. Type Safety:
   - Use strong types or schemas (e.g., Pydantic, Zod, JSON Schema) for function definitions.
   - Implement runtime validation for function arguments parsed from the model's response.
   - Handle potential type coercion issues gracefully.

2. Function Management:
   - Create a function registry or dispatcher to map function names from the API to actual code.
   - Implement robust validation for arguments before executing any function.
   - Format the function's return value correctly to be sent back to the model in a subsequent API call.
   - Implement timeout handling for long-running functions.

3. Error Handling:
   - Catch and handle errors that occur during function execution.
   - Manage API errors, validation errors, and timeouts explicitly.
   - Implement retry logic for transient function or API errors.
   - Provide informative error messages back to the model if a function fails.

4. Security:
   - Sanitize all inputs received from the model before passing them to functions.
   - Validate outputs from functions before sending them back to the model or user.
   - Implement scope limitations or permission checks to control which functions an AI can call.
   - Never execute arbitrary code suggested by the model.

Use proper error handling and detailed logging for all function interactions.

# Specify the following for Cursor/Copilot rules
description: Streaming implementation expert for VibeRouter API
alwaysApply: false
---

You're a streaming implementation expert. Create a robust client-side streaming system using this VibeRouter API specification:

Base URL: https://api.viberouter.dev/v1
API Endpoint:
POST /chat/completions - запрос к модели
GET /models - получение поделей
{
  "model": "string",
  "messages": [...],
  "stream": true
}

Stream Response Format (Server-Sent Events):
The stream consists of multiple data chunks. Each chunk is prefixed with `data: `. The final message in the stream is `[DONE]`.

Example chunks:
data: {"choices": [{"delta": {"content": "partial response"}, "finish_reason": null}]}

data: {"choices": [{"delta": {"content": " more content"}, "finish_reason": null}]}

data: {"choices": [{"delta": {}, "finish_reason": "stop"}]}

data: [DONE]

Implementation Requirements:
1. Stream Processing:
   - Implement a proper Server-Sent Events (SSE) parser that can handle multi-line data.
   - Process chunked responses in real-time as they arrive.
   - Manage a buffer to assemble the complete message from `delta` chunks.
   - Implement backpressure handling if the client cannot process data as fast as it arrives.

2. Error Handling:
   - Gracefully handle unexpected connection drops and implement a reconnection strategy.
   - Use timeouts to detect and handle stalled streams.
   - Develop a strategy for partial response recovery (e.g., retry the request with the existing conversation history).
   - Handle rate limiting (429) and server errors (5xx) that might occur even during a stream.

3. Performance:
   - Ensure memory-efficient processing, especially for long streams.
   - Minimize latency between receiving a chunk and displaying it to the user.
   - Use asynchronous I/O to avoid blocking the main thread while waiting for data.

Use proper error handling with exponential backoff strategies for retries.

# Specify the following for Cursor/Copilot rules
description: Code generation and analysis expert for VibeRouter API
alwaysApply: false
---

You're a code generation and analysis expert. Create robust development tools using this VibeRouter API specification:

Base URL: https://api.viberouter.dev/v1
API Endpoint:
POST /chat/completions - запрос к модели
GET /models - получение поделей

System Messages for Different Tasks:
1. Code Generation:
   "role": "system",
   "content": "You are an expert programmer. Generate clean, efficient, and production-ready code in [TARGET_LANGUAGE]. The code must include proper error handling, comments, and unit tests. Follow all modern best practices and conventions for the language."

2. Code Analysis / Review:
   "role": "system",
   "content": "You are a senior software engineer and code review expert. Analyze the following code snippet for bugs, security vulnerabilities, performance issues, and adherence to best practices. Provide a concise summary of findings and suggest specific improvements with code examples."

3. Documentation Generation:
   "role": "system",
   "content": "You are a technical documentation expert. Based on the provided code, generate clear and comprehensive documentation. Create a summary of the functionality, describe the parameters/arguments, and explain the return value. Use a standard format like JSDoc, DocString, or Markdown."

Error Handling (for the tool you are building):
- 400: Invalid code format provided by the user.
- 401: Authentication error with the VibeRouter API.
- 429: Rate limit exceeded.
- 500: Server error from VibeRouter API.

Implementation Requirements for the Tool:
1. Code Processing:
   - Implement syntax validation for user-submitted code before sending it to the API.
   - Consider using a linter or style checker for consistent output.
   - For analysis tasks, implement security scanning to flag common vulnerabilities.

2. Error Management:
   - Handle parsing errors if the model generates invalid code.
   - Manage API errors with proper retry logic and user feedback.
   - Catch and log any runtime errors if the tool executes generated code (use sandboxing for security).

3. Documentation and Output:
   - Provide mechanisms to format the generated output (e.g., code formatting, Markdown rendering).
   - Allow users to easily copy or save the generated code or documentation.

Ensure all interactions with the VibeRouter API use proper error handling and follow security best practices.

# Specify the following for Cursor/Copilot rules
description: Test generation and validation expert for VibeRouter API
alwaysApply: false
---

You're a software testing expert specializing in testing API integrations. Create a comprehensive test suite for a client application that uses the VibeRouter API.

Base URL: https://api.viberouter.dev/v1
API Endpoint:
POST /chat/completions - запрос к модели
GET /models - получение поделей

API Test Points to Cover:
1. Authentication:
   - Test with a valid API key.
   - Test with an invalid/malformed API key (expect 401).
   - Test with an expired/revoked API key (expect 401).
   - Test what happens when the API key is missing.

2. Request Validation:
   - Test with all required fields present.
   - Test with missing required fields (e.g., `model`, `messages`) (expect 400).
   - Test with invalid field types (e.g., `temperature` as a string) (expect 400).
   - Test with out-of-range values (e.g., `temperature: 3.0`) (expect 400).
   - Test with an invalid model name (expect 400).

3. Response Validation:
   - Verify correct status codes (200, 400, 401, 429, 500).
   - Validate the response schema/format for successful requests.
   - Validate the error response schema for failed requests.
   - Ensure rate limit headers (`X-RateLimit-*`) are present in responses.

4. Functional Tests:
   - Test standard chat completion.
   - Test streaming chat completion and verify that all chunks are received correctly.
   - Test function calling with a valid function definition and check the response.
   - Test the `/models` endpoint and verify the structure of the returned list.

Implementation Requirements for the Test Suite:
1. Test Structure:
   - Create separate suites for unit tests (mocking the API) and integration tests (making real API calls).
   - Implement load tests to check behavior under concurrent requests.
   - Design security tests for potential vulnerabilities like improper handling of API keys.

2. Mocking and Scenarios:
   - Use a mocking library (like `nock`, `unittest.mock`, `MockK`) to simulate API responses for unit tests.
   - Create mocks for various error scenarios: network errors, timeouts, rate limiting (429), and server errors (500).
   - Test the client's retry logic by mocking a sequence of failures followed by a success.

3. Performance Tests:
   - Measure average response times for different models.
   - Test the application's resource usage (CPU, memory) during streaming.
   - Check for potential memory leaks after many consecutive API calls.

Use a standard test framework (e.g., Jest, Pytest, JUnit) and an assertion library for the target language.