@jsonstudio/llms 0.6.1643 → 0.6.1739

package/dist/router/virtual-router/message-utils.js

@@ -59,8 +59,8 @@ export function detectExtendedThinkingKeyword(text) {
 export function detectImageAttachment(message) {
     if (!message)
         return false;
-    // 仅基于标准 Chat 语义判断是否携带图片：
-    // - content 为数组时查找 { type: 'image' | 'image_url' | 'input_image', ... } 块；
+    // 仅基于标准 Chat 语义判断是否携带视觉媒体（图片/视频）：
+    // - content 为数组时查找 { type: 'image' | 'image_url' | 'input_image' | 'video' | 'video_url' | 'input_video', ... } 块；
     // - 不再依赖 metadata.attachments，也不再用纯文本关键字或剪贴板标记作为信号。
     if (Array.isArray(message.content)) {
         for (const part of message.content) {
@@ -69,19 +69,29 @@ export function detectImageAttachment(message) {
             }
             const record = part;
             const typeValue = typeof record.type === 'string' ? record.type.toLowerCase() : '';
-            // For chat/standardized content, images may appear as:
+            // For chat/standardized content, media may appear as:
             // - { type: "image_url", image_url: { url } }
             // - { type: "image", uri: "...", data: "...", url: "..." }
             // - { type: "input_image", image_url: "data:..." }
-            // Treat any non-empty URL/URI/data on an image-* block as a signal.
+            // - { type: "video_url", video_url: { url } }
+            // - { type: "video", uri: "...", data: "...", url: "..." }
+            // - { type: "input_video", video_url: "data:..." }
+            // Treat any non-empty URL/URI/data on a media-* block as a signal.
             let imageCandidate = '';
             if (typeof record.image_url === 'string') {
                 imageCandidate = record.image_url ?? '';
             }
+            else if (typeof record.video_url === 'string') {
+                imageCandidate = record.video_url ?? '';
+            }
             else if (record.image_url &&
                 typeof record.image_url?.url === 'string') {
                 imageCandidate = record.image_url?.url ?? '';
             }
+            else if (record.video_url &&
+                typeof record.video_url?.url === 'string') {
+                imageCandidate = record.video_url?.url ?? '';
+            }
             else if (typeof record.url === 'string') {
                 imageCandidate = record.url ?? '';
             }
@@ -91,7 +101,7 @@ export function detectImageAttachment(message) {
             else if (typeof record.data === 'string') {
                 imageCandidate = record.data ?? '';
             }
-            if (typeValue.includes('image') && imageCandidate.trim().length > 0) {
+            if ((typeValue.includes('image') || typeValue.includes('video')) && imageCandidate.trim().length > 0) {
                 return true;
             }
         }

package/dist/servertool/engine.js

@@ -101,7 +101,7 @@ function isEmptyClientResponsePayload(payload) {
         return false;
     }
     // OpenAI Responses: requires_action (function_call output) is a meaningful response and must not be
-    // treated as "empty". Some auto-followup servertools (stop_message_flow / gemini_empty_reply_continue)
+    // treated as "empty". Some auto-followup servertools (stop_message_flow / empty_reply_continue)
     // previously misclassified this as empty because there is no output_text/content yet.
     const requiredAction = payload.required_action;
     if (requiredAction && typeof requiredAction === 'object') {
@@ -337,13 +337,13 @@ export async function runServerToolOrchestration(options) {
         };
     }
     const isStopMessageFlow = engineResult.execution.flowId === 'stop_message_flow';
-    const isGeminiEmptyReplyContinue = engineResult.execution.flowId === 'gemini_empty_reply_continue';
+    const isEmptyReplyContinue = engineResult.execution.flowId === 'empty_reply_continue';
     const isApplyPatchGuard = engineResult.execution.flowId === 'apply_patch_guard';
     const isExecCommandGuard = engineResult.execution.flowId === 'exec_command_guard';
     const stopMessageSource = isStopMessageFlow ? getStopMessageSource(options.adapterContext) : undefined;
     const isAutoStopMessage = isStopMessageFlow && stopMessageSource !== 'explicit';
     const isErrorAutoFlow = engineResult.execution.flowId === 'iflow_model_error_retry';
-    const applyAutoLimit = isAutoStopMessage || isErrorAutoFlow || isGeminiEmptyReplyContinue || isApplyPatchGuard || isExecCommandGuard;
+    const applyAutoLimit = isAutoStopMessage || isErrorAutoFlow || isEmptyReplyContinue || isApplyPatchGuard || isExecCommandGuard;
     // ServerTool followups must not inherit or inject any routeHint; always route fresh.
     const preserveRouteHint = false;
     const followupPlan = engineResult.execution.followup;
@@ -432,7 +432,7 @@ export async function runServerToolOrchestration(options) {
             metadata.__shadowCompareForcedProviderKey = providerKey;
         }
     }
-    const retryEmptyFollowupOnce = isStopMessageFlow || isGeminiEmptyReplyContinue;
+    const retryEmptyFollowupOnce = isStopMessageFlow || isEmptyReplyContinue;
     const maxAttempts = retryEmptyFollowupOnce ? 2 : 1;
     const followupRequestId = buildFollowupRequestId(options.requestId, engineResult.execution.followup.requestIdSuffix);
     let followupPayload = coerceFollowupPayloadStream(followupPayloadRaw, metadata.stream === true);

package/dist/servertool/handlers/followup-request-builder.js

@@ -249,6 +249,45 @@ function injectSystemTextIntoMessages(source, text) {
     messages.splice(insertAt, 0, sys);
     return messages;
 }
+function compactToolContentValue(value, maxChars) {
+    const text = typeof value === 'string'
+        ? value
+        : (() => {
+            try {
+                return JSON.stringify(value ?? '');
+            }
+            catch {
+                return String(value ?? '');
+            }
+        })();
+    if (text.length <= maxChars) {
+        return text;
+    }
+    const keepHead = Math.max(24, Math.floor(maxChars * 0.45));
+    const keepTail = Math.max(24, Math.floor(maxChars * 0.35));
+    const omitted = Math.max(0, text.length - keepHead - keepTail);
+    const head = text.slice(0, keepHead);
+    const tail = text.slice(text.length - keepTail);
+    return head + '\n...[tool_output_compacted omitted=' + String(omitted) + ']...\n' + tail;
+}
+function compactToolContentInMessages(source, options) {
+    const maxChars = Number.isFinite(options.maxChars) ? Math.max(64, Math.floor(options.maxChars)) : 1200;
+    const messages = Array.isArray(source) ? cloneJson(source) : [];
+    for (const message of messages) {
+        if (!message || typeof message !== 'object' || Array.isArray(message)) {
+            continue;
+        }
+        const role = typeof message.role === 'string'
+            ? String(message.role).trim().toLowerCase()
+            : '';
+        if (role !== 'tool') {
+            continue;
+        }
+        const content = message.content;
+        message.content = compactToolContentValue(content, maxChars);
+    }
+    return messages;
+}
 function buildStandardFollowupTools() {
     // Keep this list minimal and stable. Used only as a best-effort fallback when a followup hop
     // would otherwise have no tools at all (which can cause tool-based clients to "break" mid-session).
@@ -372,6 +411,13 @@ export function buildServerToolFollowupChatPayloadFromInjection(args) {
             messages = trimOpenAiMessagesForFollowup(messages, { maxNonSystemMessages });
             continue;
         }
+        if (op.op === 'compact_tool_content') {
+            const maxChars = typeof op.maxChars === 'number'
+                ? Math.max(64, Math.floor(op.maxChars))
+                : 1200;
+            messages = compactToolContentInMessages(messages, { maxChars });
+            continue;
+        }
         if (op.op === 'append_assistant_message') {
             const required = op.required !== false;
             const msg = extractAssistantMessageFromChatLike(args.chatResponse);

package/dist/servertool/handlers/gemini-empty-reply-continue.js

@@ -2,13 +2,13 @@ import { registerServerToolHandler } from '../registry.js';
 import { isCompactionRequest } from './compaction-detect.js';
 import { extractCapturedChatSeed } from './followup-request-builder.js';
 import { ensureRuntimeMetadata, readRuntimeMetadata } from '../../conversion/shared/runtime-metadata.js';
-const FLOW_ID = 'gemini_empty_reply_continue';
+const FLOW_ID = 'empty_reply_continue';
+const MAX_TOOL_HINTS = 24;
 const handler = async (ctx) => {
     if (!ctx.capabilities.reenterPipeline) {
         return null;
     }
     // 避免在 followup 请求里再次触发，防止循环。
-    const adapterRecord = ctx.adapterContext;
     const rt = readRuntimeMetadata(ctx.adapterContext);
     const followupRaw = rt?.serverToolFollowup;
     if (followupRaw === true || (typeof followupRaw === 'string' && followupRaw.trim().toLowerCase() === 'true')) {
@@ -17,22 +17,11 @@ const handler = async (ctx) => {
     if (hasCompactionFlag(rt)) {
         return null;
     }
-    // 仅针对 gemini-chat 协议 + antigravity.* providerKey 的 /v1/responses 路径启用。
-    if (ctx.providerProtocol !== 'gemini-chat') {
-        return null;
-    }
+    // 通用空回复续跑：只要是 /v1/responses 链路且满足空回复判定，不区分 provider family / protocol。
     const entryEndpoint = (ctx.entryEndpoint || '').toLowerCase();
     if (!entryEndpoint.includes('/v1/responses')) {
         return null;
     }
-    const providerKey = typeof adapterRecord.providerKey === 'string' && adapterRecord.providerKey.trim()
-        ? adapterRecord.providerKey.trim().toLowerCase()
-        : '';
-    const isAntigravity = providerKey.startsWith('antigravity.');
-    const isGeminiCli = providerKey.startsWith('gemini-cli.');
-    if (!isAntigravity && !isGeminiCli) {
-        return null;
-    }
     // 支持两种客户端协议形状：
     // - OpenAI Chat: choices[0].message.content
     // - OpenAI Responses: output/output_text/status
@@ -42,7 +31,7 @@ const handler = async (ctx) => {
         return null;
     }
     // 统计连续空回复次数，超过上限后不再自动续写，而是返回一个可重试错误。
-    const previousCountRaw = rt?.geminiEmptyReplyCount;
+    const previousCountRaw = rt?.emptyReplyContinueCount ?? rt?.geminiEmptyReplyCount;
     const previousCount = typeof previousCountRaw === 'number' && Number.isFinite(previousCountRaw) && previousCountRaw >= 0
         ? previousCountRaw
         : 0;
@@ -58,6 +47,7 @@ const handler = async (ctx) => {
     if (!seed) {
         return null;
     }
+    const continueText = buildContinueUserText(seed);
     // 超过最多 3 次空回复：返回一个 HTTP_HANDLER_ERROR 形状的错误，交由上层错误中心处理。
     if (nextCount > 3) {
         const errorChat = {
@@ -65,7 +55,7 @@ const handler = async (ctx) => {
             object: base.object,
             model: base.model,
             error: {
-                message: 'fetch failed: gemini_empty_reply_continue exceeded max empty replies',
+                message: 'fetch failed: empty_reply_continue exceeded max empty replies',
                 code: 'HTTP_HANDLER_ERROR',
                 type: 'servertool_empty_reply'
             }
@@ -80,7 +70,6 @@ const handler = async (ctx) => {
             })
         };
     }
-    const assistantMessage = extractAssistantMessageForFollowup(ctx.base);
     return {
         flowId: FLOW_ID,
         finalize: async () => ({
@@ -92,13 +81,16 @@ const handler = async (ctx) => {
                     entryEndpoint: ctx.entryEndpoint,
                     injection: {
                         ops: [
+                            { op: 'preserve_tools' },
                             { op: 'append_assistant_message', required: false },
-                            { op: 'append_user_text', text: '继续执行' }
+                            { op: 'append_user_text', text: continueText }
                         ]
                     },
                     metadata: (() => {
                         const meta = {};
                         const runtime = ensureRuntimeMetadata(meta);
+                        runtime.emptyReplyContinueCount = nextCount;
+                        // Backward compatibility for old snapshots/guards.
                         runtime.geminiEmptyReplyCount = nextCount;
                         return meta;
                     })()
@@ -107,7 +99,7 @@ const handler = async (ctx) => {
         })
     };
 };
-registerServerToolHandler('gemini_empty_reply_continue', handler, { trigger: 'auto' });
+registerServerToolHandler('empty_reply_continue', handler, { trigger: 'auto' });
 function decideEmptyReply(base) {
     // 1) OpenAI Chat shape
     const choices = Array.isArray(base.choices) ? base.choices : [];
@@ -164,34 +156,6 @@ function decideEmptyReply(base) {
     // 允许 output 为空或仅包含空消息：视作空回复，触发自动续写。
     return { shouldTrigger: true };
 }
-function extractAssistantMessageForFollowup(chatResponse) {
-    if (!chatResponse || typeof chatResponse !== 'object' || Array.isArray(chatResponse)) {
-        return null;
-    }
-    const choices = Array.isArray(chatResponse.choices)
-        ? chatResponse.choices
-        : [];
-    if (!choices.length) {
-        return null;
-    }
-    const first = choices[0];
-    if (!first || typeof first !== 'object' || Array.isArray(first)) {
-        return null;
-    }
-    const message = first.message;
-    if (!message || typeof message !== 'object' || Array.isArray(message)) {
-        return null;
-    }
-    const role = typeof message.role === 'string' ? String(message.role) : '';
-    if (role && role.toLowerCase() !== 'assistant') {
-        return null;
-    }
-    const content = message.content;
-    if (typeof content !== 'string' || !content.trim()) {
-        return null;
-    }
-    return { role: 'assistant', content: content.trim() };
-}
 function extractResponsesOutputText(base) {
     const raw = base.output_text;
     if (typeof raw === 'string') {
@@ -265,3 +229,40 @@ function hasCompactionFlag(rt) {
     }
     return false;
 }
+function buildContinueUserText(seed) {
+    const toolNames = collectToolNames(seed);
+    if (!toolNames.length) {
+        return '继续执行';
+    }
+    const shown = toolNames.slice(0, MAX_TOOL_HINTS);
+    const omitted = toolNames.length - shown.length;
+    const listText = shown.join(', ');
+    const tail = omitted > 0 ? `（其余 ${omitted} 个省略）` : '';
+    return `继续执行。可用工具列表：${listText}${tail}。请优先调用这些工具，不要返回空回复。`;
+}
+function collectToolNames(seed) {
+    const tools = Array.isArray(seed.tools) ? seed.tools : [];
+    if (!tools.length) {
+        return [];
+    }
+    const names = [];
+    const seen = new Set();
+    for (const tool of tools) {
+        if (!tool || typeof tool !== 'object' || Array.isArray(tool))
+            continue;
+        const fnNode = tool.function;
+        const fnName = fnNode && typeof fnNode === 'object' && !Array.isArray(fnNode)
+            ? normalizeToolName(fnNode.name)
+            : '';
+        const fallbackName = normalizeToolName(tool.name);
+        const resolvedName = fnName || fallbackName;
+        if (!resolvedName || seen.has(resolvedName))
+            continue;
+        seen.add(resolvedName);
+        names.push(resolvedName);
+    }
+    return names;
+}
+function normalizeToolName(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : '';
+}

package/dist/servertool/handlers/stop-message-auto.js

@@ -166,6 +166,20 @@ const handler = async (ctx) => {
         state.stopMessageUpdatedAt = now;
     }
     saveRoutingInstructionStateAsync(stickyKey, state);
+    const followupProviderKey = resolveStopMessageFollowupProviderKey({ record, runtimeMetadata: rt });
+    const followupToolContentMaxChars = resolveStopMessageFollowupToolContentMaxChars({
+        providerKey: followupProviderKey,
+        model: seed.model
+    });
+    const followupOps = [];
+    if (typeof followupToolContentMaxChars === 'number' &&
+        Number.isFinite(followupToolContentMaxChars) &&
+        followupToolContentMaxChars > 0) {
+        followupOps.push({ op: 'compact_tool_content', maxChars: Math.floor(followupToolContentMaxChars) });
+    }
+    followupOps.push({ op: 'append_assistant_message', required: false });
+    followupOps.push({ op: 'ensure_standard_tools' });
+    followupOps.push({ op: 'append_user_text', text });
     return {
         flowId: FLOW_ID,
         finalize: async () => ({
@@ -176,11 +190,7 @@ const handler = async (ctx) => {
                     requestIdSuffix: ':stop_followup',
                     entryEndpoint,
                     injection: {
-                        ops: [
-                            { op: 'append_assistant_message', required: false },
-                            { op: 'ensure_standard_tools' },
-                            { op: 'append_user_text', text }
-                        ]
+                        ops: followupOps
                     },
                     metadata: (connectionState ? { clientConnectionState: connectionState } : {})
                 }
@@ -202,6 +212,53 @@ function resolveStickyKey(record) {
     }
     return undefined;
 }
+function toNonEmptyText(value) {
+    return typeof value === 'string' && value.trim().length ? value.trim() : '';
+}
+function readProviderKeyFromMetadata(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return '';
+    }
+    const metadata = value;
+    const direct = toNonEmptyText(metadata.providerKey) ||
+        toNonEmptyText(metadata.providerId) ||
+        toNonEmptyText(metadata.targetProviderKey);
+    if (direct) {
+        return direct;
+    }
+    const target = metadata.target;
+    if (target && typeof target === 'object' && !Array.isArray(target)) {
+        const targetRecord = target;
+        return toNonEmptyText(targetRecord.providerKey) || toNonEmptyText(targetRecord.providerId);
+    }
+    return '';
+}
+function resolveStopMessageFollowupProviderKey(args) {
+    const direct = toNonEmptyText(args.record.providerKey) ||
+        toNonEmptyText(args.record.providerId) ||
+        readProviderKeyFromMetadata(args.record.metadata) ||
+        readProviderKeyFromMetadata(args.runtimeMetadata);
+    return direct;
+}
+function resolveStopMessageFollowupToolContentMaxChars(params) {
+    const raw = String(process.env.ROUTECODEX_STOPMESSAGE_FOLLOWUP_TOOL_CONTENT_MAX_CHARS || '').trim();
+    if (raw) {
+        const parsed = Number(raw);
+        if (Number.isFinite(parsed) && parsed > 0) {
+            return Math.max(64, Math.floor(parsed));
+        }
+        return undefined;
+    }
+    const providerKey = typeof params.providerKey === 'string' ? params.providerKey.trim().toLowerCase() : '';
+    if (providerKey.startsWith('iflow.')) {
+        return 1200;
+    }
+    const model = typeof params.model === 'string' ? params.model.trim().toLowerCase() : '';
+    if (model === 'kimi-k2.5' || model.startsWith('kimi-k2.5-')) {
+        return 1200;
+    }
+    return undefined;
+}
 function isStopFinishReason(base) {
     if (!base || typeof base !== 'object' || Array.isArray(base)) {
         return false;
@@ -425,7 +482,7 @@ function resolveImplicitGeminiStopMessageSnapshot(ctx, record) {
             return null;
         }
         // 仅在“空回复”时触发隐式 stopMessage：
-        // - 这个场景由 gemini_empty_reply_continue 专门处理；
+        // - 这个场景由 empty_reply_continue 专门处理；
         // - stop_message_auto 里的隐式逻辑只作为兼容兜底（且默认关闭），避免对正常 stop 响应追加“继续执行”。
         if (!isEmptyAssistantReply(ctx.base)) {
             return null;
@@ -456,7 +513,7 @@ function isEmptyAssistantReply(base) {
         const finishReason = typeof finishReasonRaw === 'string' && finishReasonRaw.trim()
             ? finishReasonRaw.trim().toLowerCase()
             : '';
-        // 仅接受 stop：length 截断通常并非“空回复”，而是需要续写（由 gemini_empty_reply_continue 负责）。
+        // 仅接受 stop：length 截断通常并非“空回复”，而是需要续写（由 empty_reply_continue 负责）。
         if (finishReason !== 'stop') {
             return false;
         }

package/dist/servertool/handlers/vision.js

@@ -103,6 +103,11 @@ function shouldRunVisionFlow(ctx) {
     }
     const providerType = typeof record.providerType === 'string' ? record.providerType.toLowerCase() : '';
     const providerProtocol = typeof record.providerProtocol === 'string' ? record.providerProtocol.toLowerCase() : '';
+    const modelId = typeof record.modelId === 'string'
+        ? record.modelId.trim().toLowerCase()
+        : typeof record.assignedModelId === 'string'
+            ? record.assignedModelId.trim().toLowerCase()
+            : '';
     const inlineMultimodal = providerType === 'gemini' ||
         providerType === 'responses' ||
         providerProtocol === 'gemini-chat' ||
@@ -110,6 +115,11 @@ function shouldRunVisionFlow(ctx) {
     if (inlineMultimodal) {
         return false;
     }
+    // Kimi K2.5 supports inline multimodal natively (image_url/video_url).
+    // When the routed model is kimi-k2.5, do not trigger the legacy vision detour.
+    if (modelId === 'kimi-k2.5') {
+        return false;
+    }
     return true;
 }
 function getCapturedRequest(adapterContext) {

package/dist/servertool/types.d.ts

@@ -74,6 +74,9 @@ export type ServerToolFollowupInjectionOp = {
 } | {
     op: 'trim_openai_messages';
     maxNonSystemMessages: number;
+} | {
+    op: 'compact_tool_content';
+    maxChars: number;
 };
 export type ServerToolFollowupInjectionPlan = {
     ops: ServerToolFollowupInjectionOp[];

package/dist/sse/sse-to-json/builders/response-builder.js

@@ -712,6 +712,12 @@ export class ResponsesResponseBuilder {
                         break;
                     }
                 case 'function_call':
+                    // Terminated SSE salvage may end before `function_call.done` / `output_item.done`.
+                    // In that case the builder state remains `in_progress` and arguments are usually partial/empty.
+                    // Do not promote such incomplete tool calls into a completed output item.
+                    if (state.status !== 'completed') {
+                        continue;
+                    }
                     outputItem = this.buildFunctionCallItem(state);
                     break;
                 case 'reasoning':

package/dist/sse/sse-to-json/chat-sse-to-json-converter.js

@@ -109,16 +109,46 @@ export class ChatSseToJsonConverter {
      */
     parseSseChunk(chunk) {
         const lines = chunk.trim().split('\n');
-        let eventType;
+        let rawEventType;
         let dataValue = '';
         for (const line of lines) {
             if (line.startsWith('event:')) {
-                eventType = line.substring(6).trim();
+                rawEventType = line.substring(6).trim();
             }
             else if (line.startsWith('data:')) {
                 dataValue = line.substring(5).trim();
             }
         }
+        const normalizeEventType = (candidate) => {
+            if (!candidate)
+                return undefined;
+            const v = candidate.trim();
+            if (!v)
+                return undefined;
+            // OpenAI Chat Completions SSE does not include `event:` lines; we infer types elsewhere.
+            // When upstream does include `event:`, accept common aliases for compatibility.
+            if (v === 'chat_chunk' || v === 'chat_chunk'.toLowerCase())
+                return 'chat_chunk';
+            if (v === 'chat.done' || v === 'chat_done')
+                return 'chat.done';
+            if (v === 'ping' || v === 'heartbeat')
+                return 'ping';
+            if (v === 'error')
+                return 'error';
+            // Legacy aliases
+            if (v === 'chunk')
+                return 'chat_chunk';
+            if (v === 'done')
+                return 'chat.done';
+            return undefined;
+        };
+        let eventType = normalizeEventType(rawEventType);
+        if (!eventType) {
+            // OpenAI-compatible streams often omit `event:`; use `[DONE]` sentinel to mark completion.
+            if (dataValue) {
+                eventType = dataValue === '[DONE]' ? 'chat.done' : 'chat_chunk';
+            }
+        }
         if (!eventType) {
             throw ErrorUtils.createError('SSE event type is required', CHAT_CONVERSION_ERROR_CODES.VALIDATION_ERROR, { chunk });
         }

package/dist/sse/sse-to-json/parsers/sse-parser.js

@@ -144,6 +144,36 @@ function validateEventType(eventType, config) {
     }
     return config.allowedEventTypes.has(eventType);
 }
+function inferEventTypeFromData(rawEvent, config) {
+    // LM Studio (and some other OpenAI-compatible servers) may omit the SSE `event:` line and only
+    // send JSON payloads like: `data: {"type":"response.output_item.added", ...}`.
+    // Per SSE spec the default event type becomes "message", but for our protocol converters we
+    // need the real OpenAI event type to pass strict validation and builder logic.
+    if (rawEvent.event && rawEvent.event !== 'message') {
+        return null;
+    }
+    if (!rawEvent.data) {
+        return null;
+    }
+    try {
+        const parsed = safeJsonParse(rawEvent.data);
+        if (!parsed || typeof parsed !== 'object') {
+            return null;
+        }
+        const candidate = parsed.type;
+        if (typeof candidate !== 'string' || !candidate.trim()) {
+            return null;
+        }
+        const normalized = candidate.trim();
+        if (!validateEventType(normalized, config)) {
+            return null;
+        }
+        return normalized;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * 创建基础事件对象
  */
@@ -279,6 +309,10 @@ export function parseSseEvent(sseText, config = DEFAULT_SSE_PARSER_CONFIG) {
             result.error = 'Invalid SSE event format';
             return result;
         }
+        const inferred = inferEventTypeFromData(rawEvent, config);
+        if (inferred) {
+            rawEvent.event = inferred;
+        }
         // 验证事件大小
         if (config.enableStrictValidation && sseText.length > config.maxEventSize) {
             result.error = `Event size ${sseText.length} exceeds maximum ${config.maxEventSize}`;

package/dist/sse/sse-to-json/responses-sse-to-json-converter.d.ts

@@ -15,6 +15,7 @@ export declare class ResponsesSseToJsonConverterRefactored {
      * 将SSE流转换为Responses响应
      */
     convertSseToJson(sseStream: ResponsesSseEventStream, options: SseToResponsesJsonOptions): Promise<ResponsesResponse>;
+    private isTerminatedError;
     /**
      * 创建可读流
      */

package/dist/sse/sse-to-json/responses-sse-to-json-converter.js

@@ -31,6 +31,7 @@ export class ResponsesSseToJsonConverterRefactored {
         // 1. 创建上下文
         const context = this.createContext(options);
         this.contexts.set(options.requestId, context);
+        let responseBuilder = null;
         try {
             // 2. 创建解析器
             const parser = createSseParser({
@@ -38,7 +39,7 @@ export class ResponsesSseToJsonConverterRefactored {
                 enableEventRecovery: !this.config.strictMode
             });
             // 3. 创建响应构建器
-            const responseBuilder = createResponseBuilder({
+            responseBuilder = createResponseBuilder({
                 enableStrictValidation: false,
                 enableEventRecovery: !this.config.strictMode,
                 maxOutputItems: 50,
@@ -100,6 +101,25 @@ export class ResponsesSseToJsonConverterRefactored {
             return result.response;
         }
         catch (error) {
+            // 容错：部分 OpenAI-compatible 上游（例如 LM Studio）在产出 tool_call 后会直接断开 SSE 连接，
+            // undici 会抛出 "terminated"。若此时已聚合出可用 response，则应优先返回而不是把它当作致命错误。
+            if (responseBuilder && this.isTerminatedError(error)) {
+                try {
+                    const salvaged = responseBuilder.getResult();
+                    if (salvaged.success && salvaged.response) {
+                        context.isCompleted = true;
+                        context.endTime = Date.now();
+                        context.duration = context.endTime - context.startTime;
+                        if (options.onCompletion) {
+                            options.onCompletion(salvaged.response);
+                        }
+                        return salvaged.response;
+                    }
+                }
+                catch {
+                    // ignore salvage failure, fall through to normal error path
+                }
+            }
             context.isCompleted = true;
             context.endTime = Date.now();
             context.duration = context.endTime - context.startTime;
@@ -114,6 +134,18 @@ export class ResponsesSseToJsonConverterRefactored {
             this.clearContext(options.requestId);
         }
     }
+    isTerminatedError(error) {
+        if (!error || typeof error !== 'object')
+            return false;
+        const msg = error.message;
+        if (typeof msg !== 'string') {
+            return false;
+        }
+        const normalized = msg.toLowerCase();
+        return (normalized.includes('terminated') ||
+            normalized.includes('upstream_stream_idle_timeout') ||
+            normalized.includes('upstream_stream_timeout'));
+    }
     /**
      * 创建可读流
      */

package/dist/tools/apply-patch/args-normalizer/default-actions.d.ts

@@ -0,0 +1,2 @@
+import type { ApplyPatchNormalizeAction } from './types.js';
+export declare const DEFAULT_APPLY_PATCH_NORMALIZE_ACTIONS: ApplyPatchNormalizeAction[];

package/dist/tools/apply-patch/args-normalizer/default-actions.js

@@ -0,0 +1,12 @@
+export const DEFAULT_APPLY_PATCH_NORMALIZE_ACTIONS = [
+    { action: 'raw_non_json_patch' },
+    { action: 'json_container_patch_fallback' },
+    { action: 'record_text_fields', fields: ['patch'] },
+    { action: 'record_conflict_patch', patchField: 'patch', fileFields: ['file', 'path', 'filepath', 'filename'] },
+    { action: 'record_text_fields', fields: ['diff', 'patchText', 'body', 'input', 'instructions'] },
+    { action: 'record_raw_envelope', field: '_raw', parseJson: true, maxDepth: 3 },
+    { action: 'record_structured_payload' },
+    { action: 'array_structured_payload' },
+    { action: 'raw_string_patch' },
+    { action: 'invalid_json_guard' }
+];

package/dist/tools/apply-patch/args-normalizer/extract-patch.d.ts

@@ -0,0 +1,2 @@
+import type { ApplyPatchExtraction } from './types.js';
+export declare function extractNormalizedPatch(value: string | undefined | null): ApplyPatchExtraction;