Commit Graph

86 Commits

  • fix(watcher): improve client reload logic and prevent redundant updates
    - replace debounce timing with content-based change detection using SHA256 hashes
    - skip client reload when auth file content is unchanged
    - handle empty auth files gracefully by ignoring them
    - ensure hash cache is updated only on successful client creation
    - clean up hash cache when clients are removed
  • refactor(watcher): restructure client management and API key handling
    - separate file-based and API key-based clients in watcher
    - improve client reloading logic with better locking and error handling
    - add dedicated functions for building API key clients and loading file clients
    - update combined client map generation to include cached API key clients
    - enhance logging and debugging information during client reloads
    - fix potential race conditions in client updates and removals
  • Add FunctionCallIndex to ConvertCliToOpenAIParams and enhance tool call handling
    - Introduced `FunctionCallIndex` to track and manage function call indices within `ConvertCliToOpenAIParams`.
    - Enhanced handling for `response.completed` and `response.output_item.done` data types to support tool call scenarios.
    - Improved logic for restoring original tool names and setting function arguments during response parsing.
  • Add reasoning/thinking configuration handling for Claude and OpenAI translators
    - Implemented `thinkingConfig` handling to allow reasoning effort configuration in request generation.
    - Added support for reasoning content deltas (`thinking_delta`) in response processing.
    - Enhanced reasoning-related token budget mappings for various reasoning levels.
    - Improved response handling logic to ensure proper reasoning content inclusion.
  • Replace path with filepath for cross-platform compatibility
    - Updated imports and function calls to use `filepath` across all token storage implementations and server entry point.
    - Ensured consistent handling of directory and file paths for improved portability.
  • Add reverse mappings for original tool names and improve error logging
    - Introduced reverse mapping logic for tool names in translators to restore original names when shortened.
    - Enhanced error handling by logging API response errors consistently across handlers.
    - Refactored request and response loggers to include API error details, improving debugging capabilities.
    - Integrated robust tool name shortening and uniqueness mechanisms for OpenAI, Gemini, and Claude requests.
    - Improved handler retry logic to properly capture and respond to errors.
  • Refactor client map construction to include all client types and enhance callback updates
    - Added `buildCombinedClientMap` to merge file-based clients with API key and compatibility clients.
    - Updated callbacks to use the combined client map for consistency.
    - Improved error logging and variable naming for clarity in client creation logic.
  • Enhance parseArgsToMap with tolerant JSON parsing
    - Introduced `tolerantParseJSONMap` to handle bareword values in streamed tool calls.
    - Added robust handling for JSON strings, objects, arrays, and numerical values.
    - Improved fallback mechanisms to ensure reliable parsing.
  • Add support for Codex API key authentication
    - Introduced functionality to handle Codex API keys, including initialization and management via new endpoints in the management API.
    - Updated Codex client to support both OAuth and API key authentication.
    - Documented Codex API key configuration in both English and Chinese README files.
    - Enhanced logging to distinguish between API key and OAuth usage scenarios.
  • Add Codex load balancing documentation and refine JSON handling logic
    - Updated README and README_CN to include a guide for configuring multiple account load balancing with CLI Proxy API.
    - Enhanced JSON handling in gemini translators by differentiating object and string outputs.
    - Added commented debug logging for Gemini CLI response conversion.
  • Remove redundant dataUglyTag parsing logic in streaming responses
    Eliminated duplicate blocks handling `dataUglyTag` in `openai-compatibility_client.go`, simplifying the streaming response logic.
  • Extract argument parsing logic into parseArgsToMap helper function
    Simplifies parsing and error handling for function arguments across OpenAI response processing methods. Replaces repeated logic with a reusable utility function.
  • **Fix model switch logic when quota is exceeded**
    Ensure `modelName` is updated after switching to a new model, avoiding inconsistencies in subsequent iterations.
  • **Handle data: without trailing space in streaming responses**
    Add support for API providers that emit `data:` (no space) in Server‑Sent Events. Introduces a new `dataUglyTag` and corresponding parsing logic to correctly process and forward these lines, ensuring compatibility with non‑standard streaming formats.
    
    Fuck for them all
  • Refactor translator packages for OpenAI Chat Completions
    - Renamed `openai` packages to `chat_completions` across translator modules.
    - Introduced `openai_responses_handlers` with handlers for `/v1/models` and OpenAI-compatible chat completions endpoints.
    - Updated constants and registry identifiers for OpenAI response type.
    - Simplified request/response conversions and added detailed retry/error handling.
    - Added `golang.org/x/crypto` for additional cryptographic functions.
  • Refactor translator packages for OpenAI Chat Completions
    - Renamed `openai` packages to `chat_completions` across translator modules.
    - Introduced `openai_responses_handlers` with handlers for `/v1/models` and OpenAI-compatible chat completions endpoints.
    - Updated constants and registry identifiers for OpenAI response type.
    - Simplified request/response conversions and added detailed retry/error handling.
    - Added `golang.org/x/crypto` for additional cryptographic functions.
  • Refactor translator packages for OpenAI Chat Completions
    - Renamed `openai` packages to `chat_completions` across translator modules.
    - Introduced `openai_responses_handlers` with handlers for `/v1/models` and OpenAI-compatible chat completions endpoints.
    - Updated constants and registry identifiers for OpenAI response type.
    - Simplified request/response conversions and added detailed retry/error handling.
    - Added `golang.org/x/crypto` for additional cryptographic functions.
  • Refactor translator packages for OpenAI Chat Completions
    - Renamed `openai` packages to `chat_completions` across translator modules.
    - Introduced `openai_responses_handlers` with handlers for `/v1/models` and OpenAI-compatible chat completions endpoints.
    - Updated constants and registry identifiers for OpenAI response type.
    - Simplified request/response conversions and added detailed retry/error handling.
    - Added `golang.org/x/crypto` for additional cryptographic functions.
  • Refactor translator packages for OpenAI Chat Completions
    - Renamed `openai` packages to `chat_completions` across translator modules.
    - Introduced `openai_responses_handlers` with handlers for `/v1/models` and OpenAI-compatible chat completions endpoints.
    - Updated constants and registry identifiers for OpenAI response type.
    - Simplified request/response conversions and added detailed retry/error handling.
    - Added `golang.org/x/crypto` for additional cryptographic functions.
  • Refactor translator packages for OpenAI Chat Completions
    - Renamed `openai` packages to `chat_completions` across translator modules.
    - Introduced `openai_responses_handlers` with handlers for `/v1/models` and OpenAI-compatible chat completions endpoints.
    - Updated constants and registry identifiers for OpenAI response type.
    - Simplified request/response conversions and added detailed retry/error handling.
    - Added `golang.org/x/crypto` for additional cryptographic functions.
  • Update PassthroughGeminiResponseStream to handle [DONE] marker
    - Added logic to return an empty slice when the raw JSON equals the `[DONE]` marker.
    - Ensures proper termination of streamed Gemini responses.
  • Add Gemini-to-Gemini request normalization and passthrough support
    - Introduced a `ConvertGeminiRequestToGemini` function to normalize Gemini v1beta requests by ensuring valid or default roles.
    - Added passthrough response handlers for both streamed and non-streamed Gemini responses.
    - Registered translators for Gemini-to-Gemini traffic in the initialization process.
    - Updated `gemini-cli` request normalization to align with the new Gemini translator logic.
  • Add management API handlers for config and auth file management
    - Implemented CRUD operations for authentication files.
    - Added endpoints for managing API keys, quotas, proxy settings, and other configurations.
    - Enhanced management access with robust validation, remote access control, and persistence support.
    - Updated README with new configuration details.
    
    Fixed OpenAI Chat Completions for codex
  • Enhance client reload process with new OpenAI compatibility support
    - Added handling for OpenAI-compatible providers during client reload.
    - Implemented client unregistration for old clients during reload.
    - Improved logging for detailed client reload insights.
    
    Expand `AuthDir` handling to support tilde (`~`) for home directory resolution
    
    - Added logic to replace `~` with the user's home directory in `AuthDir`.
    - Prevents errors when using `~` in configuration paths.
  • Add support for new GPT-5 model variants
    - Renamed existing GPT-5 variants for consistency (`nano` → `minimal`, `mini` → `low`, etc.).
    - Added metadata definitions for new variants: `gpt-5-minimal`, `gpt-5-low`, `gpt-5-medium`, and updated logic to reflect variant-specific reasoning efforts.
  • Add token refresh handling for 401 responses across clients
    - Implemented `RefreshTokens` method in client interfaces and Gemini clients.
    - Updated handlers to call `RefreshTokens` on 401 responses and retry requests if token refresh succeeds.
    - Enhanced error handling and retry logic to accommodate token refresh flow.
    
    Update README to include Qwen login instructions
    
    - Added Qwen OAuth login command instructions in both English and Chinese README files.
    - Made minor updates to existing command examples for consistency.
  • Add token refresh handling for 401 responses across clients
    - Implemented `RefreshTokens` method in client interfaces and Gemini clients.
    - Updated handlers to call `RefreshTokens` on 401 responses and retry requests if token refresh succeeds.
    - Enhanced error handling and retry logic to accommodate token refresh flow.
  • Update README documentation to clarify auth-dir configuration for Windows users
    - Added a note for setting `auth-dir` on Windows systems in both English and Chinese README files.
    - Improved descriptions for existing configuration options.
    
    Address Qwen3 tool injection issue to prevent random token insertions
    
    - Modify Qwen client to insert a placeholder tool when none is defined, avoiding erratic behavior in streaming responses.
  • Add nil-check for GetRequestMutex across handlers to prevent potential panics
    - Updated all handlers to safely unlock the request mutex only if it's non-nil.
    - Enhanced mutex locking and unlocking logic to avoid runtime errors.
    - Improved robustness of resource cleanup across clients.
    
    Add `GetRequestMutex` method for synchronization across clients
    
    - Introduced a new `GetRequestMutex` method in OpenAICompatibilityClient, CodexClient, GeminiCLIClient, GeminiClient, and QwenClient for request synchronization.
    - Ensures only one request is processed at a time to manage quotas effectively.
  • Add /v1/completions endpoint with OpenAI compatibility
    - Implemented `/v1/completions` endpoint mirroring OpenAI's completions API specification.
    - Added conversion functions to translate between completions and chat completions formats.
    - Introduced streaming and non-streaming response handling for completions requests.
    - Updated `server.go` to register the new endpoint and include it in the API's metadata.
  • Suppress debug logs for model routing and ignore empty tools arrays
    - Comment out verbose routing logs in the API server to reduce noise.
    - Remove the `tools` field from Qwen client requests when it is an empty array.
    - Add guards in Claude, Codex, Gemini‑CLI, and Gemini translators to skip tool conversion when the `tools` array is empty, preventing unnecessary payload modifications.
  • Add support for localhost unauthenticated requests
    - Introduced `AllowLocalhostUnauthenticated` flag allowing unauthenticated requests from localhost.
    - Updated authentication middleware to bypass checks for localhost when enabled.
    
    Add new Gemini CLI models and update model registry function
    
    - Introduced `GetGeminiCLIModels` for updated Gemini CLI model definitions.
    - Added new models: "Gemini 2.5 Flash Lite" and "Gemini 2.5 Pro".
    - Updated `RegisterModels` to use `GetGeminiCLIModels` in Gemini client initialization.
  • Add OpenAI compatibility support and improve resource cleanup
    - Introduced OpenAI compatibility configurations for external providers, enabling model alias routing via the OpenAI API format.
    - Enhanced provider logic in `GetProviderName` to handle OpenAI aliases and added new helper functions for compatibility checks.
    - Updated API handlers and client initialization to support OpenAI compatibility models.
    - Improved resource cleanup across clients by closing response bodies and streams using deferred functions.
  • Refactor API handlers to implement retry mechanism with configurable limits and improved error handling
    - Introduced retry counter with a configurable ` RequestRetry ` limit in all handlers.
    - Enhanced error handling with specific HTTP status codes for switching clients.
    - Standardized response forwarding for non-retriable errors.
    - Improved logging for quota and client switch scenarios.
  • Refactor error handling and variable declarations in browser and logging modules
    - Simplified variable initialization in `browser.go` for readability.
    - Updated error handling in `request_logger.go` with better resource cleanup using deferred anonymous functions.
    
    Refactor API handlers to use `GetContextWithCancel` for streamlined context creation and response handling
    
    - Replaced redundant `context.WithCancel` and `context.WithValue` logic with the new `GetContextWithCancel` utility in all handlers.
    - Centralized API response storage in the given context during cancellation.
    - Updated associated cancellation calls for consistency and improved resource management.
    
    - Replaced `apiResponseData` with `AddAPIResponseData` for centralized response recording.
    - Simplified cancellation logic by switching to a boolean-based `cliCancel` method.
    - Removed unused `apiResponseData` slices across handlers to reduce memory usage.
    - Updated `handlers.go` to support unified response data storage per request context.