llm-simple-router 0.10.10 → 0.10.11

package/dist/db/index.d.ts

@@ -12,7 +12,7 @@ export { getRouterKeyByHash, getAllRouterKeys, getRouterKeyById, createRouterKey
 export type { RouterKey } from "./router-keys.js";
 export { getMetricsSummary, getMetricsTimeseries, insertMetrics, getClientTypeBreakdown } from "./metrics.js";
 export type { MetricsSummaryRow, MetricsTimeseriesRow, MetricsPeriod, MetricsMetric, MetricsRow, MetricsInsert, ClientTypeBreakdown } from "./metrics.js";
-export { getStats } from "./stats.js";
+export { getStats, getLatestMetricTime } from "./stats.js";
 export type { Stats } from "./stats.js";
 export { getSetting, setSetting, isInitialized } from "./settings.js";
 export { getDbMaxSizeMb, setDbMaxSizeMb, getLogTableMaxSizeMb, setLogTableMaxSizeMb, } from "./settings.js";

package/dist/db/index.js

@@ -145,7 +145,7 @@ export { getActiveRetryRules, getAllRetryRules, getRetryRuleById, createRetryRul
 export { insertRequestLog, getRequestLogs, getRequestLogById, deleteLogsBefore, getRequestLogChildren, getRequestLogsGrouped, updateLogStreamContent, updateLogClientStatus, estimateLogTableSize, deleteOldestLogs, getLogCount, updateLogPipelineSnapshot, } from "./logs.js";
 export { getRouterKeyByHash, getAllRouterKeys, getRouterKeyById, createRouterKey, updateRouterKey, deleteRouterKey, getAvailableModels, } from "./router-keys.js";
 export { getMetricsSummary, getMetricsTimeseries, insertMetrics, getClientTypeBreakdown } from "./metrics.js";
-export { getStats } from "./stats.js";
+export { getStats, getLatestMetricTime } from "./stats.js";
 export { getSetting, setSetting, isInitialized } from "./settings.js";
 export { getDbMaxSizeMb, setDbMaxSizeMb, getLogTableMaxSizeMb, setLogTableMaxSizeMb, } from "./settings.js";
 export { insertWindow, getLatestWindow, getWindowsInRange, getWindowUsage, } from "./usage-windows.js";

package/dist/db/migrations/046_fix_is_complete_for_successful_requests.sql

@@ -0,0 +1,10 @@
+-- Fix historical request_metrics where is_complete=0 despite successful responses.
+-- Root cause: StreamProxy.onEnd() collected metrics before SSE parser flush,
+-- causing is_complete to always be 0 for providers using OpenAI SSE format.
+-- Only fix records with clear success signals (status 200 + output tokens + duration).
+UPDATE request_metrics
+SET is_complete = 1
+WHERE is_complete = 0
+  AND status_code = 200
+  AND output_tokens > 0
+  AND total_duration_ms > 0;

package/dist/db/stats.d.ts

@@ -1,4 +1,6 @@
 import Database from "better-sqlite3";
+/** 获取指定条件下的最近一条 metric 的 created_at（用于窗口补齐定位，不限制 is_complete） */
+export declare function getLatestMetricTime(db: Database.Database, providerId?: string, routerKeyId?: string): string | null;
 export interface Stats {
     totalRequests: number;
     successRate: number;

package/dist/db/stats.js

@@ -1,3 +1,19 @@
+/** 获取指定条件下的最近一条 metric 的 created_at（用于窗口补齐定位，不限制 is_complete） */
+export function getLatestMetricTime(db, providerId, routerKeyId) {
+    const conditions = [];
+    const params = [];
+    if (providerId) {
+        conditions.push("rm.provider_id = ?");
+        params.push(providerId);
+    }
+    if (routerKeyId) {
+        conditions.push("rm.router_key_id = ?");
+        params.push(routerKeyId);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const row = db.prepare(`SELECT rm.created_at FROM request_metrics rm ${where} ORDER BY rm.created_at DESC LIMIT 1`).get(...params);
+    return row?.created_at ?? null;
+}
 export function getStats(db, startTime, endTime, routerKeyId, providerId, backendModel) {
     const conditions = [
         "rm.is_complete = 1",

package/dist/metrics/sse-metrics-transform.d.ts

@@ -30,6 +30,8 @@ export declare class SSEMetricsTransform extends Transform {
     constructor(apiType: "openai" | "openai-responses" | "anthropic", requestStartTime: number, options?: MetricsTransformOptions);
     _transform(chunk: Buffer, _encoding: BufferEncoding, callback: TransformCallback): void;
     _flush(callback: TransformCallback): void;
+    /** Flush SSE parser 缓冲区并处理残余事件，确保 extractor 状态完整 */
+    flushParser(): void;
     getExtractor(): MetricsExtractor;
     /** 从 SSE 事件中提取内容文本，触发 onContentDelta 回调 */
     private emitContentDelta;

package/dist/metrics/sse-metrics-transform.js

@@ -54,6 +54,14 @@ export class SSEMetricsTransform extends Transform {
         }
         callback();
     }
+    /** Flush SSE parser 缓冲区并处理残余事件，确保 extractor 状态完整 */
+    flushParser() {
+        const events = this.parser.flush();
+        for (const event of events) {
+            this.extractor.processEvent(event);
+            this.emitContentDelta(event);
+        }
+    }
     getExtractor() {
         return this.extractor;
     }

package/dist/proxy/format/registry.d.ts

@@ -11,7 +11,7 @@ export declare class FormatRegistry {
         body: Record<string, unknown>;
         upstreamPath: string;
     };
-    transformResponse(bodyStr: string, source: string, target: string): string;
-    transformError(bodyStr: string, source: string, target: string): string;
+    transformResponse(body: Record<string, unknown>, source: string, target: string): Record<string, unknown>;
+    transformError(body: Record<string, unknown>, source: string, target: string): string;
     createStreamTransform(source: string, target: string, model: string): Transform | undefined;
 }

package/dist/proxy/format/registry.js

@@ -21,26 +21,25 @@ export class FormatRegistry {
             return { body, upstreamPath };
         return { body: converter.transformRequest(body, model), upstreamPath };
     }
-    transformResponse(bodyStr, source, target) {
+    transformResponse(body, source, target) {
         const converter = this.converters.get(`${source}→${target}`);
         if (!converter)
-            return bodyStr;
-        return converter.transformResponse(bodyStr);
+            return body;
+        return converter.transformResponse(body);
     }
-    transformError(bodyStr, source, target) {
+    transformError(body, source, target) {
         if (source === target)
-            return bodyStr;
+            return JSON.stringify(body);
         try {
-            const parsed = JSON.parse(bodyStr);
-            const message = parsed.error?.message ?? parsed.message ?? JSON.stringify(parsed);
-            const code = parsed.error?.code ?? parsed.code;
+            const message = body.error?.message ?? body.message ?? JSON.stringify(body);
+            const code = body.error?.code ?? body.code;
             const targetAdapter = this.adapters.get(target);
             if (!targetAdapter)
-                return bodyStr;
+                return JSON.stringify(body);
             return JSON.stringify(targetAdapter.formatError(message, code));
         }
         catch {
-            return bodyStr;
+            return JSON.stringify(body);
         }
     }
     createStreamTransform(source, target, model) {

package/dist/proxy/format/types.d.ts

@@ -14,7 +14,7 @@ export interface FormatConverter {
     readonly sourceType: string;
     readonly targetType: string;
     transformRequest(body: Record<string, unknown>, model: string): Record<string, unknown>;
-    transformResponse(bodyStr: string): string;
+    transformResponse(body: Record<string, unknown>): Record<string, unknown>;
     createStreamTransform(model: string): Transform;
 }
 /** Factory: eliminates repetitive object literal structure across 6 converters. */
@@ -22,6 +22,6 @@ export declare function createConverter(deps: {
     sourceType: string;
     targetType: string;
     requestTransform: (body: Record<string, unknown>) => Record<string, unknown>;
-    responseTransform: (bodyStr: string) => string;
+    responseTransform: (body: Record<string, unknown>) => Record<string, unknown>;
     streamTransformClass: new (model: string) => Transform;
 }): FormatConverter;

package/dist/proxy/format/types.js

@@ -6,8 +6,8 @@ export function createConverter(deps) {
         transformRequest(body) {
             return deps.requestTransform(body);
         },
-        transformResponse(bodyStr) {
-            return deps.responseTransform(bodyStr);
+        transformResponse(body) {
+            return deps.responseTransform(body);
         },
         createStreamTransform(model) {
             return new deps.streamTransformClass(model);

package/dist/proxy/handler/failover-loop.js

@@ -251,25 +251,24 @@ export async function executeFailoverLoop(ctx, errors, deps, upstreamPath, adapt
             try {
                 const parsed = JSON.parse(bodyStr);
                 if (parsed.type === "error" || parsed.error) {
-                    return formatRegistry.transformError(bodyStr, provider.api_type, ctx.apiType);
+                    return formatRegistry.transformError(parsed, provider.api_type, ctx.apiType);
                 }
-                let transformed = formatRegistry.transformResponse(bodyStr, provider.api_type, ctx.apiType);
+                let transformed = formatRegistry.transformResponse(parsed, provider.api_type, ctx.apiType);
                 if (pluginRegistry && !isStream) {
                     try {
-                        const respObj = JSON.parse(transformed);
                         const respCtx = {
-                            response: respObj,
+                            response: transformed,
                             sourceApiType: provider.api_type,
                             targetApiType: clientApiType,
                             provider: { id: provider.id, name: provider.name, base_url: provider.base_url, api_type: provider.api_type },
                         };
                         pluginRegistry.applyBeforeResponse(respCtx);
                         pluginRegistry.applyAfterResponse(respCtx);
-                        transformed = JSON.stringify(respCtx.response);
+                        transformed = respCtx.response;
                     }
                     catch { /* response hooks best-effort */ } // eslint-disable-line taste/no-silent-catch
                 }
-                return transformed;
+                return JSON.stringify(transformed);
             }
             catch (err) {
                 request.log.error({ err }, "responseTransform failed");

package/dist/proxy/routing/usage-window-tracker.d.ts

@@ -2,12 +2,10 @@ import Database from "better-sqlite3";
 export declare class UsageWindowTracker {
     private db;
     constructor(db: Database.Database);
-    /** 请求成功后调用，按需创建新窗口 */
+    /** 请求成功后调用，按需创建新窗口（前向模式：窗口 = [now, now + 5h]） */
     recordRequest(providerId: string, routerKeyId?: string): void;
-    /** 启动时按活跃 provider 补齐缺失的窗口 */
+    /** 启动时按活跃 provider 补齐缺失的窗口（每个 provider 仅创建一个前向窗口） */
     reconcileOnStartup(): void;
-    /** 为单个 provider 补齐窗口 */
+    /** 为单个 provider 补齐窗口：无窗口时基于最新 log 创建前向窗口 */
     private reconcileProvider;
-    /** 从 baseTime 开始，每 5h 一个窗口，直到覆盖 lastLogTime */
-    private backfillProviderWindows;
 }

package/dist/proxy/routing/usage-window-tracker.js

@@ -4,71 +4,56 @@ import { getAllProviders } from "../../db/providers.js";
 import { toSqliteDatetime, parseSqliteDatetime as parseDate } from "../../utils/datetime.js";
 // eslint-disable-next-line no-magic-numbers
 const WINDOW_DURATION_MS = 5 * 3600_000;
+const MS_PER_MINUTE = 60000;
+// 过期判断最小间隔（毫秒），同分钟内不重复创建窗口
+const WINDOW_GRACE_PERIOD_MS = MS_PER_MINUTE;
 export class UsageWindowTracker {
     db;
     constructor(db) {
         this.db = db;
     }
-    /** 请求成功后调用，按需创建新窗口 */
+    /** 请求成功后调用，按需创建新窗口（前向模式：窗口 = [now, now + 5h]） */
     recordRequest(providerId, routerKeyId) {
         const now = new Date();
         const latest = getLatestWindow(this.db, routerKeyId, providerId);
-        if (!latest || now > parseDate(latest.end_time)) {
-            const startTime = truncateToMinute(now);
-            insertWindow(this.db, {
-                id: randomUUID(),
-                router_key_id: routerKeyId ?? null,
-                provider_id: providerId,
-                start_time: toSqliteDatetime(startTime),
-                end_time: toSqliteDatetime(new Date(startTime.getTime() + WINDOW_DURATION_MS)),
-            });
+        // 无窗口 → 创建。有窗口但已过期（end_time <= now）且跨分钟 → 新窗口。
+        // 同分钟内的快速调用不重复创建，避免同一分钟内的多次请求产生多个窗口。
+        if (!latest) {
+            createForwardWindow(this.db, now, routerKeyId, providerId);
+        }
+        else if (parseDate(latest.end_time) <= now
+            && now.getTime() - parseDate(latest.end_time).getTime() >= WINDOW_GRACE_PERIOD_MS) {
+            createForwardWindow(this.db, now, routerKeyId, providerId);
         }
     }
-    /** 启动时按活跃 provider 补齐缺失的窗口 */
+    /** 启动时按活跃 provider 补齐缺失的窗口（每个 provider 仅创建一个前向窗口） */
     reconcileOnStartup() {
         const providers = getAllProviders(this.db).filter((p) => p.is_active);
         for (const provider of providers) {
             this.reconcileProvider(provider.id);
         }
     }
-    /** 为单个 provider 补齐窗口 */
+    /** 为单个 provider 补齐窗口：无窗口时基于最新 log 创建前向窗口 */
     reconcileProvider(providerId) {
         const latest = getLatestWindow(this.db, undefined, providerId);
-        const lastLog = this.db.prepare("SELECT created_at FROM request_logs WHERE provider_id = ? ORDER BY created_at DESC LIMIT 1").get(providerId);
-        if (!lastLog)
+        if (latest)
             return;
-        if (!latest) {
-            const firstLog = this.db.prepare("SELECT created_at FROM request_logs WHERE provider_id = ? ORDER BY created_at ASC LIMIT 1").get(providerId);
-            if (!firstLog)
-                return;
-            const truncated = truncateToMinute(parseDate(firstLog.created_at));
-            this.backfillProviderWindows(providerId, truncated);
-            return;
-        }
-        this.backfillProviderWindows(providerId, parseDate(latest.end_time));
-    }
-    /** 从 baseTime 开始，每 5h 一个窗口，直到覆盖 lastLogTime */
-    backfillProviderWindows(providerId, baseTime) {
         const lastLog = this.db.prepare("SELECT created_at FROM request_logs WHERE provider_id = ? ORDER BY created_at DESC LIMIT 1").get(providerId);
         if (!lastLog)
             return;
-        const lastLogTime = parseDate(lastLog.created_at);
-        let windowStart = baseTime;
-        while (windowStart < lastLogTime) {
-            const windowEnd = new Date(windowStart.getTime() + WINDOW_DURATION_MS);
-            insertWindow(this.db, {
-                id: randomUUID(),
-                router_key_id: null,
-                provider_id: providerId,
-                start_time: toSqliteDatetime(windowStart),
-                end_time: toSqliteDatetime(windowEnd),
-            });
-            windowStart = windowEnd;
-        }
+        const anchor = parseDate(lastLog.created_at);
+        createForwardWindow(this.db, anchor, undefined, providerId);
     }
 }
-function truncateToMinute(date) {
-    const d = new Date(date);
-    d.setSeconds(0, 0);
-    return d;
+/** 创建 5h 前向窗口：窗口 = [start, start + 5h]，start 向下取整到分钟 */
+function createForwardWindow(db, anchor, routerKeyId, providerId) {
+    const start = new Date(Math.floor(anchor.getTime() / MS_PER_MINUTE) * MS_PER_MINUTE);
+    const end = new Date(start.getTime() + WINDOW_DURATION_MS);
+    insertWindow(db, {
+        id: randomUUID(),
+        router_key_id: routerKeyId ?? null,
+        provider_id: providerId ?? null,
+        start_time: toSqliteDatetime(start),
+        end_time: toSqliteDatetime(end),
+    });
 }

package/dist/proxy/transform/message-mapper.js

@@ -66,6 +66,8 @@ export function convertMessagesOA2Ant(messages) {
             // tool_calls → tool_use blocks
             if (msg.tool_calls) {
                 for (const tc of msg.tool_calls) {
+                    if (!tc.function)
+                        continue;
                     const input = parseToolArguments(tc.function.arguments);
                     blocks.push({ type: "tool_use", id: sanitizeToolUseId(tc.id), name: tc.function.name, input });
                 }
@@ -160,10 +162,28 @@ export function convertMessagesAnt2OA(system, messages) {
             if (!content?.length)
                 continue;
             const textParts = content.filter((b) => b.type === "text");
+            const imageParts = content.filter((b) => b.type === "image");
             const toolResults = content.filter((b) => b.type === "tool_result");
-            if (textParts.length > 0) {
+            // 仅有 text → 简单字符串 content
+            if (textParts.length > 0 && imageParts.length === 0) {
                 result.push({ role: "user", content: textParts.map(b => b.text).join("") });
             }
+            else if (textParts.length > 0 || imageParts.length > 0) {
+                // 有 image 或混合 → content part 数组
+                const parts = [];
+                for (const tb of textParts) {
+                    parts.push({ type: "text", text: tb.text });
+                }
+                for (const ib of imageParts) {
+                    if (ib.source.type === "base64" && ib.source.data) {
+                        parts.push({ type: "image_url", image_url: { url: `data:${ib.source.media_type};base64,${ib.source.data}` } });
+                    }
+                    else if (ib.source.type === "url" && ib.source.url) {
+                        parts.push({ type: "image_url", image_url: { url: ib.source.url } });
+                    }
+                }
+                result.push({ role: "user", content: parts });
+            }
             for (const tr of toolResults) {
                 let toolCallId = tr.tool_use_id;
                 // 空 tool_use_id → 按顺序配对到预生成的 UUID
@@ -198,7 +218,7 @@ export function convertMessagesAnt2OA(system, messages) {
                 oaiMsg.tool_calls = toolBlocks.map((b, i) => ({
                     id: b.id || (idMap ? idMap.get(i) || randomUUID() : randomUUID()),
                     type: "function",
-                    function: { name: b.name, arguments: JSON.stringify(b.input ?? {}) },
+                    function: { name: b.name ?? "unknown", arguments: JSON.stringify(b.input ?? {}) },
                 }));
             }
             if (oaiMsg.content || oaiMsg.tool_calls) {

package/dist/proxy/transform/request-bridge-responses.js

@@ -55,17 +55,50 @@ export function responsesToChatRequest(body) {
             result.tools = chatTools;
         }
     }
-    // tool_choice — compatible between Chat and Responses
+    // tool_choice — normalize {type:"tool"} from Cursor IDE, then pass through
     if (req.tool_choice != null) {
-        result.tool_choice = req.tool_choice;
+        const tc = req.tool_choice;
+        if (typeof tc === "object" && tc !== null) {
+            const obj = tc;
+            if (obj.type === "tool" && !obj.name) {
+                result.tool_choice = "required";
+            }
+            else {
+                result.tool_choice = tc;
+            }
+        }
+        else {
+            result.tool_choice = tc;
+        }
     }
     // reasoning — pass through (both use {effort?, max_tokens?})
     if (req.reasoning != null) {
         result.reasoning = req.reasoning;
     }
-    // text.format → response_format
+    // text.format → response_format (json_schema 结构差异需转换)
     if (req.text?.format != null) {
-        result.response_format = req.text.format;
+        const format = req.text.format;
+        if (format.type === "json_schema") {
+            result.response_format = {
+                type: "json_schema",
+                json_schema: {
+                    name: format.name ?? "response_schema",
+                    schema: format.schema ?? {},
+                    strict: format.strict ?? false,
+                },
+            };
+        }
+        else {
+            result.response_format = format;
+        }
+    }
+    // parallel_tool_calls — pass through
+    if (req.parallel_tool_calls != null) {
+        result.parallel_tool_calls = req.parallel_tool_calls;
+    }
+    // metadata.user_id → user
+    if (req.metadata?.user_id) {
+        result.user = req.metadata.user_id;
     }
     // stream_options
     if (req.stream_options != null) {
@@ -135,6 +168,10 @@ function convertResponsesInputToChatMessages(input, messages) {
     if (pendingFnCalls.length > 0) {
         flushFunctionCalls(messages, pendingFnCalls);
     }
+    // Post-process: 确保 system/developer 消息不出现在 assistant(tool_calls) 和 tool 之间
+    // Responses API 允许 function_call 和 function_call_output 之间插入 developer 消息，
+    // 但 Chat Completions 格式要求 assistant(tool_calls) 后必须紧跟 tool 消息。
+    reorderMessagesAroundToolCalls(messages);
 }
 /**
  * Flush accumulated function_call tool_calls into a single assistant message.
@@ -147,6 +184,81 @@ function flushFunctionCalls(messages, pending) {
     });
     pending.length = 0;
 }
+/**
+ * 将 system/developer 消息从 assistant(tool_calls) 和 tool 之间移走。
+ *
+ * Responses API 允许 function_call 和 function_call_output 之间插入 developer 消息，
+ * 但 Chat Completions 格式要求 assistant(tool_calls) 后必须紧跟对应的 tool 消息。
+ *
+ * 算法：遍历 messages，当发现 assistant(tool_calls) 后紧跟的非 tool 消息时，
+ * 收集这些非 tool 消息，跳过后续的 tool 消息，然后在 tool 消息之后插入收集的非 tool 消息。
+ */
+function reorderMessagesAroundToolCalls(messages) {
+    const toolCallIds = new Set();
+    // 先收集所有 assistant tool_calls 的 ID，用于判断 tool 消息是否属于该批次
+    for (const msg of messages) {
+        if (msg.role === "assistant" && msg.tool_calls) {
+            const calls = msg.tool_calls;
+            for (const tc of calls) {
+                if (typeof tc.id === "string")
+                    toolCallIds.add(tc.id);
+            }
+        }
+    }
+    let i = 0;
+    while (i < messages.length) {
+        const msg = messages[i];
+        // 找到 assistant(tool_calls) 消息
+        if (msg.role === "assistant" && msg.tool_calls) {
+            const calls = msg.tool_calls;
+            const batchIds = new Set(calls.map((tc) => tc.id));
+            // 检查紧跟的消息是否为 tool 消息
+            let j = i + 1;
+            const pendingNonTool = [];
+            while (j < messages.length) {
+                const next = messages[j];
+                if (next.role === "tool" && batchIds.has(next.tool_call_id)) {
+                    // 这是属于当前 assistant 的 tool 消息，停止扫描
+                    break;
+                }
+                if (next.role === "system" || next.role === "developer") {
+                    // 收集需要延后的 system/developer 消息
+                    pendingNonTool.push(next);
+                    j++;
+                }
+                else if (next.role === "tool") {
+                    // 属于其他 assistant 的 tool 消息，停止
+                    break;
+                }
+                else {
+                    // 其他角色消息（user/assistant），停止
+                    break;
+                }
+            }
+            if (pendingNonTool.length > 0) {
+                // 从 messages 中删除这些非 tool 消息
+                messages.splice(i + 1, pendingNonTool.length);
+                // 找到属于当前 assistant 的所有 tool 消息的末尾位置
+                let toolEnd = i + 1; // splice 后 j 可能已经变了
+                while (toolEnd < messages.length) {
+                    const candidate = messages[toolEnd];
+                    if (candidate.role === "tool" && batchIds.has(candidate.tool_call_id)) {
+                        toolEnd++;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                // 在 tool 消息之后插入收集的非 tool 消息
+                messages.splice(toolEnd, 0, ...pendingNonTool);
+                // 跳过处理过的消息
+                i = toolEnd + pendingNonTool.length;
+                continue;
+            }
+        }
+        i++;
+    }
+}
 /**
  * Extract text content from a ResponseInputMessage.
  */
@@ -223,9 +335,34 @@ export function chatToResponsesRequest(body) {
     if (req.reasoning != null) {
         result.reasoning = req.reasoning;
     }
-    // response_format → text.format
+    // response_format → text.format (json_schema 结构差异需转换)
     if (req.response_format != null) {
-        result.text = { format: req.response_format };
+        const rf = req.response_format;
+        if (rf.type === "json_schema" && rf.json_schema) {
+            const js = rf.json_schema;
+            result.text = {
+                format: {
+                    type: "json_schema",
+                    name: js.name ?? "response_schema",
+                    schema: js.schema,
+                    strict: js.strict,
+                },
+            };
+        }
+        else if (rf.type === "json_object") {
+            result.text = { format: { type: "json_object" } };
+        }
+        else {
+            result.text = { format: rf };
+        }
+    }
+    // parallel_tool_calls — pass through
+    if (req.parallel_tool_calls != null) {
+        result.parallel_tool_calls = req.parallel_tool_calls;
+    }
+    // user → metadata.user_id
+    if (req.user) {
+        result.metadata = { user_id: req.user };
     }
     // stream_options
     if (req.stream_options != null) {
@@ -259,12 +396,41 @@ function convertChatMessagesToResponsesInput(messages) {
     const items = [];
     for (const msg of messages) {
         if (msg.role === "user") {
-            const text = typeof msg.content === "string" ? msg.content : (msg.content ?? "");
-            items.push({
-                type: "message",
-                role: "user",
-                content: [{ type: "input_text", text }],
-            });
+            const raw = msg.content;
+            if (typeof raw === "string") {
+                items.push({
+                    type: "message",
+                    role: "user",
+                    content: [{ type: "input_text", text: raw }],
+                });
+            }
+            else if (Array.isArray(raw)) {
+                const parts = [];
+                for (const part of raw) {
+                    if (typeof part === "object" && part !== null) {
+                        const p = part;
+                        if (p.type === "text" && p.text != null) {
+                            parts.push({ type: "input_text", text: p.text });
+                        }
+                        else if (p.type === "image_url") {
+                            parts.push({
+                                type: "input_image",
+                                image_url: p.image_url?.url ?? "",
+                            });
+                        }
+                    }
+                }
+                if (parts.length > 0) {
+                    items.push({ type: "message", role: "user", content: parts });
+                }
+            }
+            else if (raw != null) {
+                items.push({
+                    type: "message",
+                    role: "user",
+                    content: [{ type: "input_text", text: JSON.stringify(raw) }],
+                });
+            }
         }
         else if (msg.role === "assistant") {
             // Text content → assistant message with output_text