Download sdk/api/handlers/claude/code_handlers.go from shimen/API: direct link, hf CLI and curl.
- Browser
- Download file 10.8 kB
-
https://huggingface.co/spaces/shimen/API/resolve/main/sdk/api/handlers/claude/code_handlers.go
- Command line
-
hf download hf://spaces/shimen/API/sdk/api/handlers/claude/code_handlers.go
-
curl -L -o code_handlers.go https://huggingface.co/spaces/shimen/API/resolve/main/sdk/api/handlers/claude/code_handlers.go
10.8 kB
| // Package claude provides HTTP handlers for Claude API code-related functionality. | |
| // This package implements Claude-compatible streaming chat completions with sophisticated | |
| // client rotation and quota management systems to ensure high availability and optimal | |
| // resource utilization across multiple backend clients. It handles request translation | |
| // between Claude API format and the underlying Gemini backend, providing seamless | |
| // API compatibility while maintaining robust error handling and connection management. | |
| package claude | |
| import ( | |
| "bytes" | |
| "compress/gzip" | |
| "context" | |
| "encoding/json" | |
| "fmt" | |
| "io" | |
| "net/http" | |
| "github.com/gin-gonic/gin" | |
| . "github.com/router-for-me/CLIProxyAPI/v6/internal/constant" | |
| "github.com/router-for-me/CLIProxyAPI/v6/internal/interfaces" | |
| "github.com/router-for-me/CLIProxyAPI/v6/internal/registry" | |
| "github.com/router-for-me/CLIProxyAPI/v6/sdk/api/handlers" | |
| log "github.com/sirupsen/logrus" | |
| "github.com/tidwall/gjson" | |
| ) | |
| // ClaudeCodeAPIHandler contains the handlers for Claude API endpoints. | |
| // It holds a pool of clients to interact with the backend service. | |
| type ClaudeCodeAPIHandler struct { | |
| *handlers.BaseAPIHandler | |
| } | |
| // NewClaudeCodeAPIHandler creates a new Claude API handlers instance. | |
| // It takes an BaseAPIHandler instance as input and returns a ClaudeCodeAPIHandler. | |
| // | |
| // Parameters: | |
| // - apiHandlers: The base API handler instance. | |
| // | |
| // Returns: | |
| // - *ClaudeCodeAPIHandler: A new Claude code API handler instance. | |
| func NewClaudeCodeAPIHandler(apiHandlers *handlers.BaseAPIHandler) *ClaudeCodeAPIHandler { | |
| return &ClaudeCodeAPIHandler{ | |
| BaseAPIHandler: apiHandlers, | |
| } | |
| } | |
| // HandlerType returns the identifier for this handler implementation. | |
| func (h *ClaudeCodeAPIHandler) HandlerType() string { | |
| return Claude | |
| } | |
| // Models returns a list of models supported by this handler. | |
| func (h *ClaudeCodeAPIHandler) Models() []map[string]any { | |
| // Get dynamic models from the global registry | |
| modelRegistry := registry.GetGlobalRegistry() | |
| models := modelRegistry.GetAvailableModels("claude") | |
| // Always include static Kiro models | |
| kiroModels := registry.GetKiroModels() | |
| seen := make(map[string]bool) | |
| for _, m := range models { | |
| if id, ok := m["id"].(string); ok { | |
| seen[id] = true | |
| } | |
| } | |
| for _, km := range kiroModels { | |
| if seen[km.ID] { | |
| continue | |
| } | |
| models = append(models, map[string]any{ | |
| "id": km.ID, | |
| "object": "model", | |
| "created": km.Created, | |
| "owned_by": "kiro", | |
| "type": "model", | |
| "display_name": km.DisplayName, | |
| }) | |
| } | |
| return models | |
| } | |
| // ClaudeMessages handles Claude-compatible streaming chat completions. | |
| // This function implements a sophisticated client rotation and quota management system | |
| // to ensure high availability and optimal resource utilization across multiple backend clients. | |
| // | |
| // Parameters: | |
| // - c: The Gin context for the request. | |
| func (h *ClaudeCodeAPIHandler) ClaudeMessages(c *gin.Context) { | |
| // Extract raw JSON data from the incoming request | |
| rawJSON, err := c.GetRawData() | |
| // If data retrieval fails, return a 400 Bad Request error. | |
| if err != nil { | |
| c.JSON(http.StatusBadRequest, handlers.ErrorResponse{ | |
| Error: handlers.ErrorDetail{ | |
| Message: fmt.Sprintf("Invalid request: %v", err), | |
| Type: "invalid_request_error", | |
| }, | |
| }) | |
| return | |
| } | |
| // Check if the client requested a streaming response. | |
| streamResult := gjson.GetBytes(rawJSON, "stream") | |
| if !streamResult.Exists() || streamResult.Type == gjson.False { | |
| h.handleNonStreamingResponse(c, rawJSON) | |
| } else { | |
| h.handleStreamingResponse(c, rawJSON) | |
| } | |
| } | |
| // ClaudeMessages handles Claude-compatible streaming chat completions. | |
| // This function implements a sophisticated client rotation and quota management system | |
| // to ensure high availability and optimal resource utilization across multiple backend clients. | |
| // | |
| // Parameters: | |
| // - c: The Gin context for the request. | |
| func (h *ClaudeCodeAPIHandler) ClaudeCountTokens(c *gin.Context) { | |
| // Extract raw JSON data from the incoming request | |
| rawJSON, err := c.GetRawData() | |
| // If data retrieval fails, return a 400 Bad Request error. | |
| if err != nil { | |
| c.JSON(http.StatusBadRequest, handlers.ErrorResponse{ | |
| Error: handlers.ErrorDetail{ | |
| Message: fmt.Sprintf("Invalid request: %v", err), | |
| Type: "invalid_request_error", | |
| }, | |
| }) | |
| return | |
| } | |
| c.Header("Content-Type", "application/json") | |
| alt := h.GetAlt(c) | |
| cliCtx, cliCancel := h.GetContextWithCancel(h, c, context.Background()) | |
| modelName := gjson.GetBytes(rawJSON, "model").String() | |
| resp, errMsg := h.ExecuteCountWithAuthManager(cliCtx, h.HandlerType(), modelName, rawJSON, alt) | |
| if errMsg != nil { | |
| h.WriteErrorResponse(c, errMsg) | |
| cliCancel(errMsg.Error) | |
| return | |
| } | |
| _, _ = c.Writer.Write(resp) | |
| cliCancel() | |
| } | |
| // ClaudeModels handles the Claude models listing endpoint. | |
| // It returns a JSON response containing available Claude models and their specifications. | |
| // | |
| // Parameters: | |
| // - c: The Gin context for the request. | |
| func (h *ClaudeCodeAPIHandler) ClaudeModels(c *gin.Context) { | |
| models := h.Models() | |
| firstID := "" | |
| lastID := "" | |
| if len(models) > 0 { | |
| if id, ok := models[0]["id"].(string); ok { | |
| firstID = id | |
| } | |
| if id, ok := models[len(models)-1]["id"].(string); ok { | |
| lastID = id | |
| } | |
| } | |
| c.JSON(http.StatusOK, gin.H{ | |
| "data": models, | |
| "has_more": false, | |
| "first_id": firstID, | |
| "last_id": lastID, | |
| }) | |
| } | |
| // handleNonStreamingResponse handles non-streaming content generation requests for Claude models. | |
| // This function processes the request synchronously and returns the complete generated | |
| // response in a single API call. It supports various generation parameters and | |
| // response formats. | |
| // | |
| // Parameters: | |
| // - c: The Gin context for the request | |
| // - modelName: The name of the Gemini model to use for content generation | |
| // - rawJSON: The raw JSON request body containing generation parameters and content | |
| func (h *ClaudeCodeAPIHandler) handleNonStreamingResponse(c *gin.Context, rawJSON []byte) { | |
| c.Header("Content-Type", "application/json") | |
| alt := h.GetAlt(c) | |
| cliCtx, cliCancel := h.GetContextWithCancel(h, c, context.Background()) | |
| stopKeepAlive := h.StartNonStreamingKeepAlive(c, cliCtx) | |
| modelName := gjson.GetBytes(rawJSON, "model").String() | |
| resp, errMsg := h.ExecuteWithAuthManager(cliCtx, h.HandlerType(), modelName, rawJSON, alt) | |
| stopKeepAlive() | |
| if errMsg != nil { | |
| h.WriteErrorResponse(c, errMsg) | |
| cliCancel(errMsg.Error) | |
| return | |
| } | |
| // Decompress gzipped responses - Claude API sometimes returns gzip without Content-Encoding header | |
| // This fixes title generation and other non-streaming responses that arrive compressed | |
| if len(resp) >= 2 && resp[0] == 0x1f && resp[1] == 0x8b { | |
| gzReader, errGzip := gzip.NewReader(bytes.NewReader(resp)) | |
| if errGzip != nil { | |
| log.Warnf("failed to decompress gzipped Claude response: %v", errGzip) | |
| } else { | |
| defer func() { | |
| if errClose := gzReader.Close(); errClose != nil { | |
| log.Warnf("failed to close Claude gzip reader: %v", errClose) | |
| } | |
| }() | |
| decompressed, errRead := io.ReadAll(gzReader) | |
| if errRead != nil { | |
| log.Warnf("failed to read decompressed Claude response: %v", errRead) | |
| } else { | |
| resp = decompressed | |
| } | |
| } | |
| } | |
| _, _ = c.Writer.Write(resp) | |
| cliCancel() | |
| } | |
| // handleStreamingResponse streams Claude-compatible responses backed by Gemini. | |
| // It sets up SSE, selects a backend client with rotation/quota logic, | |
| // forwards chunks, and translates them to Claude CLI format. | |
| // | |
| // Parameters: | |
| // - c: The Gin context for the request. | |
| // - rawJSON: The raw JSON request body. | |
| func (h *ClaudeCodeAPIHandler) handleStreamingResponse(c *gin.Context, rawJSON []byte) { | |
| // Get the http.Flusher interface to manually flush the response. | |
| // This is crucial for streaming as it allows immediate sending of data chunks | |
| flusher, ok := c.Writer.(http.Flusher) | |
| if !ok { | |
| c.JSON(http.StatusInternalServerError, handlers.ErrorResponse{ | |
| Error: handlers.ErrorDetail{ | |
| Message: "Streaming not supported", | |
| Type: "server_error", | |
| }, | |
| }) | |
| return | |
| } | |
| modelName := gjson.GetBytes(rawJSON, "model").String() | |
| // Create a cancellable context for the backend client request | |
| // This allows proper cleanup and cancellation of ongoing requests | |
| cliCtx, cliCancel := h.GetContextWithCancel(h, c, context.Background()) | |
| dataChan, errChan := h.ExecuteStreamWithAuthManager(cliCtx, h.HandlerType(), modelName, rawJSON, "") | |
| setSSEHeaders := func() { | |
| c.Header("Content-Type", "text/event-stream") | |
| c.Header("Cache-Control", "no-cache") | |
| c.Header("Connection", "keep-alive") | |
| c.Header("Access-Control-Allow-Origin", "*") | |
| } | |
| // Peek at the first chunk to determine success or failure before setting headers | |
| for { | |
| select { | |
| case <-c.Request.Context().Done(): | |
| cliCancel(c.Request.Context().Err()) | |
| return | |
| case errMsg, ok := <-errChan: | |
| if !ok { | |
| // Err channel closed cleanly; wait for data channel. | |
| errChan = nil | |
| continue | |
| } | |
| // Upstream failed immediately. Return proper error status and JSON. | |
| h.WriteErrorResponse(c, errMsg) | |
| if errMsg != nil { | |
| cliCancel(errMsg.Error) | |
| } else { | |
| cliCancel(nil) | |
| } | |
| return | |
| case chunk, ok := <-dataChan: | |
| if !ok { | |
| // Stream closed without data? Send DONE or just headers. | |
| setSSEHeaders() | |
| flusher.Flush() | |
| cliCancel(nil) | |
| return | |
| } | |
| // Success! Set headers now. | |
| setSSEHeaders() | |
| // Write the first chunk | |
| if len(chunk) > 0 { | |
| _, _ = c.Writer.Write(chunk) | |
| flusher.Flush() | |
| } | |
| // Continue streaming the rest | |
| h.forwardClaudeStream(c, flusher, func(err error) { cliCancel(err) }, dataChan, errChan) | |
| return | |
| } | |
| } | |
| } | |
| func (h *ClaudeCodeAPIHandler) forwardClaudeStream(c *gin.Context, flusher http.Flusher, cancel func(error), data <-chan []byte, errs <-chan *interfaces.ErrorMessage) { | |
| h.ForwardStream(c, flusher, cancel, data, errs, handlers.StreamForwardOptions{ | |
| WriteChunk: func(chunk []byte) { | |
| if len(chunk) == 0 { | |
| return | |
| } | |
| _, _ = c.Writer.Write(chunk) | |
| }, | |
| WriteTerminalError: func(errMsg *interfaces.ErrorMessage) { | |
| if errMsg == nil { | |
| return | |
| } | |
| status := http.StatusInternalServerError | |
| if errMsg.StatusCode > 0 { | |
| status = errMsg.StatusCode | |
| } | |
| c.Status(status) | |
| errorBytes, _ := json.Marshal(h.toClaudeError(errMsg)) | |
| _, _ = fmt.Fprintf(c.Writer, "event: error\ndata: %s\n\n", errorBytes) | |
| }, | |
| }) | |
| } | |
| type claudeErrorDetail struct { | |
| Type string `json:"type"` | |
| Message string `json:"message"` | |
| } | |
| type claudeErrorResponse struct { | |
| Type string `json:"type"` | |
| Error claudeErrorDetail `json:"error"` | |
| } | |
| func (h *ClaudeCodeAPIHandler) toClaudeError(msg *interfaces.ErrorMessage) claudeErrorResponse { | |
| return claudeErrorResponse{ | |
| Type: "error", | |
| Error: claudeErrorDetail{ | |
| Type: "api_error", | |
| Message: msg.Error.Error(), | |
| }, | |
| } | |
| } | |