merge: integrate origin/master (v0.5.50) into gitea/new_feature

- Resolve conflicts in chatCore handlers: keep apiKey/streamErrorPatterns from the details-filters feature, adopt origin's stripContinuityFields, customToolNames, cache-inclusive usage accounting, and Responses-API SSE→JSON conversion - Adopt origin's provider usage handlers (codebuddy-intl, qoder creds) and modality detection (audio/video inputs) - Keep requestDetails apiKey column (schema v2) + masked key persistence Co-authored-by: CommandCodeBot <noreply@commandcode.ai>
2026-08-06 09:54:31 +07:00
parent 386b25ff7f 15223724c3
commit a3182a7265
180 changed files with 8622 additions and 6233 deletions
--- a/open-sse/handlers/chatCore/nonStreamingHandler.js
+++ b/open-sse/handlers/chatCore/nonStreamingHandler.js
@@ -9,6 +9,7 @@ import { parseSSEToOpenAIResponse } from "./sseToJsonHandler.js";
 import { buildRequestDetail, extractRequestConfig, extractUsageFromResponse, saveUsageStats, formatDoneLine } from "./requestDetail.js";
 import { appendRequestLog, saveRequestDetail } from "@/lib/usageDb.js";
 import { decloakToolNames } from "../../utils/claudeCloaking.js";
+import { ROLE, RESPONSES_ITEM } from "../../translator/schema/index.js";

 function parseToolArguments(value) {
  if (!value) return {};
@@ -60,11 +61,93 @@ function openAICompletionToClaudeMessage(responseBody) {
  };
 }

+/**
+ * Convert an OpenAI Chat Completions non-streaming response body into the
+ * OpenAI Responses API shape. Used when a Responses-format client (e.g. Codex)
+ * is routed to a Chat Completions upstream and `stream:false` — the streaming
+ * path already emits Responses events, but the JSON path returned a raw
+ * `chat.completion` body, so tool_calls were invisible to Responses clients.
+ */
+function extractCustomToolInput(argumentsValue) {
+  const argumentsText = typeof argumentsValue === "string" ? argumentsValue : JSON.stringify(argumentsValue || {});
+  try {
+    const parsed = JSON.parse(argumentsText);
+    if (parsed && typeof parsed === "object" && typeof parsed.input === "string") return parsed.input;
+  } catch { /* raw freeform input */ }
+  return argumentsText;
+}
+
+function openAICompletionToResponses(responseBody, customToolNames = null) {
+  const choice = responseBody?.choices?.[0];
+  if (!choice) return responseBody;
+
+  const message = choice.message || {};
+  const output = [];
+
+  // Reasoning → a reasoning item (summary text), mirroring the streaming path.
+  const reasoning = message.reasoning_content || message.reasoning;
+  if (typeof reasoning === "string" && reasoning.length > 0) {
+    output.push({
+      type: RESPONSES_ITEM.REASONING,
+      summary: [{ type: RESPONSES_ITEM.SUMMARY_TEXT, text: reasoning }],
+    });
+  }
+
+  // Assistant text → a message item with output_text content.
+  const text = typeof message.content === "string" ? message.content : "";
+  if (text.length > 0) {
+    output.push({
+      type: RESPONSES_ITEM.MESSAGE,
+      role: ROLE.ASSISTANT,
+      content: [{ type: RESPONSES_ITEM.OUTPUT_TEXT, text, annotations: [] }],
+    });
+  }
+
+  // tool_calls → function_call/custom_tool_call items (Responses-native tool shape).
+  for (const tc of message.tool_calls || []) {
+    const fn = tc.function || {};
+    const custom = customToolNames?.has(fn.name);
+    output.push({
+      type: custom ? RESPONSES_ITEM.CUSTOM_TOOL_CALL : RESPONSES_ITEM.FUNCTION_CALL,
+      id: `${custom ? "ctc" : "fc"}_${tc.id || ""}`,
+      call_id: tc.id || "",
+      name: fn.name || "",
+      ...(custom
+        ? { input: extractCustomToolInput(fn.arguments) }
+        : { arguments: typeof fn.arguments === "string" ? fn.arguments : JSON.stringify(fn.arguments || {}) }),
+    });
+  }
+
+  const usage = responseBody.usage || {};
+  const status = choice.finish_reason === "tool_calls" ? "completed" : (choice.finish_reason === "stop" ? "completed" : (choice.finish_reason || "completed"));
+
+  return {
+    id: `resp_${responseBody.id || ""}`.replace(/^resp_chatcmpl-/, "resp_"),
+    object: "response",
+    created_at: responseBody.created || Math.floor(Date.now() / 1000),
+    model: responseBody.model || "unknown",
+    status,
+    background: false,
+    error: null,
+    output,
+    usage: {
+      input_tokens: usage.prompt_tokens || usage.input_tokens || 0,
+      output_tokens: usage.completion_tokens || usage.output_tokens || 0,
+      total_tokens: usage.total_tokens || (usage.prompt_tokens || 0) + (usage.completion_tokens || 0),
+    },
+  };
+}
+
 /**
 * Translate non-streaming response body from provider format → OpenAI format.
 */
-export function translateNonStreamingResponse(responseBody, targetFormat, sourceFormat) {
+export function translateNonStreamingResponse(responseBody, targetFormat, sourceFormat, customToolNames = null) {
  if (targetFormat === sourceFormat) return responseBody;
+  // Provider responded in OpenAI Chat Completions shape but the client speaks
+  // Responses API — convert so tool_calls/text surface as Responses `output`.
+  if (targetFormat === FORMATS.OPENAI && sourceFormat === FORMATS.OPENAI_RESPONSES) {
+    return openAICompletionToResponses(responseBody, customToolNames);
+  }
  if (targetFormat === FORMATS.OPENAI && sourceFormat === FORMATS.CLAUDE) {
    return openAICompletionToClaudeMessage(responseBody);
  }
@@ -198,7 +281,7 @@ export function translateNonStreamingResponse(responseBody, targetFormat, source
 /**
 * Handle non-streaming response from provider.
 */
-export async function handleNonStreamingResponse({ providerResponse, provider, model, sourceFormat, targetFormat, body, stream, translatedBody, finalBody, requestStartTime, connectionId, apiKey, clientRawRequest, onRequestSuccess, reqLogger, toolNameMap, trackDone, appendLog, pxpipe, reqTag, log }) {
+export async function handleNonStreamingResponse({ providerResponse, provider, model, sourceFormat, targetFormat, body, stream, translatedBody, finalBody, requestStartTime, connectionId, apiKey, clientRawRequest, onRequestSuccess, reqLogger, toolNameMap, customToolNames, trackDone, appendLog, pxpipe, reqTag, log }) {
  trackDone();
  const contentType = providerResponse.headers.get("content-type") || "";
  let responseBody;
@@ -239,9 +322,12 @@ export async function handleNonStreamingResponse({ providerResponse, provider, m
  if (log?.line) log.line(reqTag, "📊", formatDoneLine({ usage, latency: { total: Date.now() - requestStartTime } }));

  const translatedResponse = needsTranslation(targetFormat, sourceFormat)
-    ? translateNonStreamingResponse(responseBody, targetFormat, sourceFormat)
+    ? translateNonStreamingResponse(responseBody, targetFormat, sourceFormat, customToolNames)
    : responseBody;
  const isClaudeMessageResponse = sourceFormat === FORMATS.CLAUDE && translatedResponse?.type === "message";
+  // Responses-format translation produces a `object:"response"` body with no
+  // `choices`; skip the Chat-Completions-specific post-processing below for it.
+  const isResponsesResponse = sourceFormat === FORMATS.OPENAI_RESPONSES && translatedResponse?.object === "response";

  // Fix finish_reason for tool_calls: some providers return non-standard values (e.g. "other")
  if (translatedResponse?.choices?.[0]) {
@@ -254,13 +340,13 @@ export async function handleNonStreamingResponse({ providerResponse, provider, m
  }

  // Ensure OpenAI-required fields
-  if (!isClaudeMessageResponse) {
+  if (!isClaudeMessageResponse && !isResponsesResponse) {
    if (!translatedResponse.object) translatedResponse.object = "chat.completion";
    if (!translatedResponse.created) translatedResponse.created = Math.floor(Date.now() / 1000);
  }

  // Strip Azure-specific fields
-  if (!isClaudeMessageResponse) {
+  if (!isClaudeMessageResponse && !isResponsesResponse) {
    delete translatedResponse.prompt_filter_results;
    if (translatedResponse?.choices) {
      for (const choice of translatedResponse.choices) delete choice.content_filter_results;
@@ -274,7 +360,7 @@ export async function handleNonStreamingResponse({ providerResponse, provider, m
  // Strip reasoning_content only when content is non-empty.
  // When content is empty (e.g. thinking models that used all tokens for reasoning),
  // reasoning_content is the only useful output and must be preserved.
-  if (!isClaudeMessageResponse && translatedResponse?.choices) {
+  if (!isClaudeMessageResponse && !isResponsesResponse && translatedResponse?.choices) {
    for (const choice of translatedResponse.choices) {
      if (choice?.message?.reasoning_content && choice.message.content) {
        delete choice.message.reasoning_content;
--- a/open-sse/handlers/chatCore/sseToJsonHandler.js
+++ b/open-sse/handlers/chatCore/sseToJsonHandler.js
@@ -4,12 +4,8 @@ import { createErrorResult } from "../../utils/error.js";
 import { HTTP_STATUS } from "../../config/runtimeConfig.js";
 import { FORMATS } from "../../translator/formats.js";
 import { PROVIDERS } from "../../config/providers.js";
-import {
-	buildRequestDetail,
-	extractRequestConfig,
-	saveUsageStats,
-	formatDoneLine,
-} from "./requestDetail.js";
+import { buildRequestDetail, extractRequestConfig, saveUsageStats, formatDoneLine } from "./requestDetail.js";
+import { ROLE, RESPONSES_ITEM } from "../../translator/schema/index.js";

 // Responses-API providers (e.g. codex) may emit SSE without content-type + use Responses output shape
 const isResponsesProvider = (p) =>
@@ -41,6 +37,76 @@ function pickAssistantMessageForChatCompletion(output) {
 	return { msgItem: last, textContent: textFromResponsesMessageItem(last) };
 }

+/**
+ * Convert an OpenAI Chat Completions JSON body into the Responses API shape.
+ * Inlined here (not imported from nonStreamingHandler.js) to avoid a circular
+ * import. Mirrors openAICompletionToResponses in nonStreamingHandler.js.
+ */
+function extractCustomToolInput(argumentsValue) {
+  const argumentsText = typeof argumentsValue === "string" ? argumentsValue : JSON.stringify(argumentsValue || {});
+  try {
+    const parsed = JSON.parse(argumentsText);
+    if (parsed && typeof parsed === "object" && typeof parsed.input === "string") return parsed.input;
+  } catch { /* raw freeform input */ }
+  return argumentsText;
+}
+
+function chatCompletionToResponses(responseBody, customToolNames = null) {
+  const choice = responseBody?.choices?.[0];
+  if (!choice) return responseBody;
+
+  const message = choice.message || {};
+  const output = [];
+
+  const reasoning = message.reasoning_content || message.reasoning;
+  if (typeof reasoning === "string" && reasoning.length > 0) {
+    output.push({
+      type: RESPONSES_ITEM.REASONING,
+      summary: [{ type: RESPONSES_ITEM.SUMMARY_TEXT, text: reasoning }],
+    });
+  }
+
+  const text = typeof message.content === "string" ? message.content : "";
+  if (text.length > 0) {
+    output.push({
+      type: RESPONSES_ITEM.MESSAGE,
+      role: ROLE.ASSISTANT,
+      content: [{ type: RESPONSES_ITEM.OUTPUT_TEXT, text, annotations: [] }],
+    });
+  }
+
+  for (const tc of message.tool_calls || []) {
+    const fn = tc.function || {};
+    const custom = customToolNames?.has(fn.name);
+    output.push({
+      type: custom ? RESPONSES_ITEM.CUSTOM_TOOL_CALL : RESPONSES_ITEM.FUNCTION_CALL,
+      id: `${custom ? "ctc" : "fc"}_${tc.id || ""}`,
+      call_id: tc.id || "",
+      name: fn.name || "",
+      ...(custom
+        ? { input: extractCustomToolInput(fn.arguments) }
+        : { arguments: typeof fn.arguments === "string" ? fn.arguments : JSON.stringify(fn.arguments || {}) }),
+    });
+  }
+
+  const usage = responseBody.usage || {};
+  return {
+    id: `resp_${responseBody.id || ""}`.replace(/^resp_chatcmpl-/, "resp_"),
+    object: "response",
+    created_at: responseBody.created || Math.floor(Date.now() / 1000),
+    model: responseBody.model || "unknown",
+    status: "completed",
+    background: false,
+    error: null,
+    output,
+    usage: {
+      input_tokens: usage.prompt_tokens || usage.input_tokens || 0,
+      output_tokens: usage.completion_tokens || usage.output_tokens || 0,
+      total_tokens: usage.total_tokens || (usage.prompt_tokens || 0) + (usage.completion_tokens || 0),
+    },
+  };
+}
+
 /**
 * Parse OpenAI-style SSE text into a single chat completion JSON.
 * Used when provider forces streaming but client wants non-streaming.
@@ -136,6 +202,7 @@ export function parseSSEToOpenAIResponse(rawSSE, fallbackModel) {
 export async function handleForcedSSEToJson({
 	providerResponse,
 	sourceFormat,
+	targetFormat,
 	provider,
 	model,
 	body,
@@ -147,6 +214,7 @@ export async function handleForcedSSEToJson({
 	apiKey,
 	clientRawRequest,
 	onRequestSuccess,
+	customToolNames,
 	trackDone,
 	appendLog,
 	reqTag,
@@ -170,8 +238,11 @@ export async function handleForcedSSEToJson({
 	};

 	// Codex/Responses API SSE path
+	// Branch on the UPSTREAM format (targetFormat = format we spoke to the provider in),
+	// not the client format: a Responses-API client behind a chat-native forced-streaming
+	// provider still receives chat SSE chunks, which must go through the standard path.
 	const isCodexResponsesApi =
-		isResponsesProvider(provider) || sourceFormat === FORMATS.OPENAI_RESPONSES;
+		isResponsesProvider(provider) || targetFormat === FORMATS.OPENAI_RESPONSES;
 	if (isCodexResponsesApi) {
 		try {
 			const jsonResponse = await convertResponsesStreamToJson(
@@ -200,6 +271,11 @@ export async function handleForcedSSEToJson({
 					}),
 				);

+			// Same cache-inclusive total for the recorded detail, so the DB and the
+			// client-facing usage can never disagree.
+			const inTokensForLog = (usage.input_tokens || 0)
+				+ (usage.cache_read_input_tokens || usage.cached_tokens || 0)
+				+ (usage.cache_creation_input_tokens || 0);
 			const { msgItem, textContent } = pickAssistantMessageForChatCompletion(
 				jsonResponse.output,
 			);
@@ -209,9 +285,10 @@ export async function handleForcedSSEToJson({
 				buildRequestDetail(
 					{
 						...ctx,
+						apiKey,
 						latency: { ttft: totalLatency, total: totalLatency },
 						tokens: {
-							prompt_tokens: usage.input_tokens || 0,
+							prompt_tokens: inTokensForLog,
 							completion_tokens: usage.output_tokens || 0,
 						},
 						response: {
@@ -238,9 +315,22 @@ export async function handleForcedSSEToJson({
 				};
 			}

-			// Build client-format response
-			const inTokens = usage.input_tokens || 0;
+			// Build client-format response.
+			// input_tokens EXCLUDES cached tokens on cache-capable upstreams, so summing
+			// only input+output under-reports prompt_tokens — measured: 2012 reported
+			// where the real prompt was ~5344 with 5332 served from cache. Fold the cache
+			// counters in, and keep them visible in prompt_tokens_details so a client can
+			// tell a cache hit from a small prompt.
+			const cacheRead = usage.cache_read_input_tokens || usage.cached_tokens || 0;
+			const cacheCreate = usage.cache_creation_input_tokens || 0;
+			const inTokens = (usage.input_tokens || 0) + cacheRead + cacheCreate;
 			const outTokens = usage.output_tokens || 0;
+			const cacheDetails = (cacheRead > 0 || cacheCreate > 0)
+				? {
+					prompt_tokens_details: {
+						...(cacheRead > 0 ? { cached_tokens: cacheRead } : {}),
+						...(cacheCreate > 0 ? { cache_creation_tokens: cacheCreate } : {}) } }
+				: {};
 			let finalResp;

 			// Extract tool calls from Responses API output (function_call items)
@@ -309,6 +399,7 @@ export async function handleForcedSSEToJson({
 						prompt_tokens: inTokens,
 						completion_tokens: outTokens,
 						total_tokens: inTokens + outTokens,
+						...cacheDetails,
 					},
 				};
 			}
@@ -384,23 +475,14 @@ export async function handleForcedSSEToJson({
 				}),
 			);

-		const totalLatency = Date.now() - requestStartTime;
-		saveRequestDetail(
-			buildRequestDetail(
-				{
-					...ctx,
-					latency: { ttft: totalLatency, total: totalLatency },
-					tokens: usage,
-					response: {
-						content: parsed.choices?.[0]?.message?.content || null,
-						thinking: parsed.choices?.[0]?.message?.reasoning_content || null,
-						finish_reason: parsed.choices?.[0]?.finish_reason || "unknown",
-					},
-					status: "success",
-				},
-				{ endpoint: clientRawRequest?.endpoint || null },
-			),
-		).catch(() => {});
+		// Re-attach usage explicitly. This handler already HAS the correct usage — it is
+		// the same object written to the usage DB, and for a cached Claude request that DB
+		// row reads cache_read_input_tokens: 11022 — yet the client was observed receiving
+		// no usage field at all (verified 2026-08-04 with a fingerprinted payload matched
+		// on both sides). Whatever drops it between assembly and serialisation, the client
+		// must not be left unable to account for its own token spend: a caller cannot tell
+		// a 90%-cached request from a cheap one without this.
+		if (usage && Object.keys(usage).length > 0) parsed.usage = usage;

 		// Strip reasoning_content only when content is non-empty.
 		// When content is empty (e.g. thinking models that used all tokens for reasoning),
@@ -414,9 +496,19 @@ export async function handleForcedSSEToJson({
 			}
 		}

+		// A Responses-format client (e.g. Codex) forced this provider to stream,
+		// but wants JSON back. parseSSEToOpenAIResponse yields a Chat Completions
+		// body; convert it to the Responses `output` shape so tool_calls are not
+		// lost on the non-streaming return path. Inlined (not imported from
+		// nonStreamingHandler.js) to avoid a circular import: nonStreamingHandler
+		// already imports parseSSEToOpenAIResponse from this module.
+		const finalBody = sourceFormat === FORMATS.OPENAI_RESPONSES
+			? chatCompletionToResponses(parsed, customToolNames)
+			: parsed;
+
 		return {
 			success: true,
-			response: new Response(JSON.stringify(parsed), {
+			response: new Response(JSON.stringify(finalBody), {
 				headers: {
 					"Content-Type": "application/json",
 					"Access-Control-Allow-Origin": "*",
--- a/open-sse/handlers/chatCore/streamingHandler.js
+++ b/open-sse/handlers/chatCore/streamingHandler.js
@@ -38,6 +38,7 @@ function buildTransformStream({
 	userAgent,
 	reqLogger,
 	toolNameMap,
+	customToolNames,
 	model,
 	connectionId,
 	body,
@@ -68,6 +69,7 @@ function buildTransformStream({
 			body,
 			onStreamComplete,
 			apiKey,
+			customToolNames,
 		);
 	}

@@ -83,6 +85,7 @@ function buildTransformStream({
 			body,
 			onStreamComplete,
 			apiKey,
+			customToolNames,
 		);
 	}

@@ -118,6 +121,7 @@ export async function handleStreamingResponse({
 	onRequestSuccess,
 	reqLogger,
 	toolNameMap,
+	customToolNames,
 	streamController,
 	onStreamComplete,
 	streamDetailId,
@@ -200,6 +204,7 @@ export async function handleStreamingResponse({
 		userAgent,
 		reqLogger,
 		toolNameMap,
+		customToolNames,
 		model,
 		connectionId,
 		body,