mirror of
https://github.com/router-for-me/CLIProxyAPI.git
synced 2026-11-16 22:57:53 +08:00
Map Gemini and Antigravity safety/filter/malformed finishReason values (SAFETY, RECITATION, BLOCKLIST, PROHIBITED_CONTENT, SPII, IMAGE_SAFETY, MALFORMED_RESPONSE, MALFORMED_FUNCTION_CALL) to non-normal terminal states across OpenAI Chat Completions, OpenAI Responses, and Claude translators, and ensure Gemini OpenAI streaming emits cached finish reasons even when usageMetadata arrives separately or is absent. Also surface candidate-less promptFeedback.blockReason responses in Gemini and Vertex executors as explicit 502 errors while preserving usage reporting, and enforce finishReason truncation checks for OpenAI streams. Fixes #6906
1893 lines
73 KiB
Go
1893 lines
73 KiB
Go
// Package executor provides runtime execution capabilities for various AI service providers.
|
|
// This file implements the Vertex AI Gemini executor that talks to Google Vertex AI
|
|
// endpoints using service account credentials or API keys.
|
|
package executor
|
|
|
|
import (
|
|
"bufio"
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"strings"
|
|
"time"
|
|
|
|
vertexauth "github.com/router-for-me/CLIProxyAPI/v8/internal/auth/vertex"
|
|
"github.com/router-for-me/CLIProxyAPI/v8/internal/config"
|
|
"github.com/router-for-me/CLIProxyAPI/v8/internal/runtime/executor/helps"
|
|
internalsignature "github.com/router-for-me/CLIProxyAPI/v8/internal/signature"
|
|
"github.com/router-for-me/CLIProxyAPI/v8/internal/thinking"
|
|
"github.com/router-for-me/CLIProxyAPI/v8/internal/util"
|
|
cliproxyauth "github.com/router-for-me/CLIProxyAPI/v8/sdk/cliproxy/auth"
|
|
cliproxyexecutor "github.com/router-for-me/CLIProxyAPI/v8/sdk/cliproxy/executor"
|
|
sdktranslator "github.com/router-for-me/CLIProxyAPI/v8/sdk/translator"
|
|
log "github.com/sirupsen/logrus"
|
|
"github.com/tidwall/gjson"
|
|
"github.com/tidwall/sjson"
|
|
"golang.org/x/oauth2"
|
|
"golang.org/x/oauth2/google"
|
|
)
|
|
|
|
const (
|
|
// vertexAPIVersion aligns with current public Vertex Generative AI API.
|
|
vertexAPIVersion = "v1"
|
|
)
|
|
|
|
// isImagenModel checks if the model name is an Imagen image generation model.
|
|
// Imagen models use the :predict action instead of :generateContent.
|
|
func isImagenModel(model string) bool {
|
|
lowerModel := strings.ToLower(model)
|
|
return strings.Contains(lowerModel, "imagen")
|
|
}
|
|
|
|
// getVertexAction returns the appropriate action for the given model.
|
|
// Imagen models use "predict", while Gemini models use "generateContent".
|
|
func getVertexAction(model string, isStream bool) string {
|
|
if isImagenModel(model) {
|
|
return "predict"
|
|
}
|
|
if isStream {
|
|
return "streamGenerateContent"
|
|
}
|
|
return "generateContent"
|
|
}
|
|
|
|
// convertImagenToGeminiResponse converts Imagen API response to Gemini format
|
|
// so it can be processed by the standard translation pipeline.
|
|
// This ensures Imagen models return responses in the same format as gemini-3-pro-image-preview.
|
|
func convertImagenToGeminiResponse(data []byte, model string) []byte {
|
|
predictions := gjson.GetBytes(data, "predictions")
|
|
if !predictions.Exists() || !predictions.IsArray() {
|
|
return data
|
|
}
|
|
|
|
// Build Gemini-compatible response with inlineData
|
|
parts := make([]map[string]any, 0)
|
|
for _, pred := range predictions.Array() {
|
|
imageData := pred.Get("bytesBase64Encoded").String()
|
|
mimeType := pred.Get("mimeType").String()
|
|
if mimeType == "" {
|
|
mimeType = "image/png"
|
|
}
|
|
if imageData != "" {
|
|
parts = append(parts, map[string]any{
|
|
"inlineData": map[string]any{
|
|
"mimeType": mimeType,
|
|
"data": imageData,
|
|
},
|
|
})
|
|
}
|
|
}
|
|
|
|
// Generate unique response ID using timestamp
|
|
responseId := fmt.Sprintf("imagen-%d", time.Now().UnixNano())
|
|
|
|
response := map[string]any{
|
|
"candidates": []map[string]any{{
|
|
"content": map[string]any{
|
|
"parts": parts,
|
|
"role": "model",
|
|
},
|
|
"finishReason": "STOP",
|
|
}},
|
|
"responseId": responseId,
|
|
"modelVersion": model,
|
|
// Imagen API doesn't return token counts, set to 0 for tracking purposes
|
|
"usageMetadata": map[string]any{
|
|
"promptTokenCount": 0,
|
|
"candidatesTokenCount": 0,
|
|
"totalTokenCount": 0,
|
|
},
|
|
}
|
|
|
|
result, err := json.Marshal(response)
|
|
if err != nil {
|
|
return data
|
|
}
|
|
return result
|
|
}
|
|
|
|
// convertToImagenRequest converts a Gemini-style request to Imagen API format.
|
|
// Imagen API uses a different structure: instances[].prompt instead of contents[].
|
|
func convertToImagenRequest(payload []byte) ([]byte, error) {
|
|
// Extract prompt from Gemini-style contents
|
|
prompt := ""
|
|
|
|
// Try to get prompt from contents[0].parts[0].text
|
|
contentsText := gjson.GetBytes(payload, "contents.0.parts.0.text")
|
|
if contentsText.Exists() {
|
|
prompt = contentsText.String()
|
|
}
|
|
|
|
// If no contents, try messages format (OpenAI-compatible)
|
|
if prompt == "" {
|
|
messagesText := gjson.GetBytes(payload, "messages.#.content")
|
|
if messagesText.Exists() && messagesText.IsArray() {
|
|
for _, msg := range messagesText.Array() {
|
|
if msg.String() != "" {
|
|
prompt = msg.String()
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// If still no prompt, try direct prompt field
|
|
if prompt == "" {
|
|
directPrompt := gjson.GetBytes(payload, "prompt")
|
|
if directPrompt.Exists() {
|
|
prompt = directPrompt.String()
|
|
}
|
|
}
|
|
|
|
if prompt == "" {
|
|
return nil, fmt.Errorf("imagen: no prompt found in request")
|
|
}
|
|
|
|
// Build Imagen API request
|
|
imagenReq := map[string]any{
|
|
"instances": []map[string]any{
|
|
{
|
|
"prompt": prompt,
|
|
},
|
|
},
|
|
"parameters": map[string]any{
|
|
"sampleCount": 1,
|
|
},
|
|
}
|
|
|
|
// Extract optional parameters
|
|
if aspectRatio := gjson.GetBytes(payload, "aspectRatio"); aspectRatio.Exists() {
|
|
imagenReq["parameters"].(map[string]any)["aspectRatio"] = aspectRatio.String()
|
|
}
|
|
if sampleCount := gjson.GetBytes(payload, "sampleCount"); sampleCount.Exists() {
|
|
imagenReq["parameters"].(map[string]any)["sampleCount"] = int(sampleCount.Int())
|
|
}
|
|
if negativePrompt := gjson.GetBytes(payload, "negativePrompt"); negativePrompt.Exists() {
|
|
imagenReq["instances"].([]map[string]any)[0]["negativePrompt"] = negativePrompt.String()
|
|
}
|
|
|
|
return json.Marshal(imagenReq)
|
|
}
|
|
|
|
// GeminiVertexExecutor sends requests to Vertex AI Gemini endpoints using service account credentials.
|
|
type GeminiVertexExecutor struct {
|
|
cfg *config.Config
|
|
}
|
|
|
|
// NewGeminiVertexExecutor creates a new Vertex AI Gemini executor instance.
|
|
//
|
|
// Parameters:
|
|
// - cfg: The application configuration
|
|
//
|
|
// Returns:
|
|
// - *GeminiVertexExecutor: A new Vertex AI Gemini executor instance
|
|
func NewGeminiVertexExecutor(cfg *config.Config) *GeminiVertexExecutor {
|
|
return &GeminiVertexExecutor{cfg: cfg}
|
|
}
|
|
|
|
// Identifier returns the executor identifier.
|
|
func (e *GeminiVertexExecutor) Identifier() string { return "vertex" }
|
|
|
|
// PrepareRequest injects Vertex credentials into the outgoing HTTP request.
|
|
func (e *GeminiVertexExecutor) PrepareRequest(req *http.Request, auth *cliproxyauth.Auth) error {
|
|
if req == nil {
|
|
return nil
|
|
}
|
|
apiKey, _ := vertexAPICreds(auth)
|
|
if strings.TrimSpace(apiKey) != "" {
|
|
req.Header.Set("x-goog-api-key", apiKey)
|
|
req.Header.Del("Authorization")
|
|
return nil
|
|
}
|
|
_, _, saJSON, errCreds := vertexCreds(auth)
|
|
if errCreds != nil {
|
|
return errCreds
|
|
}
|
|
token, errToken := vertexAccessToken(req.Context(), e.cfg, auth, saJSON)
|
|
if errToken != nil {
|
|
return errToken
|
|
}
|
|
if strings.TrimSpace(token) == "" {
|
|
return statusErr{code: http.StatusUnauthorized, msg: "missing access token"}
|
|
}
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
req.Header.Del("x-goog-api-key")
|
|
return nil
|
|
}
|
|
|
|
// HttpRequest injects Vertex credentials into the request and executes it.
|
|
func (e *GeminiVertexExecutor) HttpRequest(ctx context.Context, auth *cliproxyauth.Auth, req *http.Request) (*http.Response, error) {
|
|
if req == nil {
|
|
return nil, fmt.Errorf("vertex executor: request is nil")
|
|
}
|
|
if ctx == nil {
|
|
ctx = req.Context()
|
|
}
|
|
httpReq := req.WithContext(ctx)
|
|
if err := e.PrepareRequest(httpReq, auth); err != nil {
|
|
return nil, err
|
|
}
|
|
httpClient := helps.NewProxyAwareHTTPClient(ctx, e.cfg, auth, 0)
|
|
return httpClient.Do(httpReq)
|
|
}
|
|
|
|
// Execute performs a non-streaming request to the Vertex AI API.
|
|
func (e *GeminiVertexExecutor) Execute(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options) (resp cliproxyexecutor.Response, err error) {
|
|
ctx = helps.EnsureSessionContext(ctx, opts, req.Payload)
|
|
if opts.Alt == "responses/compact" {
|
|
return resp, statusErr{code: http.StatusNotImplemented, msg: "/responses/compact not supported"}
|
|
}
|
|
if helps.ShouldExecuteVertexOpenAPIForRequest(e.cfg, auth, req.Model, opts) {
|
|
return e.executeOpenAPI(ctx, auth, req, opts)
|
|
}
|
|
if shouldExecuteVertexInteractions(auth, opts) {
|
|
return e.executeInteractions(ctx, auth, req, opts)
|
|
}
|
|
// Try API key authentication first
|
|
apiKey, baseURL := vertexAPICreds(auth)
|
|
|
|
// If no API key found, fall back to service account authentication
|
|
if apiKey == "" {
|
|
projectID, location, saJSON, errCreds := vertexCreds(auth)
|
|
if errCreds != nil {
|
|
return resp, errCreds
|
|
}
|
|
return e.executeWithServiceAccount(ctx, auth, req, opts, projectID, location, saJSON)
|
|
}
|
|
|
|
// Use API key authentication
|
|
return e.executeWithAPIKey(ctx, auth, req, opts, apiKey, baseURL)
|
|
}
|
|
|
|
// ExecuteStream performs a streaming request to the Vertex AI API.
|
|
func (e *GeminiVertexExecutor) ExecuteStream(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options) (*cliproxyexecutor.StreamResult, error) {
|
|
ctx = helps.EnsureSessionContext(ctx, opts, req.Payload)
|
|
if opts.Alt == "responses/compact" {
|
|
return nil, statusErr{code: http.StatusNotImplemented, msg: "/responses/compact not supported"}
|
|
}
|
|
if helps.ShouldExecuteVertexOpenAPIForRequest(e.cfg, auth, req.Model, opts) {
|
|
return e.executeOpenAPIStream(ctx, auth, req, opts)
|
|
}
|
|
if shouldExecuteVertexInteractions(auth, opts) {
|
|
return e.executeInteractionsStream(ctx, auth, req, opts)
|
|
}
|
|
// Try API key authentication first
|
|
apiKey, baseURL := vertexAPICreds(auth)
|
|
|
|
// If no API key found, fall back to service account authentication
|
|
if apiKey == "" {
|
|
projectID, location, saJSON, errCreds := vertexCreds(auth)
|
|
if errCreds != nil {
|
|
return nil, errCreds
|
|
}
|
|
return e.executeStreamWithServiceAccount(ctx, auth, req, opts, projectID, location, saJSON)
|
|
}
|
|
|
|
// Use API key authentication
|
|
return e.executeStreamWithAPIKey(ctx, auth, req, opts, apiKey, baseURL)
|
|
}
|
|
|
|
// CountTokens counts tokens for the given request using the Vertex AI API.
|
|
func (e *GeminiVertexExecutor) CountTokens(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options) (cliproxyexecutor.Response, error) {
|
|
if helps.ShouldExecuteVertexOpenAPIForRequest(e.cfg, auth, req.Model, opts) {
|
|
normalizedReq, normalizedOpts := normalizeVertexOpenAPIRequest(req, opts)
|
|
return NewOpenAICompatExecutor(e.Identifier(), e.cfg).CountTokens(ctx, auth, normalizedReq, normalizedOpts)
|
|
}
|
|
// Try API key authentication first
|
|
apiKey, baseURL := vertexAPICreds(auth)
|
|
|
|
// If no API key found, fall back to service account authentication
|
|
if apiKey == "" {
|
|
projectID, location, saJSON, errCreds := vertexCreds(auth)
|
|
if errCreds != nil {
|
|
return cliproxyexecutor.Response{}, errCreds
|
|
}
|
|
return e.countTokensWithServiceAccount(ctx, auth, req, opts, projectID, location, saJSON)
|
|
}
|
|
|
|
// Use API key authentication
|
|
return e.countTokensWithAPIKey(ctx, auth, req, opts, apiKey, baseURL)
|
|
}
|
|
|
|
func normalizeVertexOpenAPIRequest(req cliproxyexecutor.Request, opts cliproxyexecutor.Options) (cliproxyexecutor.Request, cliproxyexecutor.Options) {
|
|
normalizedModel := helps.NormalizeVertexOpenAPIModel(req.Model)
|
|
if normalizedModel == "" || normalizedModel == req.Model {
|
|
return req, opts
|
|
}
|
|
if len(opts.OriginalRequest) == 0 && len(req.Payload) > 0 {
|
|
opts.OriginalRequest = req.Payload
|
|
}
|
|
req.Model = normalizedModel
|
|
return req, opts
|
|
}
|
|
|
|
func hasVertexServiceAccount(auth *cliproxyauth.Auth) bool {
|
|
if auth == nil || auth.Metadata == nil {
|
|
return false
|
|
}
|
|
sa, ok := auth.Metadata["service_account"].(map[string]any)
|
|
return ok && len(sa) > 0
|
|
}
|
|
|
|
func (e *GeminiVertexExecutor) vertexOpenAPILocation(auth *cliproxyauth.Auth, defaultLocation string) string {
|
|
if explicit := helps.VertexExplicitOpenAPILocation(e.cfg, auth); explicit != "" {
|
|
return explicit
|
|
}
|
|
return helps.VertexOpenAPILocation(auth, defaultLocation)
|
|
}
|
|
|
|
func (e *GeminiVertexExecutor) resolveOpenAPICredentials(ctx context.Context, auth *cliproxyauth.Auth) (string, string, error) {
|
|
apiKey, baseURL := vertexAPICreds(auth)
|
|
if apiKey == "" || hasVertexServiceAccount(auth) {
|
|
projectID, location, saJSON, errCreds := vertexCreds(auth)
|
|
if errCreds != nil {
|
|
return "", "", errCreds
|
|
}
|
|
token, errTok := vertexAccessToken(ctx, e.cfg, auth, saJSON)
|
|
if errTok != nil {
|
|
log.Errorf("vertex executor: access token error: %v", errTok)
|
|
return "", "", statusErr{code: 500, msg: "internal server error"}
|
|
}
|
|
if strings.TrimSpace(token) == "" {
|
|
return "", "", statusErr{code: http.StatusUnauthorized, msg: "missing access token"}
|
|
}
|
|
authBaseURL := helps.VertexAuthBaseURL(auth)
|
|
openAPILocation := e.vertexOpenAPILocation(auth, location)
|
|
if strings.Contains(authBaseURL, "/locations/") {
|
|
openAPILocation = helps.VertexExplicitOpenAPILocation(e.cfg, auth)
|
|
}
|
|
openAPIBaseURL := helps.VertexServiceAccountOpenAPIBaseURL(authBaseURL, vertexAPIVersion, projectID, openAPILocation)
|
|
return openAPIBaseURL, token, nil
|
|
}
|
|
if helps.IsGoogleVertexHost(baseURL) {
|
|
return "", "", statusErr{code: http.StatusBadRequest, msg: "vertex endpoints/openapi on aiplatform.googleapis.com requires service account credentials"}
|
|
}
|
|
openAPILocation := helps.VertexExplicitOpenAPILocation(e.cfg, auth)
|
|
if !strings.Contains(baseURL, "/locations/") && openAPILocation == "" {
|
|
openAPILocation = e.vertexOpenAPILocation(auth, "")
|
|
}
|
|
openAPIBaseURL := helps.VertexAPIKeyOpenAPIBaseURL(baseURL, vertexAPIVersion, helps.VertexAuthProjectID(auth), openAPILocation)
|
|
return openAPIBaseURL, apiKey, nil
|
|
}
|
|
|
|
func (e *GeminiVertexExecutor) executeOpenAPI(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options) (resp cliproxyexecutor.Response, err error) {
|
|
req, opts = normalizeVertexOpenAPIRequest(req, opts)
|
|
openAPIBaseURL, token, errCreds := e.resolveOpenAPICredentials(ctx, auth)
|
|
if errCreds != nil {
|
|
baseModel := thinking.ParseSuffix(req.Model).ModelName
|
|
reporter := helps.NewExecutorUsageReporter(ctx, e, baseModel, auth)
|
|
reporter.TrackFailure(ctx, &errCreds)
|
|
return resp, errCreds
|
|
}
|
|
return NewOpenAICompatExecutor(e.Identifier(), e.cfg).executeWithCredentials(ctx, auth, req, opts, openAPIBaseURL, token, nil)
|
|
}
|
|
|
|
func (e *GeminiVertexExecutor) executeOpenAPIStream(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options) (*cliproxyexecutor.StreamResult, error) {
|
|
req, opts = normalizeVertexOpenAPIRequest(req, opts)
|
|
openAPIBaseURL, token, errCreds := e.resolveOpenAPICredentials(ctx, auth)
|
|
if errCreds != nil {
|
|
baseModel := thinking.ParseSuffix(req.Model).ModelName
|
|
reporter := helps.NewExecutorUsageReporter(ctx, e, baseModel, auth)
|
|
reporter.TrackFailure(ctx, &errCreds)
|
|
return nil, errCreds
|
|
}
|
|
return NewOpenAICompatExecutor(e.Identifier(), e.cfg).executeStreamWithCredentials(ctx, auth, req, opts, openAPIBaseURL, token, nil)
|
|
}
|
|
|
|
// Refresh refreshes the authentication credentials (no-op for Vertex).
|
|
func (e *GeminiVertexExecutor) Refresh(ctx context.Context, auth *cliproxyauth.Auth) (*cliproxyauth.Auth, error) {
|
|
if refreshed, handled, err := helps.RefreshAuthViaHome(ctx, e.cfg, auth); handled {
|
|
return refreshed, err
|
|
}
|
|
return auth, nil
|
|
}
|
|
|
|
// executeWithServiceAccount handles authentication using service account credentials.
|
|
// This method contains the original service account authentication logic.
|
|
func (e *GeminiVertexExecutor) executeWithServiceAccount(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options, projectID, location string, saJSON []byte) (resp cliproxyexecutor.Response, err error) {
|
|
baseModel := thinking.ParseSuffix(req.Model).ModelName
|
|
|
|
reporter := helps.NewExecutorUsageReporter(ctx, e, baseModel, auth)
|
|
defer reporter.TrackFailure(ctx, &err)
|
|
|
|
var body []byte
|
|
var originalTranslated []byte
|
|
|
|
// Handle Imagen models with special request format
|
|
if isImagenModel(baseModel) {
|
|
imagenBody, errImagen := convertToImagenRequest(req.Payload)
|
|
if errImagen != nil {
|
|
return resp, errImagen
|
|
}
|
|
body = imagenBody
|
|
originalTranslated = append([]byte(nil), imagenBody...)
|
|
if len(opts.OriginalRequest) > 0 {
|
|
originalTranslated, errImagen = convertToImagenRequest(opts.OriginalRequest)
|
|
if errImagen != nil {
|
|
return resp, errImagen
|
|
}
|
|
}
|
|
} else {
|
|
// Standard Gemini translation flow
|
|
from := opts.SourceFormat
|
|
to := sdktranslator.FromString("gemini")
|
|
|
|
originalPayloadSource := req.Payload
|
|
if len(opts.OriginalRequest) > 0 {
|
|
originalPayloadSource = opts.OriginalRequest
|
|
}
|
|
originalPayload := originalPayloadSource
|
|
originalTranslated = helps.TranslateRequestWithCodexMultiAgentV2(ctx, opts.Headers, e.cfg, from, to, baseModel, originalPayload, false)
|
|
body, err = helps.TranslateRequestReturningError(ctx, opts.Headers, e.cfg, from, to, baseModel, req.Payload, false, false)
|
|
if err != nil {
|
|
return resp, err
|
|
}
|
|
|
|
body, err = helps.ApplyRequestThinking(body, req, opts, from.String(), to.String(), e.Identifier())
|
|
if err != nil {
|
|
return resp, err
|
|
}
|
|
|
|
body = fixGeminiImageAspectRatio(baseModel, body)
|
|
body = helps.SetStringIfDifferent(body, "model", baseModel)
|
|
body = helps.StripVertexOpenAIResponsesToolCallIDs(body, from.String())
|
|
body = internalsignature.SanitizeGeminiRequestThoughtSignatures(body, "contents")
|
|
}
|
|
|
|
action := getVertexAction(baseModel, false)
|
|
if req.Metadata != nil {
|
|
if a, _ := req.Metadata["action"].(string); a == "countTokens" {
|
|
action = "countTokens"
|
|
}
|
|
}
|
|
body = helps.EnsureGeminiLeadingUserContent(body, "contents")
|
|
if action != "countTokens" {
|
|
body = helps.DropGeminiTrailingThoughtOnlyContent(body, "contents")
|
|
body = helps.EnsureGeminiTrailingUserContent(body, "contents")
|
|
}
|
|
baseURL := vertexBaseURL(location)
|
|
url := fmt.Sprintf("%s/%s/projects/%s/locations/%s/publishers/google/models/%s:%s", baseURL, vertexAPIVersion, projectID, location, baseModel, action)
|
|
if opts.Alt != "" && action != "countTokens" {
|
|
url = url + fmt.Sprintf("?$alt=%s", opts.Alt)
|
|
}
|
|
body, _ = sjson.DeleteBytes(body, "session_id")
|
|
|
|
body = helps.ApplyPayloadConfigWithRequest(e.cfg, baseModel, "gemini", opts.SourceFormat.String(), "", body, originalTranslated, helps.PayloadRequestedModel(opts, req.Model), helps.PayloadRequestPath(opts), opts.Headers)
|
|
reporter.SetTranslatedReasoningEffort(body, "gemini")
|
|
httpReq, errNewReq := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body))
|
|
if errNewReq != nil {
|
|
return resp, errNewReq
|
|
}
|
|
httpReq.Header.Set("Content-Type", "application/json")
|
|
if token, errTok := vertexAccessToken(ctx, e.cfg, auth, saJSON); errTok == nil && token != "" {
|
|
httpReq.Header.Set("Authorization", "Bearer "+token)
|
|
} else if errTok != nil {
|
|
log.Errorf("vertex executor: access token error: %v", errTok)
|
|
return resp, statusErr{code: 500, msg: "internal server error"}
|
|
}
|
|
applyGeminiHeaders(httpReq, auth, opts.Headers)
|
|
var attrs map[string]string
|
|
if auth != nil {
|
|
attrs = auth.Attributes
|
|
}
|
|
util.ApplyCustomHeadersFromAttrs(httpReq, attrs, opts.Headers)
|
|
|
|
var authID, authLabel, authType, authValue string
|
|
if auth != nil {
|
|
authID = auth.ID
|
|
authLabel = auth.Label
|
|
authType, authValue = auth.AccountInfo()
|
|
}
|
|
helps.RecordAPIRequest(ctx, e.cfg, helps.UpstreamRequestLog{
|
|
URL: url,
|
|
Method: http.MethodPost,
|
|
Headers: httpReq.Header.Clone(),
|
|
Body: body,
|
|
Provider: e.Identifier(),
|
|
AuthID: authID,
|
|
AuthLabel: authLabel,
|
|
AuthType: authType,
|
|
AuthValue: authValue,
|
|
})
|
|
|
|
httpClient := helps.NewProxyAwareHTTPClient(ctx, e.cfg, auth, 0)
|
|
httpClient = reporter.TrackHTTPClient(httpClient)
|
|
httpResp, errDo := httpClient.Do(httpReq)
|
|
if errDo != nil {
|
|
helps.RecordAPIResponseError(ctx, e.cfg, errDo)
|
|
return resp, errDo
|
|
}
|
|
defer func() {
|
|
if errClose := httpResp.Body.Close(); errClose != nil {
|
|
log.Errorf("vertex executor: close response body error: %v", errClose)
|
|
}
|
|
}()
|
|
helps.RecordAPIResponseMetadata(ctx, e.cfg, httpResp.StatusCode, httpResp.Header.Clone())
|
|
if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 {
|
|
b, _ := io.ReadAll(httpResp.Body)
|
|
helps.AppendAPIResponseChunk(ctx, e.cfg, b)
|
|
helps.LogWithRequestID(ctx).Debugf("request error, error status: %d, error message: %s", httpResp.StatusCode, helps.SummarizeErrorBody(httpResp.Header.Get("Content-Type"), b))
|
|
err = statusErr{code: httpResp.StatusCode, msg: string(b)}
|
|
return resp, err
|
|
}
|
|
data, errRead := io.ReadAll(httpResp.Body)
|
|
if errRead != nil {
|
|
helps.RecordAPIResponseError(ctx, e.cfg, errRead)
|
|
return resp, errRead
|
|
}
|
|
helps.AppendAPIResponseChunk(ctx, e.cfg, data)
|
|
reporter.ObserveResponseModel(data)
|
|
|
|
// For Imagen models, convert response to Gemini format before translation
|
|
// This ensures Imagen responses use the same format as gemini-3-pro-image-preview
|
|
if isImagenModel(baseModel) {
|
|
data = convertImagenToGeminiResponse(data, baseModel)
|
|
}
|
|
|
|
if blockMsg, blocked := geminiPromptBlockErrorMessage(data); blocked {
|
|
err = statusErr{code: http.StatusBadGateway, msg: blockMsg}
|
|
helps.RecordAPIResponseError(ctx, e.cfg, err)
|
|
reporter.PublishFailureWithDetail(ctx, helps.ParseGeminiUsage(data), err)
|
|
return cliproxyexecutor.Response{}, err
|
|
}
|
|
|
|
// Standard Gemini translation (works for both Gemini and converted Imagen responses)
|
|
responseFormat := cliproxyexecutor.ResponseFormatOrSource(opts)
|
|
to := sdktranslator.FromString("gemini")
|
|
var param any
|
|
out := sdktranslator.TranslateNonStream(ctx, to, responseFormat, req.Model, helps.ApplyPatchOriginalRequest(req, opts), body, data, ¶m)
|
|
if helps.ApplyPatchTranslationError(param) != nil || len(out) == 0 {
|
|
return cliproxyexecutor.Response{}, statusErr{code: http.StatusBadGateway, msg: helps.ApplyPatchUpstreamErrorMessage}
|
|
}
|
|
if errPayload, okErr := helps.TranslatedClaudeErrorPayload(responseFormat, out); okErr {
|
|
err = statusErr{code: http.StatusBadGateway, msg: errPayload}
|
|
reporter.PublishFailureWithDetail(ctx, helps.ParseGeminiUsage(data), err)
|
|
return cliproxyexecutor.Response{}, err
|
|
}
|
|
reporter.Publish(ctx, helps.ParseGeminiUsage(data))
|
|
if responseFormat == sdktranslator.FormatOpenAIResponse {
|
|
out = helps.EnsureResponsesUsageDetails(out)
|
|
}
|
|
resp = cliproxyexecutor.Response{Payload: out, Headers: httpResp.Header.Clone()}
|
|
return resp, nil
|
|
}
|
|
|
|
// executeWithAPIKey handles authentication using API key credentials.
|
|
func (e *GeminiVertexExecutor) executeWithAPIKey(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options, apiKey, baseURL string) (resp cliproxyexecutor.Response, err error) {
|
|
baseModel := thinking.ParseSuffix(req.Model).ModelName
|
|
|
|
reporter := helps.NewExecutorUsageReporter(ctx, e, baseModel, auth)
|
|
defer reporter.TrackFailure(ctx, &err)
|
|
|
|
from := opts.SourceFormat
|
|
responseFormat := cliproxyexecutor.ResponseFormatOrSource(opts)
|
|
to := sdktranslator.FromString("gemini")
|
|
|
|
originalPayloadSource := req.Payload
|
|
if len(opts.OriginalRequest) > 0 {
|
|
originalPayloadSource = opts.OriginalRequest
|
|
}
|
|
originalPayload := originalPayloadSource
|
|
originalTranslated := helps.TranslateRequestWithCodexMultiAgentV2(ctx, opts.Headers, e.cfg, from, to, baseModel, originalPayload, false)
|
|
body, err := helps.TranslateRequestReturningError(ctx, opts.Headers, e.cfg, from, to, baseModel, req.Payload, false, false)
|
|
if err != nil {
|
|
return resp, err
|
|
}
|
|
|
|
body, err = helps.ApplyRequestThinking(body, req, opts, from.String(), to.String(), e.Identifier())
|
|
if err != nil {
|
|
return resp, err
|
|
}
|
|
|
|
body = fixGeminiImageAspectRatio(baseModel, body)
|
|
requestedModel := helps.PayloadRequestedModel(opts, req.Model)
|
|
requestPath := helps.PayloadRequestPath(opts)
|
|
body = helps.SetStringIfDifferent(body, "model", baseModel)
|
|
body = helps.StripVertexOpenAIResponsesToolCallIDs(body, from.String())
|
|
body = internalsignature.SanitizeGeminiRequestThoughtSignatures(body, "contents")
|
|
|
|
action := getVertexAction(baseModel, false)
|
|
if req.Metadata != nil {
|
|
if a, _ := req.Metadata["action"].(string); a == "countTokens" {
|
|
action = "countTokens"
|
|
}
|
|
}
|
|
body = helps.EnsureGeminiLeadingUserContent(body, "contents")
|
|
if action != "countTokens" {
|
|
body = helps.DropGeminiTrailingThoughtOnlyContent(body, "contents")
|
|
body = helps.EnsureGeminiTrailingUserContent(body, "contents")
|
|
}
|
|
|
|
// For API key auth, use simpler URL format without project/location.
|
|
// The helper honors base URLs that already encode "/publishers/..." so
|
|
// configurations like ".../v1/projects/P/locations/L/publishers/google/models"
|
|
// keep working without a duplicated "/v1" segment.
|
|
url := vertexAPIKeyModelsURL(baseURL, baseModel, action)
|
|
if opts.Alt != "" && action != "countTokens" {
|
|
url = url + fmt.Sprintf("?$alt=%s", opts.Alt)
|
|
}
|
|
body, _ = sjson.DeleteBytes(body, "session_id")
|
|
|
|
body = helps.ApplyPayloadConfigWithRequest(e.cfg, baseModel, to.String(), from.String(), "", body, originalTranslated, requestedModel, requestPath, opts.Headers)
|
|
reporter.SetTranslatedReasoningEffort(body, to.String())
|
|
httpReq, errNewReq := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body))
|
|
if errNewReq != nil {
|
|
return resp, errNewReq
|
|
}
|
|
httpReq.Header.Set("Content-Type", "application/json")
|
|
if apiKey != "" {
|
|
httpReq.Header.Set("x-goog-api-key", apiKey)
|
|
}
|
|
applyGeminiHeaders(httpReq, auth, opts.Headers)
|
|
var attrs map[string]string
|
|
if auth != nil {
|
|
attrs = auth.Attributes
|
|
}
|
|
util.ApplyCustomHeadersFromAttrs(httpReq, attrs, opts.Headers)
|
|
|
|
var authID, authLabel, authType, authValue string
|
|
if auth != nil {
|
|
authID = auth.ID
|
|
authLabel = auth.Label
|
|
authType, authValue = auth.AccountInfo()
|
|
}
|
|
helps.RecordAPIRequest(ctx, e.cfg, helps.UpstreamRequestLog{
|
|
URL: url,
|
|
Method: http.MethodPost,
|
|
Headers: httpReq.Header.Clone(),
|
|
Body: body,
|
|
Provider: e.Identifier(),
|
|
AuthID: authID,
|
|
AuthLabel: authLabel,
|
|
AuthType: authType,
|
|
AuthValue: authValue,
|
|
})
|
|
|
|
httpClient := helps.NewProxyAwareHTTPClient(ctx, e.cfg, auth, 0)
|
|
httpClient = reporter.TrackHTTPClient(httpClient)
|
|
httpResp, errDo := httpClient.Do(httpReq)
|
|
if errDo != nil {
|
|
helps.RecordAPIResponseError(ctx, e.cfg, errDo)
|
|
return resp, errDo
|
|
}
|
|
defer func() {
|
|
if errClose := httpResp.Body.Close(); errClose != nil {
|
|
log.Errorf("vertex executor: close response body error: %v", errClose)
|
|
}
|
|
}()
|
|
helps.RecordAPIResponseMetadata(ctx, e.cfg, httpResp.StatusCode, httpResp.Header.Clone())
|
|
if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 {
|
|
b, _ := io.ReadAll(httpResp.Body)
|
|
helps.AppendAPIResponseChunk(ctx, e.cfg, b)
|
|
helps.LogWithRequestID(ctx).Debugf("request error, error status: %d, error message: %s", httpResp.StatusCode, helps.SummarizeErrorBody(httpResp.Header.Get("Content-Type"), b))
|
|
err = statusErr{code: httpResp.StatusCode, msg: string(b)}
|
|
return resp, err
|
|
}
|
|
data, errRead := io.ReadAll(httpResp.Body)
|
|
if errRead != nil {
|
|
helps.RecordAPIResponseError(ctx, e.cfg, errRead)
|
|
return resp, errRead
|
|
}
|
|
helps.AppendAPIResponseChunk(ctx, e.cfg, data)
|
|
reporter.ObserveResponseModel(data)
|
|
if blockMsg, blocked := geminiPromptBlockErrorMessage(data); blocked {
|
|
err = statusErr{code: http.StatusBadGateway, msg: blockMsg}
|
|
helps.RecordAPIResponseError(ctx, e.cfg, err)
|
|
reporter.PublishFailureWithDetail(ctx, helps.ParseGeminiUsage(data), err)
|
|
return cliproxyexecutor.Response{}, err
|
|
}
|
|
var param any
|
|
out := sdktranslator.TranslateNonStream(ctx, to, responseFormat, req.Model, helps.ApplyPatchOriginalRequest(req, opts), body, data, ¶m)
|
|
if helps.ApplyPatchTranslationError(param) != nil || len(out) == 0 {
|
|
return cliproxyexecutor.Response{}, statusErr{code: http.StatusBadGateway, msg: helps.ApplyPatchUpstreamErrorMessage}
|
|
}
|
|
if errPayload, okErr := helps.TranslatedClaudeErrorPayload(responseFormat, out); okErr {
|
|
err = statusErr{code: http.StatusBadGateway, msg: errPayload}
|
|
reporter.PublishFailureWithDetail(ctx, helps.ParseGeminiUsage(data), err)
|
|
return cliproxyexecutor.Response{}, err
|
|
}
|
|
reporter.Publish(ctx, helps.ParseGeminiUsage(data))
|
|
if responseFormat == sdktranslator.FormatOpenAIResponse {
|
|
out = helps.EnsureResponsesUsageDetails(out)
|
|
}
|
|
resp = cliproxyexecutor.Response{Payload: out, Headers: httpResp.Header.Clone()}
|
|
return resp, nil
|
|
}
|
|
|
|
// executeStreamWithServiceAccount handles streaming authentication using service account credentials.
|
|
func (e *GeminiVertexExecutor) executeStreamWithServiceAccount(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options, projectID, location string, saJSON []byte) (_ *cliproxyexecutor.StreamResult, err error) {
|
|
baseModel := thinking.ParseSuffix(req.Model).ModelName
|
|
|
|
reporter := helps.NewExecutorUsageReporter(ctx, e, baseModel, auth)
|
|
defer reporter.TrackFailure(ctx, &err)
|
|
|
|
from := opts.SourceFormat
|
|
responseFormat := cliproxyexecutor.ResponseFormatOrSource(opts)
|
|
to := sdktranslator.FromString("gemini")
|
|
|
|
originalPayloadSource := req.Payload
|
|
if len(opts.OriginalRequest) > 0 {
|
|
originalPayloadSource = opts.OriginalRequest
|
|
}
|
|
originalPayload := originalPayloadSource
|
|
originalTranslated := helps.TranslateRequestWithCodexMultiAgentV2(ctx, opts.Headers, e.cfg, from, to, baseModel, originalPayload, true)
|
|
body, err := helps.TranslateRequestReturningError(ctx, opts.Headers, e.cfg, from, to, baseModel, req.Payload, true, false)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
body, err = helps.ApplyRequestThinking(body, req, opts, from.String(), to.String(), e.Identifier())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
body = fixGeminiImageAspectRatio(baseModel, body)
|
|
requestedModel := helps.PayloadRequestedModel(opts, req.Model)
|
|
requestPath := helps.PayloadRequestPath(opts)
|
|
body = helps.SetStringIfDifferent(body, "model", baseModel)
|
|
body = helps.StripVertexOpenAIResponsesToolCallIDs(body, from.String())
|
|
body = internalsignature.SanitizeGeminiRequestThoughtSignatures(body, "contents")
|
|
|
|
action := getVertexAction(baseModel, true)
|
|
body = helps.DropGeminiTrailingThoughtOnlyContent(body, "contents")
|
|
body = helps.EnsureGeminiBoundaryUserContent(body, "contents")
|
|
baseURL := vertexBaseURL(location)
|
|
url := fmt.Sprintf("%s/%s/projects/%s/locations/%s/publishers/google/models/%s:%s", baseURL, vertexAPIVersion, projectID, location, baseModel, action)
|
|
// Imagen models don't support streaming, skip SSE params
|
|
if !isImagenModel(baseModel) {
|
|
if opts.Alt == "" {
|
|
url = url + "?alt=sse"
|
|
} else {
|
|
url = url + fmt.Sprintf("?$alt=%s", opts.Alt)
|
|
}
|
|
}
|
|
body, _ = sjson.DeleteBytes(body, "session_id")
|
|
|
|
body = helps.ApplyPayloadConfigWithRequest(e.cfg, baseModel, to.String(), from.String(), "", body, originalTranslated, requestedModel, requestPath, opts.Headers)
|
|
reporter.SetTranslatedReasoningEffort(body, to.String())
|
|
httpReq, errNewReq := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body))
|
|
if errNewReq != nil {
|
|
return nil, errNewReq
|
|
}
|
|
httpReq.Header.Set("Content-Type", "application/json")
|
|
if token, errTok := vertexAccessToken(ctx, e.cfg, auth, saJSON); errTok == nil && token != "" {
|
|
httpReq.Header.Set("Authorization", "Bearer "+token)
|
|
} else if errTok != nil {
|
|
log.Errorf("vertex executor: access token error: %v", errTok)
|
|
return nil, statusErr{code: 500, msg: "internal server error"}
|
|
}
|
|
applyGeminiHeaders(httpReq, auth, opts.Headers)
|
|
var attrs map[string]string
|
|
if auth != nil {
|
|
attrs = auth.Attributes
|
|
}
|
|
util.ApplyCustomHeadersFromAttrs(httpReq, attrs, opts.Headers)
|
|
|
|
var authID, authLabel, authType, authValue string
|
|
if auth != nil {
|
|
authID = auth.ID
|
|
authLabel = auth.Label
|
|
authType, authValue = auth.AccountInfo()
|
|
}
|
|
helps.RecordAPIRequest(ctx, e.cfg, helps.UpstreamRequestLog{
|
|
URL: url,
|
|
Method: http.MethodPost,
|
|
Headers: httpReq.Header.Clone(),
|
|
Body: body,
|
|
Provider: e.Identifier(),
|
|
AuthID: authID,
|
|
AuthLabel: authLabel,
|
|
AuthType: authType,
|
|
AuthValue: authValue,
|
|
})
|
|
|
|
httpClient := helps.NewProxyAwareHTTPClient(ctx, e.cfg, auth, 0)
|
|
httpClient = reporter.TrackHTTPClient(httpClient)
|
|
httpResp, errDo := httpClient.Do(httpReq)
|
|
if errDo != nil {
|
|
helps.RecordAPIResponseError(ctx, e.cfg, errDo)
|
|
return nil, errDo
|
|
}
|
|
helps.RecordAPIResponseMetadata(ctx, e.cfg, httpResp.StatusCode, httpResp.Header.Clone())
|
|
if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 {
|
|
b, _ := io.ReadAll(httpResp.Body)
|
|
helps.AppendAPIResponseChunk(ctx, e.cfg, b)
|
|
helps.LogWithRequestID(ctx).Debugf("request error, error status: %d, error message: %s", httpResp.StatusCode, helps.SummarizeErrorBody(httpResp.Header.Get("Content-Type"), b))
|
|
if errClose := httpResp.Body.Close(); errClose != nil {
|
|
log.Errorf("vertex executor: close response body error: %v", errClose)
|
|
}
|
|
return nil, statusErr{code: httpResp.StatusCode, msg: string(b)}
|
|
}
|
|
|
|
out := make(chan cliproxyexecutor.StreamChunk, 1)
|
|
go func() {
|
|
defer close(out)
|
|
defer reporter.EnsurePublished(ctx)
|
|
defer func() {
|
|
if errClose := httpResp.Body.Close(); errClose != nil {
|
|
log.Errorf("vertex executor: close response body error: %v", errClose)
|
|
}
|
|
}()
|
|
scanner := bufio.NewScanner(httpResp.Body)
|
|
scanner.Buffer(nil, streamScannerBuffer)
|
|
claudeInputTokens := helps.NewClaudeInputTokenState(from, to, responseFormat, originalPayload)
|
|
var streamUsage helps.StreamUsageBuffer
|
|
defer streamUsage.Publish(ctx, reporter)
|
|
var streamErr error
|
|
defer func() {
|
|
_ = helps.StopTranslatedClaudeStream(ctx, &streamErr, reporter, &streamUsage, out)
|
|
}()
|
|
var terminalDelivered bool
|
|
var sawFinishReason bool
|
|
var param any
|
|
helps.InitializeApplyPatchStream(ctx, to, responseFormat, req.Model, helps.ApplyPatchOriginalRequest(req, opts), body, ¶m)
|
|
for scanner.Scan() {
|
|
line := scanner.Bytes()
|
|
helps.AppendAPIResponseChunk(ctx, e.cfg, line)
|
|
reporter.ObserveResponseModel(line)
|
|
rawPayload := helps.JSONPayload(line)
|
|
if !sawFinishReason && geminiStreamHasFinishSignal(rawPayload) {
|
|
sawFinishReason = true
|
|
}
|
|
if detail, ok := helps.ParseGeminiStreamUsage(line); ok {
|
|
streamUsage.Observe(detail, true)
|
|
}
|
|
if blockMsg, blocked := geminiPromptBlockErrorMessage(rawPayload); blocked {
|
|
blockErr := statusErr{code: http.StatusBadGateway, msg: blockMsg}
|
|
helps.RecordAPIResponseError(ctx, e.cfg, blockErr)
|
|
if !streamUsage.PublishFailure(ctx, reporter, blockErr) {
|
|
reporter.PublishFailure(ctx, blockErr)
|
|
}
|
|
select {
|
|
case out <- cliproxyexecutor.StreamChunk{Err: blockErr}:
|
|
case <-ctx.Done():
|
|
}
|
|
return
|
|
}
|
|
lines := helps.TranslateStreamWithClaudeInputTokens(ctx, to, responseFormat, req.Model, helps.ApplyPatchOriginalRequest(req, opts), body, bytes.Clone(line), ¶m, claudeInputTokens)
|
|
helps.RecordApplyPatchStreamFailure(ctx, param, reporter, statusErr{code: http.StatusBadGateway, msg: helps.ApplyPatchUpstreamErrorMessage})
|
|
helps.CaptureTranslatedClaudeStreamError(responseFormat, lines, &streamErr, func(msg string) error {
|
|
return statusErr{code: http.StatusBadGateway, msg: msg}
|
|
})
|
|
for i := range lines {
|
|
select {
|
|
case out <- cliproxyexecutor.StreamChunk{Payload: lines[i]}:
|
|
if helps.IsGeminiTerminalStreamChunk(lines[i]) {
|
|
terminalDelivered = true
|
|
}
|
|
case <-ctx.Done():
|
|
return
|
|
}
|
|
}
|
|
if helps.StopApplyPatchStream(ctx, param, reporter, out, statusErr{code: http.StatusBadGateway, msg: helps.ApplyPatchUpstreamErrorMessage}) {
|
|
return
|
|
}
|
|
}
|
|
if helps.EndApplyPatchStream(ctx, param, reporter, out, statusErr{code: http.StatusBadGateway, msg: helps.ApplyPatchUpstreamErrorMessage}) {
|
|
return
|
|
}
|
|
if helps.StopTranslatedClaudeStream(ctx, &streamErr, reporter, &streamUsage, out) {
|
|
return
|
|
}
|
|
if errScan := scanner.Err(); errScan != nil {
|
|
if terminalDelivered && errors.Is(errScan, context.Canceled) {
|
|
return
|
|
}
|
|
helps.RecordAPIResponseError(ctx, e.cfg, errScan)
|
|
reporter.PublishFailure(ctx, errScan)
|
|
select {
|
|
case out <- cliproxyexecutor.StreamChunk{Err: errScan}:
|
|
case <-ctx.Done():
|
|
}
|
|
return
|
|
}
|
|
if ctx.Err() != nil {
|
|
return
|
|
}
|
|
if (responseFormat == sdktranslator.FormatClaude || responseFormat == sdktranslator.FormatOpenAI) && !sawFinishReason {
|
|
truncErr := statusErr{code: http.StatusBadGateway, msg: "upstream stream closed before finishReason"}
|
|
helps.RecordAPIResponseError(ctx, e.cfg, truncErr)
|
|
if !streamUsage.PublishFailure(ctx, reporter, truncErr) {
|
|
reporter.PublishFailure(ctx, truncErr)
|
|
}
|
|
select {
|
|
case out <- cliproxyexecutor.StreamChunk{Err: truncErr}:
|
|
case <-ctx.Done():
|
|
}
|
|
return
|
|
}
|
|
lines := helps.TranslateStreamWithClaudeInputTokens(ctx, to, responseFormat, req.Model, helps.ApplyPatchOriginalRequest(req, opts), body, []byte("[DONE]"), ¶m, claudeInputTokens)
|
|
helps.RecordApplyPatchStreamFailure(ctx, param, reporter, statusErr{code: http.StatusBadGateway, msg: helps.ApplyPatchUpstreamErrorMessage})
|
|
helps.CaptureTranslatedClaudeStreamError(responseFormat, lines, &streamErr, func(msg string) error {
|
|
return statusErr{code: http.StatusBadGateway, msg: msg}
|
|
})
|
|
for i := range lines {
|
|
select {
|
|
case out <- cliproxyexecutor.StreamChunk{Payload: lines[i]}:
|
|
case <-ctx.Done():
|
|
return
|
|
}
|
|
}
|
|
if helps.StopApplyPatchStream(ctx, param, reporter, out, statusErr{code: http.StatusBadGateway, msg: helps.ApplyPatchUpstreamErrorMessage}) {
|
|
return
|
|
}
|
|
if helps.StopTranslatedClaudeStream(ctx, &streamErr, reporter, &streamUsage, out) {
|
|
return
|
|
}
|
|
}()
|
|
return &cliproxyexecutor.StreamResult{Headers: httpResp.Header.Clone(), Chunks: out}, nil
|
|
}
|
|
|
|
// executeStreamWithAPIKey handles streaming authentication using API key credentials.
|
|
func (e *GeminiVertexExecutor) executeStreamWithAPIKey(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options, apiKey, baseURL string) (_ *cliproxyexecutor.StreamResult, err error) {
|
|
baseModel := thinking.ParseSuffix(req.Model).ModelName
|
|
|
|
reporter := helps.NewExecutorUsageReporter(ctx, e, baseModel, auth)
|
|
defer reporter.TrackFailure(ctx, &err)
|
|
|
|
from := opts.SourceFormat
|
|
responseFormat := cliproxyexecutor.ResponseFormatOrSource(opts)
|
|
to := sdktranslator.FromString("gemini")
|
|
|
|
originalPayloadSource := req.Payload
|
|
if len(opts.OriginalRequest) > 0 {
|
|
originalPayloadSource = opts.OriginalRequest
|
|
}
|
|
originalPayload := originalPayloadSource
|
|
originalTranslated := helps.TranslateRequestWithCodexMultiAgentV2(ctx, opts.Headers, e.cfg, from, to, baseModel, originalPayload, true)
|
|
body, err := helps.TranslateRequestReturningError(ctx, opts.Headers, e.cfg, from, to, baseModel, req.Payload, true, false)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
body, err = helps.ApplyRequestThinking(body, req, opts, from.String(), to.String(), e.Identifier())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
body = fixGeminiImageAspectRatio(baseModel, body)
|
|
requestedModel := helps.PayloadRequestedModel(opts, req.Model)
|
|
requestPath := helps.PayloadRequestPath(opts)
|
|
body = helps.SetStringIfDifferent(body, "model", baseModel)
|
|
body = helps.StripVertexOpenAIResponsesToolCallIDs(body, from.String())
|
|
body = internalsignature.SanitizeGeminiRequestThoughtSignatures(body, "contents")
|
|
|
|
action := getVertexAction(baseModel, true)
|
|
body = helps.DropGeminiTrailingThoughtOnlyContent(body, "contents")
|
|
body = helps.EnsureGeminiBoundaryUserContent(body, "contents")
|
|
// For API key auth, use simpler URL format without project/location
|
|
url := vertexAPIKeyModelsURL(baseURL, baseModel, action)
|
|
// Imagen models don't support streaming, skip SSE params
|
|
if !isImagenModel(baseModel) {
|
|
if opts.Alt == "" {
|
|
url = url + "?alt=sse"
|
|
} else {
|
|
url = url + fmt.Sprintf("?$alt=%s", opts.Alt)
|
|
}
|
|
}
|
|
body, _ = sjson.DeleteBytes(body, "session_id")
|
|
|
|
body = helps.ApplyPayloadConfigWithRequest(e.cfg, baseModel, to.String(), from.String(), "", body, originalTranslated, requestedModel, requestPath, opts.Headers)
|
|
reporter.SetTranslatedReasoningEffort(body, to.String())
|
|
httpReq, errNewReq := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body))
|
|
if errNewReq != nil {
|
|
return nil, errNewReq
|
|
}
|
|
httpReq.Header.Set("Content-Type", "application/json")
|
|
if apiKey != "" {
|
|
httpReq.Header.Set("x-goog-api-key", apiKey)
|
|
}
|
|
applyGeminiHeaders(httpReq, auth, opts.Headers)
|
|
var attrs map[string]string
|
|
if auth != nil {
|
|
attrs = auth.Attributes
|
|
}
|
|
util.ApplyCustomHeadersFromAttrs(httpReq, attrs, opts.Headers)
|
|
|
|
var authID, authLabel, authType, authValue string
|
|
if auth != nil {
|
|
authID = auth.ID
|
|
authLabel = auth.Label
|
|
authType, authValue = auth.AccountInfo()
|
|
}
|
|
helps.RecordAPIRequest(ctx, e.cfg, helps.UpstreamRequestLog{
|
|
URL: url,
|
|
Method: http.MethodPost,
|
|
Headers: httpReq.Header.Clone(),
|
|
Body: body,
|
|
Provider: e.Identifier(),
|
|
AuthID: authID,
|
|
AuthLabel: authLabel,
|
|
AuthType: authType,
|
|
AuthValue: authValue,
|
|
})
|
|
|
|
httpClient := helps.NewProxyAwareHTTPClient(ctx, e.cfg, auth, 0)
|
|
httpClient = reporter.TrackHTTPClient(httpClient)
|
|
httpResp, errDo := httpClient.Do(httpReq)
|
|
if errDo != nil {
|
|
helps.RecordAPIResponseError(ctx, e.cfg, errDo)
|
|
return nil, errDo
|
|
}
|
|
helps.RecordAPIResponseMetadata(ctx, e.cfg, httpResp.StatusCode, httpResp.Header.Clone())
|
|
if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 {
|
|
b, _ := io.ReadAll(httpResp.Body)
|
|
helps.AppendAPIResponseChunk(ctx, e.cfg, b)
|
|
helps.LogWithRequestID(ctx).Debugf("request error, error status: %d, error message: %s", httpResp.StatusCode, helps.SummarizeErrorBody(httpResp.Header.Get("Content-Type"), b))
|
|
if errClose := httpResp.Body.Close(); errClose != nil {
|
|
log.Errorf("vertex executor: close response body error: %v", errClose)
|
|
}
|
|
return nil, statusErr{code: httpResp.StatusCode, msg: string(b)}
|
|
}
|
|
|
|
out := make(chan cliproxyexecutor.StreamChunk, 1)
|
|
go func() {
|
|
defer close(out)
|
|
defer reporter.EnsurePublished(ctx)
|
|
defer func() {
|
|
if errClose := httpResp.Body.Close(); errClose != nil {
|
|
log.Errorf("vertex executor: close response body error: %v", errClose)
|
|
}
|
|
}()
|
|
scanner := bufio.NewScanner(httpResp.Body)
|
|
scanner.Buffer(nil, streamScannerBuffer)
|
|
claudeInputTokens := helps.NewClaudeInputTokenState(from, to, responseFormat, originalPayload)
|
|
var streamUsage helps.StreamUsageBuffer
|
|
defer streamUsage.Publish(ctx, reporter)
|
|
var streamErr error
|
|
defer func() {
|
|
_ = helps.StopTranslatedClaudeStream(ctx, &streamErr, reporter, &streamUsage, out)
|
|
}()
|
|
var terminalDelivered bool
|
|
var sawFinishReason bool
|
|
var param any
|
|
helps.InitializeApplyPatchStream(ctx, to, responseFormat, req.Model, helps.ApplyPatchOriginalRequest(req, opts), body, ¶m)
|
|
for scanner.Scan() {
|
|
line := scanner.Bytes()
|
|
helps.AppendAPIResponseChunk(ctx, e.cfg, line)
|
|
reporter.ObserveResponseModel(line)
|
|
rawPayload := helps.JSONPayload(line)
|
|
if !sawFinishReason && geminiStreamHasFinishSignal(rawPayload) {
|
|
sawFinishReason = true
|
|
}
|
|
if detail, ok := helps.ParseGeminiStreamUsage(line); ok {
|
|
streamUsage.Observe(detail, true)
|
|
}
|
|
if blockMsg, blocked := geminiPromptBlockErrorMessage(rawPayload); blocked {
|
|
blockErr := statusErr{code: http.StatusBadGateway, msg: blockMsg}
|
|
helps.RecordAPIResponseError(ctx, e.cfg, blockErr)
|
|
if !streamUsage.PublishFailure(ctx, reporter, blockErr) {
|
|
reporter.PublishFailure(ctx, blockErr)
|
|
}
|
|
select {
|
|
case out <- cliproxyexecutor.StreamChunk{Err: blockErr}:
|
|
case <-ctx.Done():
|
|
}
|
|
return
|
|
}
|
|
lines := helps.TranslateStreamWithClaudeInputTokens(ctx, to, responseFormat, req.Model, helps.ApplyPatchOriginalRequest(req, opts), body, bytes.Clone(line), ¶m, claudeInputTokens)
|
|
helps.RecordApplyPatchStreamFailure(ctx, param, reporter, statusErr{code: http.StatusBadGateway, msg: helps.ApplyPatchUpstreamErrorMessage})
|
|
helps.CaptureTranslatedClaudeStreamError(responseFormat, lines, &streamErr, func(msg string) error {
|
|
return statusErr{code: http.StatusBadGateway, msg: msg}
|
|
})
|
|
for i := range lines {
|
|
select {
|
|
case out <- cliproxyexecutor.StreamChunk{Payload: lines[i]}:
|
|
if helps.IsGeminiTerminalStreamChunk(lines[i]) {
|
|
terminalDelivered = true
|
|
}
|
|
case <-ctx.Done():
|
|
return
|
|
}
|
|
}
|
|
if helps.StopApplyPatchStream(ctx, param, reporter, out, statusErr{code: http.StatusBadGateway, msg: helps.ApplyPatchUpstreamErrorMessage}) {
|
|
return
|
|
}
|
|
}
|
|
if helps.EndApplyPatchStream(ctx, param, reporter, out, statusErr{code: http.StatusBadGateway, msg: helps.ApplyPatchUpstreamErrorMessage}) {
|
|
return
|
|
}
|
|
if helps.StopTranslatedClaudeStream(ctx, &streamErr, reporter, &streamUsage, out) {
|
|
return
|
|
}
|
|
if errScan := scanner.Err(); errScan != nil {
|
|
if terminalDelivered && errors.Is(errScan, context.Canceled) {
|
|
return
|
|
}
|
|
helps.RecordAPIResponseError(ctx, e.cfg, errScan)
|
|
reporter.PublishFailure(ctx, errScan)
|
|
select {
|
|
case out <- cliproxyexecutor.StreamChunk{Err: errScan}:
|
|
case <-ctx.Done():
|
|
}
|
|
return
|
|
}
|
|
if ctx.Err() != nil {
|
|
return
|
|
}
|
|
if (responseFormat == sdktranslator.FormatClaude || responseFormat == sdktranslator.FormatOpenAI) && !sawFinishReason {
|
|
truncErr := statusErr{code: http.StatusBadGateway, msg: "upstream stream closed before finishReason"}
|
|
helps.RecordAPIResponseError(ctx, e.cfg, truncErr)
|
|
if !streamUsage.PublishFailure(ctx, reporter, truncErr) {
|
|
reporter.PublishFailure(ctx, truncErr)
|
|
}
|
|
select {
|
|
case out <- cliproxyexecutor.StreamChunk{Err: truncErr}:
|
|
case <-ctx.Done():
|
|
}
|
|
return
|
|
}
|
|
lines := helps.TranslateStreamWithClaudeInputTokens(ctx, to, responseFormat, req.Model, helps.ApplyPatchOriginalRequest(req, opts), body, []byte("[DONE]"), ¶m, claudeInputTokens)
|
|
helps.RecordApplyPatchStreamFailure(ctx, param, reporter, statusErr{code: http.StatusBadGateway, msg: helps.ApplyPatchUpstreamErrorMessage})
|
|
helps.CaptureTranslatedClaudeStreamError(responseFormat, lines, &streamErr, func(msg string) error {
|
|
return statusErr{code: http.StatusBadGateway, msg: msg}
|
|
})
|
|
for i := range lines {
|
|
select {
|
|
case out <- cliproxyexecutor.StreamChunk{Payload: lines[i]}:
|
|
case <-ctx.Done():
|
|
return
|
|
}
|
|
}
|
|
if helps.StopApplyPatchStream(ctx, param, reporter, out, statusErr{code: http.StatusBadGateway, msg: helps.ApplyPatchUpstreamErrorMessage}) {
|
|
return
|
|
}
|
|
if helps.StopTranslatedClaudeStream(ctx, &streamErr, reporter, &streamUsage, out) {
|
|
return
|
|
}
|
|
}()
|
|
return &cliproxyexecutor.StreamResult{Headers: httpResp.Header.Clone(), Chunks: out}, nil
|
|
}
|
|
|
|
// countTokensWithServiceAccount counts tokens using service account credentials.
|
|
func (e *GeminiVertexExecutor) countTokensWithServiceAccount(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options, projectID, location string, saJSON []byte) (cliproxyexecutor.Response, error) {
|
|
baseModel := thinking.ParseSuffix(req.Model).ModelName
|
|
|
|
from := opts.SourceFormat
|
|
responseFormat := cliproxyexecutor.ResponseFormatOrSource(opts)
|
|
to := sdktranslator.FromString("gemini")
|
|
|
|
translatedReq, err := helps.TranslateRequestReturningError(ctx, opts.Headers, e.cfg, from, to, baseModel, req.Payload, false, false)
|
|
if err != nil {
|
|
return cliproxyexecutor.Response{}, err
|
|
}
|
|
originalTranslatedForPayload := append([]byte(nil), translatedReq...)
|
|
if len(opts.OriginalRequest) > 0 {
|
|
originalTranslatedForPayload = helps.TranslateRequestWithCodexMultiAgentV2(ctx, opts.Headers, e.cfg, from, to, baseModel, opts.OriginalRequest, false)
|
|
}
|
|
|
|
translatedReq, err = helps.ApplyRequestThinking(translatedReq, req, opts, from.String(), to.String(), e.Identifier())
|
|
if err != nil {
|
|
return cliproxyexecutor.Response{}, err
|
|
}
|
|
|
|
translatedReq = fixGeminiImageAspectRatio(baseModel, translatedReq)
|
|
translatedReq, _ = sjson.SetBytes(translatedReq, "model", baseModel)
|
|
translatedReq = helps.StripVertexOpenAIResponsesToolCallIDs(translatedReq, from.String())
|
|
respCtx := context.WithValue(ctx, "alt", opts.Alt)
|
|
translatedReq, _ = sjson.DeleteBytes(translatedReq, "tools")
|
|
translatedReq, _ = sjson.DeleteBytes(translatedReq, "generationConfig")
|
|
translatedReq, _ = sjson.DeleteBytes(translatedReq, "safetySettings")
|
|
translatedReq = internalsignature.SanitizeGeminiRequestThoughtSignatures(translatedReq, "contents")
|
|
translatedReq = helps.EnsureGeminiLeadingUserContent(translatedReq, "contents")
|
|
|
|
baseURL := vertexBaseURL(location)
|
|
url := fmt.Sprintf("%s/%s/projects/%s/locations/%s/publishers/google/models/%s:%s", baseURL, vertexAPIVersion, projectID, location, baseModel, "countTokens")
|
|
|
|
translatedReq = helps.NewPayloadFinalizer(e.cfg, e.Identifier(), baseModel, to.String(), "", originalTranslatedForPayload, req, opts)(translatedReq)
|
|
httpReq, errNewReq := http.NewRequestWithContext(respCtx, http.MethodPost, url, bytes.NewReader(translatedReq))
|
|
if errNewReq != nil {
|
|
return cliproxyexecutor.Response{}, errNewReq
|
|
}
|
|
httpReq.Header.Set("Content-Type", "application/json")
|
|
if token, errTok := vertexAccessToken(ctx, e.cfg, auth, saJSON); errTok == nil && token != "" {
|
|
httpReq.Header.Set("Authorization", "Bearer "+token)
|
|
} else if errTok != nil {
|
|
log.Errorf("vertex executor: access token error: %v", errTok)
|
|
return cliproxyexecutor.Response{}, statusErr{code: 500, msg: "internal server error"}
|
|
}
|
|
applyGeminiHeaders(httpReq, auth, opts.Headers)
|
|
var attrs map[string]string
|
|
if auth != nil {
|
|
attrs = auth.Attributes
|
|
}
|
|
util.ApplyCustomHeadersFromAttrs(httpReq, attrs, opts.Headers)
|
|
|
|
var authID, authLabel, authType, authValue string
|
|
if auth != nil {
|
|
authID = auth.ID
|
|
authLabel = auth.Label
|
|
authType, authValue = auth.AccountInfo()
|
|
}
|
|
helps.RecordAPIRequest(ctx, e.cfg, helps.UpstreamRequestLog{
|
|
URL: url,
|
|
Method: http.MethodPost,
|
|
Headers: httpReq.Header.Clone(),
|
|
Body: translatedReq,
|
|
Provider: e.Identifier(),
|
|
AuthID: authID,
|
|
AuthLabel: authLabel,
|
|
AuthType: authType,
|
|
AuthValue: authValue,
|
|
})
|
|
|
|
httpClient := helps.NewProxyAwareHTTPClient(ctx, e.cfg, auth, 0)
|
|
cliproxyexecutor.MarkUpstreamAttempt(ctx)
|
|
httpResp, errDo := httpClient.Do(httpReq)
|
|
if errDo != nil {
|
|
helps.RecordAPIResponseError(ctx, e.cfg, errDo)
|
|
return cliproxyexecutor.Response{}, errDo
|
|
}
|
|
defer func() {
|
|
if errClose := httpResp.Body.Close(); errClose != nil {
|
|
log.Errorf("vertex executor: close response body error: %v", errClose)
|
|
}
|
|
}()
|
|
helps.RecordAPIResponseMetadata(ctx, e.cfg, httpResp.StatusCode, httpResp.Header.Clone())
|
|
if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 {
|
|
b, _ := io.ReadAll(httpResp.Body)
|
|
helps.AppendAPIResponseChunk(ctx, e.cfg, b)
|
|
helps.LogWithRequestID(ctx).Debugf("request error, error status: %d, error message: %s", httpResp.StatusCode, helps.SummarizeErrorBody(httpResp.Header.Get("Content-Type"), b))
|
|
return cliproxyexecutor.Response{}, statusErr{code: httpResp.StatusCode, msg: string(b)}
|
|
}
|
|
data, errRead := io.ReadAll(httpResp.Body)
|
|
if errRead != nil {
|
|
helps.RecordAPIResponseError(ctx, e.cfg, errRead)
|
|
return cliproxyexecutor.Response{}, errRead
|
|
}
|
|
helps.AppendAPIResponseChunk(ctx, e.cfg, data)
|
|
count := gjson.GetBytes(data, "totalTokens").Int()
|
|
out := sdktranslator.TranslateTokenCount(ctx, to, responseFormat, count, data)
|
|
return cliproxyexecutor.Response{Payload: out, Headers: httpResp.Header.Clone()}, nil
|
|
}
|
|
|
|
// countTokensWithAPIKey handles token counting using API key credentials.
|
|
func (e *GeminiVertexExecutor) countTokensWithAPIKey(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options, apiKey, baseURL string) (cliproxyexecutor.Response, error) {
|
|
baseModel := thinking.ParseSuffix(req.Model).ModelName
|
|
|
|
from := opts.SourceFormat
|
|
responseFormat := cliproxyexecutor.ResponseFormatOrSource(opts)
|
|
to := sdktranslator.FromString("gemini")
|
|
|
|
translatedReq, err := helps.TranslateRequestReturningError(ctx, opts.Headers, e.cfg, from, to, baseModel, req.Payload, false, false)
|
|
if err != nil {
|
|
return cliproxyexecutor.Response{}, err
|
|
}
|
|
originalTranslatedForPayload := append([]byte(nil), translatedReq...)
|
|
if len(opts.OriginalRequest) > 0 {
|
|
originalTranslatedForPayload = helps.TranslateRequestWithCodexMultiAgentV2(ctx, opts.Headers, e.cfg, from, to, baseModel, opts.OriginalRequest, false)
|
|
}
|
|
|
|
translatedReq, err = helps.ApplyRequestThinking(translatedReq, req, opts, from.String(), to.String(), e.Identifier())
|
|
if err != nil {
|
|
return cliproxyexecutor.Response{}, err
|
|
}
|
|
|
|
translatedReq = fixGeminiImageAspectRatio(baseModel, translatedReq)
|
|
translatedReq, _ = sjson.SetBytes(translatedReq, "model", baseModel)
|
|
translatedReq = helps.StripVertexOpenAIResponsesToolCallIDs(translatedReq, from.String())
|
|
respCtx := context.WithValue(ctx, "alt", opts.Alt)
|
|
translatedReq, _ = sjson.DeleteBytes(translatedReq, "tools")
|
|
translatedReq, _ = sjson.DeleteBytes(translatedReq, "generationConfig")
|
|
translatedReq, _ = sjson.DeleteBytes(translatedReq, "safetySettings")
|
|
translatedReq = internalsignature.SanitizeGeminiRequestThoughtSignatures(translatedReq, "contents")
|
|
translatedReq = helps.EnsureGeminiLeadingUserContent(translatedReq, "contents")
|
|
|
|
// For API key auth, use simpler URL format without project/location
|
|
url := vertexAPIKeyModelsURL(baseURL, baseModel, "countTokens")
|
|
|
|
translatedReq = helps.NewPayloadFinalizer(e.cfg, e.Identifier(), baseModel, to.String(), "", originalTranslatedForPayload, req, opts)(translatedReq)
|
|
httpReq, errNewReq := http.NewRequestWithContext(respCtx, http.MethodPost, url, bytes.NewReader(translatedReq))
|
|
if errNewReq != nil {
|
|
return cliproxyexecutor.Response{}, errNewReq
|
|
}
|
|
httpReq.Header.Set("Content-Type", "application/json")
|
|
if apiKey != "" {
|
|
httpReq.Header.Set("x-goog-api-key", apiKey)
|
|
}
|
|
applyGeminiHeaders(httpReq, auth, opts.Headers)
|
|
var attrs map[string]string
|
|
if auth != nil {
|
|
attrs = auth.Attributes
|
|
}
|
|
util.ApplyCustomHeadersFromAttrs(httpReq, attrs, opts.Headers)
|
|
|
|
var authID, authLabel, authType, authValue string
|
|
if auth != nil {
|
|
authID = auth.ID
|
|
authLabel = auth.Label
|
|
authType, authValue = auth.AccountInfo()
|
|
}
|
|
helps.RecordAPIRequest(ctx, e.cfg, helps.UpstreamRequestLog{
|
|
URL: url,
|
|
Method: http.MethodPost,
|
|
Headers: httpReq.Header.Clone(),
|
|
Body: translatedReq,
|
|
Provider: e.Identifier(),
|
|
AuthID: authID,
|
|
AuthLabel: authLabel,
|
|
AuthType: authType,
|
|
AuthValue: authValue,
|
|
})
|
|
|
|
httpClient := helps.NewProxyAwareHTTPClient(ctx, e.cfg, auth, 0)
|
|
cliproxyexecutor.MarkUpstreamAttempt(ctx)
|
|
httpResp, errDo := httpClient.Do(httpReq)
|
|
if errDo != nil {
|
|
helps.RecordAPIResponseError(ctx, e.cfg, errDo)
|
|
return cliproxyexecutor.Response{}, errDo
|
|
}
|
|
defer func() {
|
|
if errClose := httpResp.Body.Close(); errClose != nil {
|
|
log.Errorf("vertex executor: close response body error: %v", errClose)
|
|
}
|
|
}()
|
|
helps.RecordAPIResponseMetadata(ctx, e.cfg, httpResp.StatusCode, httpResp.Header.Clone())
|
|
if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 {
|
|
b, _ := io.ReadAll(httpResp.Body)
|
|
helps.AppendAPIResponseChunk(ctx, e.cfg, b)
|
|
helps.LogWithRequestID(ctx).Debugf("request error, error status: %d, error message: %s", httpResp.StatusCode, helps.SummarizeErrorBody(httpResp.Header.Get("Content-Type"), b))
|
|
return cliproxyexecutor.Response{}, statusErr{code: httpResp.StatusCode, msg: string(b)}
|
|
}
|
|
data, errRead := io.ReadAll(httpResp.Body)
|
|
if errRead != nil {
|
|
helps.RecordAPIResponseError(ctx, e.cfg, errRead)
|
|
return cliproxyexecutor.Response{}, errRead
|
|
}
|
|
helps.AppendAPIResponseChunk(ctx, e.cfg, data)
|
|
count := gjson.GetBytes(data, "totalTokens").Int()
|
|
out := sdktranslator.TranslateTokenCount(ctx, to, responseFormat, count, data)
|
|
return cliproxyexecutor.Response{Payload: out, Headers: httpResp.Header.Clone()}, nil
|
|
}
|
|
|
|
// vertexCreds extracts project, location and raw service account JSON from auth metadata.
|
|
func vertexCreds(a *cliproxyauth.Auth) (projectID, location string, serviceAccountJSON []byte, err error) {
|
|
if a == nil || a.Metadata == nil {
|
|
return "", "", nil, fmt.Errorf("vertex executor: missing auth metadata")
|
|
}
|
|
if v, ok := a.Metadata["project_id"].(string); ok {
|
|
projectID = strings.TrimSpace(v)
|
|
}
|
|
if projectID == "" {
|
|
// Some service accounts may use "project"; still prefer standard field
|
|
if v, ok := a.Metadata["project"].(string); ok {
|
|
projectID = strings.TrimSpace(v)
|
|
}
|
|
}
|
|
if projectID == "" {
|
|
return "", "", nil, fmt.Errorf("vertex executor: missing project_id in credentials")
|
|
}
|
|
if v, ok := a.Metadata["location"].(string); ok && strings.TrimSpace(v) != "" {
|
|
location = strings.TrimSpace(v)
|
|
} else {
|
|
location = "us-central1"
|
|
}
|
|
var sa map[string]any
|
|
if raw, ok := a.Metadata["service_account"].(map[string]any); ok {
|
|
sa = raw
|
|
}
|
|
if sa == nil {
|
|
return "", "", nil, fmt.Errorf("vertex executor: missing service_account in credentials")
|
|
}
|
|
normalized, errNorm := vertexauth.NormalizeServiceAccountMap(sa)
|
|
if errNorm != nil {
|
|
return "", "", nil, fmt.Errorf("vertex executor: %w", errNorm)
|
|
}
|
|
saJSON, errMarshal := json.Marshal(normalized)
|
|
if errMarshal != nil {
|
|
return "", "", nil, fmt.Errorf("vertex executor: marshal service_account failed: %w", errMarshal)
|
|
}
|
|
return projectID, location, saJSON, nil
|
|
}
|
|
|
|
// vertexAPICreds extracts API key and base URL from auth attributes following the claudeCreds pattern.
|
|
func vertexAPICreds(a *cliproxyauth.Auth) (apiKey, baseURL string) {
|
|
if a == nil {
|
|
return "", ""
|
|
}
|
|
if a.Attributes != nil {
|
|
apiKey = a.Attributes["api_key"]
|
|
baseURL = a.Attributes["base_url"]
|
|
}
|
|
if apiKey == "" && a.Metadata != nil {
|
|
if v, ok := a.Metadata["access_token"].(string); ok {
|
|
apiKey = v
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// vertexAPIKeyModelsURL builds the API-key models endpoint URL.
|
|
//
|
|
// The configured base URL is treated as a full resource prefix when it
|
|
// already contains a "/publishers/" segment (e.g. a real Vertex endpoint
|
|
// such as "https://aiplatform.googleapis.com/v1/projects/{p}/locations/{l}/publishers/google/models"),
|
|
// in which case only "/{model}:{action}" is appended. Otherwise the default
|
|
// "/v1/publishers/google/models" segment is inserted so short third-party
|
|
// hosts keep working; if the base already ends in a version segment such
|
|
// as "/v1" or "/v1beta1", only "/publishers/google/models" is appended to
|
|
// avoid producing a duplicated version path.
|
|
func vertexAPIKeyModelsURL(baseURL, model, action string) string {
|
|
base := strings.TrimRight(strings.TrimSpace(baseURL), "/")
|
|
if base == "" {
|
|
base = "https://aiplatform.googleapis.com"
|
|
}
|
|
if strings.Contains(base, "/publishers/") {
|
|
return fmt.Sprintf("%s/%s:%s", base, model, action)
|
|
}
|
|
if !vertexAPIVersionSuffix(base) {
|
|
base = fmt.Sprintf("%s/%s", base, vertexAPIVersion)
|
|
}
|
|
return fmt.Sprintf("%s/publishers/google/models/%s:%s", base, model, action)
|
|
}
|
|
|
|
// vertexAPIVersionSuffix reports whether the trimmed base URL already ends
|
|
// with a Google API version segment like "/v1" or "/v1beta1".
|
|
func vertexAPIVersionSuffix(base string) bool {
|
|
if base == "" {
|
|
return false
|
|
}
|
|
seg := base[strings.LastIndexByte(base, '/')+1:]
|
|
if len(seg) < 2 || seg[0] != 'v' {
|
|
return false
|
|
}
|
|
hasDigit := false
|
|
for i := 1; i < len(seg); i++ {
|
|
c := seg[i]
|
|
switch {
|
|
case c >= '0' && c <= '9':
|
|
hasDigit = true
|
|
case c == '_' || c == '-' || (c >= 'a' && c <= 'z'):
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
return hasDigit
|
|
}
|
|
|
|
func vertexBaseURL(location string) string {
|
|
loc := strings.TrimSpace(location)
|
|
if loc == "" {
|
|
loc = "us-central1"
|
|
} else if strings.EqualFold(loc, "global") {
|
|
return "https://aiplatform.googleapis.com"
|
|
} else if strings.EqualFold(loc, "us") || strings.EqualFold(loc, "eu") {
|
|
return fmt.Sprintf("https://aiplatform.%s.rep.googleapis.com", strings.ToLower(loc))
|
|
}
|
|
return fmt.Sprintf("https://%s-aiplatform.googleapis.com", loc)
|
|
}
|
|
|
|
func vertexAccessToken(ctx context.Context, cfg *config.Config, auth *cliproxyauth.Auth, saJSON []byte) (string, error) {
|
|
// Token exchange stays on the credential or global proxy. The execution proxy
|
|
// applies only to the model request that follows.
|
|
tokenCtx := cliproxyexecutor.WithoutRequestProxyURL(ctx)
|
|
if httpClient := helps.NewProxyAwareHTTPClient(tokenCtx, cfg, auth, 0); httpClient != nil {
|
|
ctx = context.WithValue(ctx, oauth2.HTTPClient, httpClient)
|
|
}
|
|
// Use cloud-platform scope for Vertex AI.
|
|
creds, errCreds := google.CredentialsFromJSON(ctx, saJSON, "https://www.googleapis.com/auth/cloud-platform")
|
|
if errCreds != nil {
|
|
return "", fmt.Errorf("vertex executor: parse service account json failed: %w", errCreds)
|
|
}
|
|
tok, errTok := creds.TokenSource.Token()
|
|
if errTok != nil {
|
|
return "", fmt.Errorf("vertex executor: get access token failed: %w", errTok)
|
|
}
|
|
return tok.AccessToken, nil
|
|
}
|
|
|
|
// resolveVertexConfig finds the matching vertex-api-key configuration entry for the given auth.
|
|
func (e *GeminiVertexExecutor) resolveVertexConfig(auth *cliproxyauth.Auth) *config.VertexCompatKey {
|
|
return helps.ResolveVertexCompatConfig(e.cfg, auth)
|
|
}
|
|
|
|
// SupportsApplyPatch reports the actual executor contract, independent of its provider name.
|
|
func (e *GeminiVertexExecutor) SupportsApplyPatch() bool { return e != nil }
|
|
|
|
func shouldExecuteVertexInteractions(auth *cliproxyauth.Auth, opts cliproxyexecutor.Options) bool {
|
|
return opts.SourceFormat == sdktranslator.FormatInteractions && isNativeVertexInteractionsAuth(auth)
|
|
}
|
|
|
|
func isNativeVertexInteractionsAuth(auth *cliproxyauth.Auth) bool {
|
|
if auth == nil {
|
|
return false
|
|
}
|
|
if auth.Attributes != nil {
|
|
if v := strings.TrimSpace(auth.Attributes["interactions"]); strings.EqualFold(v, "true") || strings.EqualFold(v, "1") {
|
|
return true
|
|
}
|
|
}
|
|
if auth.Metadata != nil {
|
|
if v, ok := auth.Metadata["interactions"].(bool); ok && v {
|
|
return true
|
|
}
|
|
if v, ok := auth.Metadata["native_interactions"].(bool); ok && v {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func vertexInteractionsURL(baseURL, projectID string, isStream bool) string {
|
|
base := strings.TrimSpace(baseURL)
|
|
if base == "" {
|
|
base = "https://aiplatform.googleapis.com"
|
|
}
|
|
base = strings.TrimRight(base, "/")
|
|
var url string
|
|
if strings.TrimSpace(projectID) != "" {
|
|
url = fmt.Sprintf("%s/v1beta1/projects/%s/locations/global/interactions", base, strings.TrimSpace(projectID))
|
|
} else {
|
|
url = fmt.Sprintf("%s/v1beta1/interactions", base)
|
|
}
|
|
if isStream {
|
|
url = url + "?alt=sse"
|
|
}
|
|
return url
|
|
}
|
|
|
|
func (e *GeminiVertexExecutor) executeInteractions(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options) (resp cliproxyexecutor.Response, err error) {
|
|
targetName := thinking.ParseSuffix(req.Model).ModelName
|
|
reporter := helps.NewExecutorUsageReporter(ctx, e, targetName, auth)
|
|
defer reporter.TrackFailure(ctx, &err)
|
|
|
|
isCompat := helps.APIKeyModelIsCompat(req)
|
|
originalTranslated, body, errTranslate := helps.TranslateGeminiInteractionsRequestPair(ctx, e.cfg, targetName, req.Payload, opts, false, isCompat)
|
|
if errTranslate != nil {
|
|
return resp, errTranslate
|
|
}
|
|
if gjson.GetBytes(body, "model").Exists() && targetName != "" {
|
|
body = helps.SetStringIfDifferent(body, "model", targetName)
|
|
}
|
|
var errThinking error
|
|
body, errThinking = helps.ApplyGeminiInteractionsThinking(body, req, opts)
|
|
if errThinking != nil {
|
|
return resp, errThinking
|
|
}
|
|
requestedModel := helps.PayloadRequestedModel(opts, req.Model)
|
|
requestPath := helps.PayloadRequestPath(opts)
|
|
fromProtocol := opts.SourceFormat.String()
|
|
body = helps.SanitizeGeminiInteractionsUnsupportedInputIDs(body)
|
|
|
|
apiKey, baseURL := vertexAPICreds(auth)
|
|
var projectID string
|
|
var saJSON []byte
|
|
if apiKey == "" {
|
|
var errCreds error
|
|
projectID, _, saJSON, errCreds = vertexCreds(auth)
|
|
if errCreds != nil {
|
|
return resp, errCreds
|
|
}
|
|
if auth != nil && auth.Attributes != nil && auth.Attributes["base_url"] != "" {
|
|
baseURL = strings.TrimSpace(auth.Attributes["base_url"])
|
|
}
|
|
} else if auth != nil && auth.Metadata != nil {
|
|
if pid, ok := auth.Metadata["project_id"].(string); ok {
|
|
projectID = pid
|
|
}
|
|
}
|
|
|
|
url := vertexInteractionsURL(baseURL, projectID, false)
|
|
|
|
body = helps.ApplyPayloadConfigWithRequest(e.cfg, targetName, "interactions", fromProtocol, "", body, originalTranslated, requestedModel, requestPath, opts.Headers)
|
|
reporter.SetTranslatedRequestMetadata(body, "interactions")
|
|
|
|
httpReq, errRequest := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body))
|
|
if errRequest != nil {
|
|
return resp, errRequest
|
|
}
|
|
httpReq.Header.Set("Content-Type", "application/json")
|
|
if apiKey != "" {
|
|
httpReq.Header.Set("x-goog-api-key", apiKey)
|
|
} else {
|
|
token, errTok := vertexAccessToken(ctx, e.cfg, auth, saJSON)
|
|
if errTok != nil {
|
|
log.Errorf("vertex executor: interactions access token error: %v", errTok)
|
|
return resp, statusErr{code: 500, msg: "internal server error"}
|
|
}
|
|
if strings.TrimSpace(token) == "" {
|
|
return resp, statusErr{code: http.StatusUnauthorized, msg: "missing access token"}
|
|
}
|
|
httpReq.Header.Set("Authorization", "Bearer "+token)
|
|
}
|
|
applyGeminiHeaders(httpReq, auth, opts.Headers)
|
|
helps.ApplyGeminiInteractionsRequestHeaders(httpReq, opts.Headers)
|
|
helps.ApplyGeminiInteractionsRevisionHeader(httpReq)
|
|
|
|
var attrs map[string]string
|
|
if auth != nil {
|
|
attrs = auth.Attributes
|
|
}
|
|
util.ApplyCustomHeadersFromAttrs(httpReq, attrs, opts.Headers)
|
|
|
|
var authID, authLabel, authType, authValue string
|
|
if auth != nil {
|
|
authID = auth.ID
|
|
authLabel = auth.Label
|
|
authType, authValue = auth.AccountInfo()
|
|
}
|
|
helps.RecordAPIRequest(ctx, e.cfg, helps.UpstreamRequestLog{
|
|
URL: url,
|
|
Method: http.MethodPost,
|
|
Headers: httpReq.Header.Clone(),
|
|
Body: body,
|
|
Provider: e.Identifier(),
|
|
AuthID: authID,
|
|
AuthLabel: authLabel,
|
|
AuthType: authType,
|
|
AuthValue: authValue,
|
|
})
|
|
|
|
httpClient := reporter.TrackHTTPClient(helps.NewProxyAwareHTTPClient(ctx, e.cfg, auth, 0))
|
|
httpResp, errDo := httpClient.Do(httpReq)
|
|
if errDo != nil {
|
|
helps.RecordAPIResponseError(ctx, e.cfg, errDo)
|
|
return resp, errDo
|
|
}
|
|
defer func() {
|
|
if errClose := httpResp.Body.Close(); errClose != nil {
|
|
log.Errorf("vertex executor: close interactions response body error: %v", errClose)
|
|
}
|
|
}()
|
|
helps.RecordAPIResponseMetadata(ctx, e.cfg, httpResp.StatusCode, httpResp.Header.Clone())
|
|
data, errRead := io.ReadAll(httpResp.Body)
|
|
if errRead != nil {
|
|
helps.RecordAPIResponseError(ctx, e.cfg, errRead)
|
|
return resp, errRead
|
|
}
|
|
helps.AppendAPIResponseChunk(ctx, e.cfg, data)
|
|
if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 {
|
|
helps.LogWithRequestID(ctx).Debugf("request error, error status: %d, error message: %s", httpResp.StatusCode, helps.SummarizeErrorBody(httpResp.Header.Get("Content-Type"), data))
|
|
err = statusErr{code: httpResp.StatusCode, msg: string(data)}
|
|
return resp, err
|
|
}
|
|
reporter.ObserveResponseModel(data)
|
|
targetFormat := cliproxyexecutor.ResponseFormatOrSource(opts)
|
|
var param any
|
|
out := sdktranslator.TranslateNonStream(ctx, sdktranslator.FormatInteractions, targetFormat, req.Model, helps.ApplyPatchOriginalRequest(req, opts), body, data, ¶m)
|
|
if helps.ApplyPatchTranslationError(param) != nil || len(out) == 0 {
|
|
return cliproxyexecutor.Response{}, statusErr{code: http.StatusBadGateway, msg: helps.ApplyPatchUpstreamErrorMessage}
|
|
}
|
|
reporter.Publish(ctx, helps.ParseInteractionsUsage(data))
|
|
if targetFormat == sdktranslator.FormatOpenAIResponse {
|
|
out = helps.EnsureResponsesUsageDetails(out)
|
|
}
|
|
return cliproxyexecutor.Response{Payload: out, Headers: httpResp.Header.Clone()}, nil
|
|
}
|
|
|
|
func (e *GeminiVertexExecutor) executeInteractionsStream(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options) (_ *cliproxyexecutor.StreamResult, err error) {
|
|
targetName := thinking.ParseSuffix(req.Model).ModelName
|
|
reporter := helps.NewExecutorUsageReporter(ctx, e, targetName, auth)
|
|
defer reporter.TrackFailure(ctx, &err)
|
|
|
|
isCompat := helps.APIKeyModelIsCompat(req)
|
|
originalTranslated, body, errTranslate := helps.TranslateGeminiInteractionsRequestPair(ctx, e.cfg, targetName, req.Payload, opts, true, isCompat)
|
|
if errTranslate != nil {
|
|
return nil, errTranslate
|
|
}
|
|
if gjson.GetBytes(body, "model").Exists() && targetName != "" {
|
|
body = helps.SetStringIfDifferent(body, "model", targetName)
|
|
}
|
|
var errThinking error
|
|
body, errThinking = helps.ApplyGeminiInteractionsThinking(body, req, opts)
|
|
if errThinking != nil {
|
|
return nil, errThinking
|
|
}
|
|
requestedModel := helps.PayloadRequestedModel(opts, req.Model)
|
|
requestPath := helps.PayloadRequestPath(opts)
|
|
fromProtocol := opts.SourceFormat.String()
|
|
body = helps.SanitizeGeminiInteractionsUnsupportedInputIDs(body)
|
|
body = helps.SetBoolIfDifferent(body, "stream", true)
|
|
|
|
apiKey, baseURL := vertexAPICreds(auth)
|
|
var projectID string
|
|
var saJSON []byte
|
|
if apiKey == "" {
|
|
var errCreds error
|
|
projectID, _, saJSON, errCreds = vertexCreds(auth)
|
|
if errCreds != nil {
|
|
return nil, errCreds
|
|
}
|
|
if auth != nil && auth.Attributes != nil && auth.Attributes["base_url"] != "" {
|
|
baseURL = strings.TrimSpace(auth.Attributes["base_url"])
|
|
}
|
|
} else if auth != nil && auth.Metadata != nil {
|
|
if pid, ok := auth.Metadata["project_id"].(string); ok {
|
|
projectID = pid
|
|
}
|
|
}
|
|
|
|
url := vertexInteractionsURL(baseURL, projectID, true)
|
|
|
|
body = helps.ApplyPayloadConfigWithRequest(e.cfg, targetName, "interactions", fromProtocol, "", body, originalTranslated, requestedModel, requestPath, opts.Headers)
|
|
reporter.SetTranslatedRequestMetadata(body, "interactions")
|
|
|
|
httpReq, errRequest := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body))
|
|
if errRequest != nil {
|
|
return nil, errRequest
|
|
}
|
|
httpReq.Header.Set("Content-Type", "application/json")
|
|
if apiKey != "" {
|
|
httpReq.Header.Set("x-goog-api-key", apiKey)
|
|
} else {
|
|
token, errTok := vertexAccessToken(ctx, e.cfg, auth, saJSON)
|
|
if errTok != nil {
|
|
log.Errorf("vertex executor: interactions access token error: %v", errTok)
|
|
return nil, statusErr{code: 500, msg: "internal server error"}
|
|
}
|
|
if strings.TrimSpace(token) == "" {
|
|
return nil, statusErr{code: http.StatusUnauthorized, msg: "missing access token"}
|
|
}
|
|
httpReq.Header.Set("Authorization", "Bearer "+token)
|
|
}
|
|
applyGeminiHeaders(httpReq, auth, opts.Headers)
|
|
helps.ApplyGeminiInteractionsRequestHeaders(httpReq, opts.Headers)
|
|
helps.ApplyGeminiInteractionsRevisionHeader(httpReq)
|
|
|
|
var attrs map[string]string
|
|
if auth != nil {
|
|
attrs = auth.Attributes
|
|
}
|
|
util.ApplyCustomHeadersFromAttrs(httpReq, attrs, opts.Headers)
|
|
|
|
var authID, authLabel, authType, authValue string
|
|
if auth != nil {
|
|
authID = auth.ID
|
|
authLabel = auth.Label
|
|
authType, authValue = auth.AccountInfo()
|
|
}
|
|
helps.RecordAPIRequest(ctx, e.cfg, helps.UpstreamRequestLog{
|
|
URL: url,
|
|
Method: http.MethodPost,
|
|
Headers: httpReq.Header.Clone(),
|
|
Body: body,
|
|
Provider: e.Identifier(),
|
|
AuthID: authID,
|
|
AuthLabel: authLabel,
|
|
AuthType: authType,
|
|
AuthValue: authValue,
|
|
})
|
|
|
|
httpClient := reporter.TrackHTTPClient(helps.NewProxyAwareHTTPClient(ctx, e.cfg, auth, 0))
|
|
httpResp, errDo := httpClient.Do(httpReq)
|
|
if errDo != nil {
|
|
helps.RecordAPIResponseError(ctx, e.cfg, errDo)
|
|
return nil, errDo
|
|
}
|
|
helps.RecordAPIResponseMetadata(ctx, e.cfg, httpResp.StatusCode, httpResp.Header.Clone())
|
|
if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 {
|
|
data, _ := io.ReadAll(httpResp.Body)
|
|
if errClose := httpResp.Body.Close(); errClose != nil {
|
|
log.Errorf("vertex executor: close interactions error response body error: %v", errClose)
|
|
}
|
|
helps.AppendAPIResponseChunk(ctx, e.cfg, data)
|
|
return nil, statusErr{code: httpResp.StatusCode, msg: string(data)}
|
|
}
|
|
|
|
out := make(chan cliproxyexecutor.StreamChunk)
|
|
responseFormat := cliproxyexecutor.ResponseFormatOrSource(opts)
|
|
go func() {
|
|
defer close(out)
|
|
defer reporter.EnsurePublished(ctx)
|
|
defer func() {
|
|
if errClose := httpResp.Body.Close(); errClose != nil {
|
|
log.Errorf("vertex executor: close interactions stream body error: %v", errClose)
|
|
}
|
|
}()
|
|
scanner := bufio.NewScanner(httpResp.Body)
|
|
scanner.Buffer(nil, helps.StreamScannerBuffer)
|
|
originalRequest := opts.OriginalRequest
|
|
if len(originalRequest) == 0 {
|
|
originalRequest = req.Payload
|
|
}
|
|
claudeInputTokens := helps.NewClaudeInputTokenState(opts.SourceFormat, sdktranslator.FormatInteractions, responseFormat, originalRequest)
|
|
var streamUsage helps.StreamUsageBuffer
|
|
defer streamUsage.Publish(ctx, reporter)
|
|
var param any
|
|
helps.InitializeApplyPatchStream(ctx, sdktranslator.FormatInteractions, responseFormat, req.Model, helps.ApplyPatchOriginalRequest(req, opts), body, ¶m)
|
|
var frame []byte
|
|
emitFrame := func() bool {
|
|
rawFrame := bytes.Clone(frame)
|
|
trimmed := bytes.TrimSpace(rawFrame)
|
|
frame = frame[:0]
|
|
if len(trimmed) == 0 {
|
|
return true
|
|
}
|
|
payload := helps.GeminiInteractionsSSEPayload(rawFrame)
|
|
if len(payload) == 0 && helps.GeminiInteractionsSSEDone(rawFrame) {
|
|
payload = []byte("[DONE]")
|
|
}
|
|
if len(payload) > 0 {
|
|
reporter.ObserveResponseModel(payload)
|
|
if detail, ok := helps.ParseInteractionsStreamUsage(payload); ok {
|
|
streamUsage.Observe(detail, true)
|
|
}
|
|
}
|
|
if responseFormat == sdktranslator.FormatInteractions {
|
|
visibleFrame := append(bytes.TrimRight(rawFrame, "\r\n"), '\n', '\n')
|
|
select {
|
|
case out <- cliproxyexecutor.StreamChunk{Payload: visibleFrame}:
|
|
case <-ctx.Done():
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
if len(payload) == 0 {
|
|
return true
|
|
}
|
|
var lines [][]byte
|
|
lines = helps.TranslateStreamWithClaudeInputTokens(ctx, sdktranslator.FormatInteractions, responseFormat, req.Model, helps.ApplyPatchOriginalRequest(req, opts), body, payload, ¶m, claudeInputTokens)
|
|
helps.RecordApplyPatchStreamFailure(ctx, param, reporter, statusErr{code: http.StatusBadGateway, msg: helps.ApplyPatchUpstreamErrorMessage})
|
|
for i := range lines {
|
|
select {
|
|
case out <- cliproxyexecutor.StreamChunk{Payload: lines[i]}:
|
|
case <-ctx.Done():
|
|
return false
|
|
}
|
|
}
|
|
if helps.StopApplyPatchStream(ctx, param, reporter, out, statusErr{code: http.StatusBadGateway, msg: helps.ApplyPatchUpstreamErrorMessage}) {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
for scanner.Scan() {
|
|
line := scanner.Bytes()
|
|
helps.AppendAPIResponseChunk(ctx, e.cfg, line)
|
|
trimmed := bytes.TrimSpace(line)
|
|
if len(trimmed) == 0 {
|
|
if !emitFrame() {
|
|
return
|
|
}
|
|
continue
|
|
}
|
|
if len(frame) > 0 {
|
|
frame = append(frame, '\n')
|
|
}
|
|
frame = append(frame, line...)
|
|
}
|
|
if !emitFrame() {
|
|
return
|
|
}
|
|
if helps.EndApplyPatchStream(ctx, param, reporter, out, statusErr{code: http.StatusBadGateway, msg: helps.ApplyPatchUpstreamErrorMessage}) {
|
|
return
|
|
}
|
|
if errScan := scanner.Err(); errScan != nil {
|
|
helps.RecordAPIResponseError(ctx, e.cfg, errScan)
|
|
reporter.PublishFailure(ctx, errScan)
|
|
select {
|
|
case out <- cliproxyexecutor.StreamChunk{Err: errScan}:
|
|
case <-ctx.Done():
|
|
}
|
|
}
|
|
}()
|
|
|
|
return &cliproxyexecutor.StreamResult{
|
|
Chunks: out,
|
|
Headers: httpResp.Header.Clone(),
|
|
}, nil
|
|
}
|