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>

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": "*",