@jsonstudio/llms 0.6.568 → 0.6.626

package/dist/conversion/hub/semantic-mappers/responses-mapper.js

@@ -2,6 +2,7 @@ import { isJsonObject, jsonClone } from '../types/json.js';
 import { createBridgeActionState, runBridgeActionPipeline } from '../../shared/bridge-actions.js';
 import { resolveBridgePolicy, resolvePolicyActions } from '../../shared/bridge-policies.js';
 import { captureResponsesContext, buildChatRequestFromResponses, buildResponsesRequestFromChat } from '../../responses/responses-openai-bridge.js';
+import { maybeAugmentApplyPatchErrorContent } from './chat-mapper.js';
 const RESPONSES_PARAMETER_KEYS = [
     'model',
     'temperature',
@@ -19,6 +20,7 @@ const RESPONSES_PARAMETER_KEYS = [
     'stop_sequences',
     'modalities'
 ];
+const RESPONSES_SUBMIT_ENDPOINT = '/v1/responses.submit_tool_outputs';
 function mapToolOutputs(entries, missing) {
     if (!entries || !entries.length)
         return undefined;
@@ -45,10 +47,12 @@ function mapToolOutputs(entries, missing) {
                 content = String(entry.output);
             }
         }
+        const nameValue = typeof entry.name === 'string' ? entry.name : undefined;
+        const augmented = maybeAugmentApplyPatchErrorContent(content, nameValue);
         outputs.push({
             tool_call_id: String(callId),
-            content,
-            name: typeof entry.name === 'string' ? entry.name : undefined
+            content: augmented,
+            name: nameValue
         });
     });
     return outputs.length ? outputs : undefined;
@@ -197,6 +201,259 @@ function mergeMetadata(a, b) {
     const right = jsonClone(b);
     return { ...left, ...right };
 }
+function isSubmitToolOutputsEndpoint(ctx) {
+    if (!ctx || typeof ctx !== 'object') {
+        return false;
+    }
+    const entry = typeof ctx.entryEndpoint === 'string' ? ctx.entryEndpoint.trim().toLowerCase() : '';
+    return entry === RESPONSES_SUBMIT_ENDPOINT;
+}
+function attachResponsesSemantics(existing, context, resume) {
+    if (!context && !resume) {
+        return existing;
+    }
+    const next = existing ? { ...existing } : {};
+    const currentNode = next.responses && isJsonObject(next.responses) ? { ...next.responses } : {};
+    if (context) {
+        currentNode.context = jsonClone(context);
+    }
+    if (resume) {
+        currentNode.resume = jsonClone(resume);
+    }
+    next.responses = currentNode;
+    return next;
+}
+function extractResponsesSemanticsNode(chat) {
+    if (!chat?.semantics || typeof chat.semantics !== 'object') {
+        return undefined;
+    }
+    const node = chat.semantics.responses;
+    return node && isJsonObject(node) ? node : undefined;
+}
+function readResponsesContextFromSemantics(chat) {
+    const node = extractResponsesSemanticsNode(chat);
+    if (!node) {
+        return undefined;
+    }
+    const contextNode = node.context;
+    if (!contextNode || !isJsonObject(contextNode)) {
+        return undefined;
+    }
+    return jsonClone(contextNode);
+}
+function readResponsesResumeFromSemantics(chat) {
+    const node = extractResponsesSemanticsNode(chat);
+    if (!node) {
+        return undefined;
+    }
+    const resumeNode = node.resume;
+    if (!resumeNode || !isJsonObject(resumeNode)) {
+        return undefined;
+    }
+    return jsonClone(resumeNode);
+}
+function selectResponsesContextSnapshot(chat, envelopeMetadata) {
+    const semanticsContext = readResponsesContextFromSemantics(chat);
+    const metadataContextCandidate = chat.metadata?.responsesContext;
+    const metadataContext = metadataContextCandidate && isJsonObject(metadataContextCandidate)
+        ? jsonClone(metadataContextCandidate)
+        : undefined;
+    const context = semanticsContext ??
+        metadataContext ??
+        {
+            metadata: envelopeMetadata
+        };
+    const mergedMetadata = mergeMetadata(context.metadata ?? undefined, envelopeMetadata);
+    if (mergedMetadata) {
+        context.metadata = mergedMetadata;
+    }
+    return context;
+}
+function resolveSubmitResponseId(ctx, responsesContext) {
+    const resumeMeta = ctx.responsesResume && typeof ctx.responsesResume === 'object'
+        ? ctx.responsesResume
+        : undefined;
+    const resumeId = typeof resumeMeta?.restoredFromResponseId === 'string'
+        ? resumeMeta.restoredFromResponseId.trim()
+        : undefined;
+    if (resumeId) {
+        return resumeId;
+    }
+    const contextRecord = responsesContext && typeof responsesContext === 'object'
+        ? responsesContext
+        : undefined;
+    const previousId = typeof contextRecord?.previous_response_id === 'string'
+        ? contextRecord.previous_response_id.trim()
+        : undefined;
+    if (previousId) {
+        return previousId;
+    }
+    return undefined;
+}
+function extractSubmitMetadata(responsesContext, resumeMeta) {
+    if (responsesContext && responsesContext.metadata && isJsonObject(responsesContext.metadata)) {
+        return jsonClone(responsesContext.metadata);
+    }
+    if (resumeMeta && resumeMeta.metadata && isJsonObject(resumeMeta.metadata)) {
+        return jsonClone(resumeMeta.metadata);
+    }
+    return undefined;
+}
+function coerceOutputText(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (value === undefined || value === null) {
+        return '';
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function extractCapturedToolOutputs(responsesContext) {
+    if (!responsesContext || typeof responsesContext !== 'object') {
+        return [];
+    }
+    const snapshot = responsesContext.__captured_tool_results;
+    if (!Array.isArray(snapshot) || !snapshot.length) {
+        return [];
+    }
+    const entries = [];
+    snapshot.forEach((entry) => {
+        if (!entry || typeof entry !== 'object') {
+            return;
+        }
+        const record = entry;
+        const toolId = typeof record.tool_call_id === 'string' && record.tool_call_id.trim().length
+            ? record.tool_call_id.trim()
+            : typeof record.call_id === 'string' && record.call_id.trim().length
+                ? record.call_id.trim()
+                : undefined;
+        if (!toolId) {
+            return;
+        }
+        entries.push({
+            tool_call_id: toolId,
+            id: toolId,
+            output: typeof record.output === 'string' ? record.output : coerceOutputText(record.output),
+            name: typeof record.name === 'string' ? record.name : undefined
+        });
+    });
+    return entries;
+}
+function collectSubmitToolOutputs(chat, ctx, responsesContext) {
+    const outputs = [];
+    const seen = new Set();
+    const append = (idSeed, outputSeed, name) => {
+        const trimmed = typeof idSeed === 'string' && idSeed.trim().length ? idSeed.trim() : '';
+        const fallbackId = trimmed || `submit_tool_${outputs.length + 1}`;
+        if (seen.has(fallbackId)) {
+            return;
+        }
+        seen.add(fallbackId);
+        outputs.push({
+            tool_call_id: fallbackId,
+            id: fallbackId,
+            output: coerceOutputText(outputSeed),
+            name
+        });
+    };
+    if (Array.isArray(chat.toolOutputs) && chat.toolOutputs.length) {
+        chat.toolOutputs.forEach((entry) => {
+            append(entry.tool_call_id ?? entry.call_id, entry.content, entry.name);
+        });
+    }
+    if (!outputs.length) {
+        const captured = extractCapturedToolOutputs(responsesContext);
+        captured.forEach((entry) => append(entry.tool_call_id ?? entry.id, entry.output, entry.name));
+    }
+    if (!outputs.length) {
+        const resume = ctx.responsesResume && typeof ctx.responsesResume === 'object'
+            ? ctx.responsesResume
+            : undefined;
+        const detailed = Array.isArray(resume?.toolOutputsDetailed)
+            ? resume?.toolOutputsDetailed
+            : undefined;
+        if (detailed) {
+            detailed.forEach((entry, index) => {
+                if (!entry || typeof entry !== 'object') {
+                    return;
+                }
+                const callId = typeof entry.callId === 'string' && entry.callId.trim().length
+                    ? entry.callId.trim()
+                    : typeof entry.originalId === 'string' && entry.originalId.trim().length
+                        ? entry.originalId.trim()
+                        : `resume_tool_${index + 1}`;
+                append(callId, typeof entry.outputText === 'string' ? entry.outputText : entry.outputText ?? '');
+            });
+        }
+    }
+    return outputs;
+}
+function resolveSubmitStreamFlag(chat, ctx, responsesContext) {
+    if (chat.parameters && typeof chat.parameters.stream === 'boolean') {
+        return chat.parameters.stream;
+    }
+    if (responsesContext && typeof responsesContext.stream === 'boolean') {
+        return responsesContext.stream;
+    }
+    if (ctx.streamingHint === 'force') {
+        return true;
+    }
+    if (ctx.streamingHint === 'disable') {
+        return false;
+    }
+    return undefined;
+}
+function resolveSubmitModel(chat, responsesContext) {
+    const direct = chat.parameters && typeof chat.parameters.model === 'string'
+        ? chat.parameters.model.trim()
+        : undefined;
+    if (direct) {
+        return direct;
+    }
+    if (responsesContext && typeof responsesContext.parameters === 'object') {
+        const params = responsesContext.parameters;
+        const model = typeof params.model === 'string' ? params.model.trim() : undefined;
+        if (model) {
+            return model;
+        }
+    }
+    return undefined;
+}
+function buildSubmitToolOutputsPayload(chat, ctx, responsesContext) {
+    const responseId = resolveSubmitResponseId(ctx, responsesContext);
+    if (!responseId) {
+        throw new Error('Submit tool outputs requires response_id from Responses resume context');
+    }
+    const toolOutputs = collectSubmitToolOutputs(chat, ctx, responsesContext);
+    if (!toolOutputs.length) {
+        throw new Error('Submit tool outputs requires at least one tool output entry');
+    }
+    const resumeMeta = ctx.responsesResume && typeof ctx.responsesResume === 'object'
+        ? ctx.responsesResume
+        : undefined;
+    const payload = {
+        response_id: responseId,
+        tool_outputs: toolOutputs
+    };
+    const modelValue = resolveSubmitModel(chat, responsesContext);
+    if (modelValue) {
+        payload.model = modelValue;
+    }
+    const streamValue = resolveSubmitStreamFlag(chat, ctx, responsesContext);
+    if (typeof streamValue === 'boolean') {
+        payload.stream = streamValue;
+    }
+    const metadata = extractSubmitMetadata(responsesContext, resumeMeta);
+    if (metadata) {
+        payload.metadata = metadata;
+    }
+    return payload;
+}
 export class ResponsesSemanticMapper {
     async toChat(format, ctx) {
         const payload = format.payload || {};
@@ -248,15 +505,35 @@ export class ResponsesSemanticMapper {
         if (responsesContext.responseFormat) {
             metadata.responseFormat = jsonClone(responsesContext.responseFormat);
         }
+        metadata.responsesContext = jsonClone(responsesContext);
+        const resumeNode = ctx.responsesResume && isJsonObject(ctx.responsesResume)
+            ? ctx.responsesResume
+            : undefined;
+        const semantics = attachResponsesSemantics(undefined, responsesContext, resumeNode);
         return {
             messages,
             tools: normalizeTools(toolsNormalized, missingFields),
             toolOutputs,
             parameters,
+            semantics,
             metadata
         };
     }
     async fromChat(chat, ctx) {
+        const envelopeMetadata = chat.metadata && isJsonObject(chat.metadata) ? chat.metadata : undefined;
+        const responsesContext = selectResponsesContextSnapshot(chat, envelopeMetadata);
+        if (isSubmitToolOutputsEndpoint(ctx)) {
+            const submitPayload = buildSubmitToolOutputsPayload(chat, ctx, responsesContext);
+            return {
+                protocol: 'openai-responses',
+                direction: 'response',
+                payload: submitPayload,
+                meta: {
+                    context: ctx,
+                    submitToolOutputs: true
+                }
+            };
+        }
         const modelValue = chat.parameters?.model;
         if (typeof modelValue !== 'string' || !modelValue.trim()) {
             throw new Error('ChatEnvelope.parameters.model is required for openai-responses outbound conversion');
@@ -271,18 +548,7 @@ export class ResponsesSemanticMapper {
             .filter((message) => Boolean(message && typeof message === 'object' && message.role === 'system'))
             .map(message => serializeSystemContent(message))
             .filter((content) => typeof content === 'string' && content.length > 0);
-        const capturedContext = chat.metadata?.responsesContext;
-        const envelopeMetadata = chat.metadata && isJsonObject(chat.metadata) ? chat.metadata : undefined;
-        const responsesContext = isJsonObject(capturedContext)
-            ? {
-                ...capturedContext,
-                metadata: mergeMetadata(capturedContext.metadata, envelopeMetadata),
-                originalSystemMessages
-            }
-            : {
-                metadata: envelopeMetadata,
-                originalSystemMessages
-            };
+        responsesContext.originalSystemMessages = originalSystemMessages;
         const responsesResult = buildResponsesRequestFromChat(requestShape, responsesContext);
         const responses = responsesResult.request;
         if (chat.parameters && chat.parameters.stream !== undefined) {

package/dist/conversion/hub/standardized-bridge.js

@@ -5,6 +5,7 @@ export function chatEnvelopeToStandardized(chat, options) {
     const model = extractModel(parameters);
     const messages = chat.messages.map((message) => normalizeChatMessage(message));
     const tools = normalizeTools(chat.tools);
+    const semantics = cloneSemantics(chat.semantics);
     const metadataCaptured = {};
     const hubState = {};
     if (Array.isArray(chat.metadata?.missingFields) && chat.metadata?.missingFields.length) {
@@ -35,7 +36,8 @@ export function chatEnvelopeToStandardized(chat, options) {
             capturedContext: metadataCaptured,
             requestId: options.requestId,
             stream: parameters.stream === true
-        }
+        },
+        semantics
     };
     return standardized;
 }
@@ -93,7 +95,8 @@ export function standardizedToChatEnvelope(request, options) {
         messages,
         tools,
         parameters,
-        metadata
+        metadata,
+        semantics: cloneSemantics(request.semantics)
     };
 }
 function extractModel(parameters) {
@@ -103,6 +106,12 @@ function extractModel(parameters) {
     }
     throw new Error('ChatEnvelope parameters must include model string');
 }
+function cloneSemantics(value) {
+    if (!value) {
+        return value;
+    }
+    return jsonClone(value);
+}
 function normalizeChatMessage(message) {
     const normalized = {
         role: message.role,

package/dist/conversion/hub/types/chat-envelope.d.ts

@@ -56,11 +56,21 @@ export interface AdapterContext {
     responsesResume?: JsonObject;
     [key: string]: JsonValue;
 }
+export interface ChatSemantics extends JsonObject {
+    session?: JsonObject;
+    system?: JsonObject;
+    tools?: JsonObject;
+    responses?: JsonObject;
+    anthropic?: JsonObject;
+    gemini?: JsonObject;
+    providerExtras?: JsonObject;
+}
 export interface ChatEnvelope {
     messages: ChatMessage[];
     tools?: ChatToolDefinition[];
     toolOutputs?: ChatToolOutput[];
     parameters?: JsonObject;
+    semantics?: ChatSemantics;
     metadata: {
         context: AdapterContext;
         missingFields?: MissingField[];

package/dist/conversion/hub/types/standardized.d.ts

@@ -1,4 +1,4 @@
-import type { ChatMessageContentPart } from './chat-envelope.js';
+import type { ChatMessageContentPart, ChatSemantics } from './chat-envelope.js';
 import type { JsonObject } from './json.js';
 export type ToolChoice = 'none' | 'auto' | 'required' | {
     type: 'function';
@@ -74,6 +74,7 @@ export interface StandardizedRequest {
     tools?: StandardizedTool[];
     parameters: StandardizedParameters;
     metadata: StandardizedMetadata;
+    semantics?: ChatSemantics;
 }
 export interface ProcessedRequest extends StandardizedRequest {
     processed: {

package/dist/conversion/responses/responses-openai-bridge.d.ts

@@ -1,5 +1,6 @@
 import type { BridgeInputItem, BridgeToolDefinition } from '../shared/bridge-message-types.js';
 import type { ChatToolDefinition } from '../hub/types/chat-envelope.js';
+import type { JsonObject, JsonValue } from '../hub/types/json.js';
 import type { BridgeInputBuildResult } from '../shared/bridge-message-utils.js';
 import type { ToolCallIdStyle } from '../shared/responses-tool-utils.js';
 type Unknown = Record<string, unknown>;
@@ -11,8 +12,8 @@ export interface ResponsesRequestContext extends Unknown {
     store?: unknown;
     toolChoice?: unknown;
     parallelToolCalls?: boolean;
-    metadata?: Record<string, unknown> | undefined;
-    responseFormat?: unknown;
+    metadata?: JsonObject;
+    responseFormat?: JsonValue;
     stream?: boolean;
     isChatPayload?: boolean;
     isResponsesPayload?: boolean;

package/dist/conversion/responses/responses-openai-bridge.js

@@ -10,7 +10,6 @@ import { normalizeMessageReasoningTools } from '../shared/reasoning-tool-normali
 import { createBridgeActionState, runBridgeActionPipeline } from '../shared/bridge-actions.js';
 import { resolveBridgePolicy, resolvePolicyActions } from '../shared/bridge-policies.js';
 import { buildResponsesOutputFromChat } from '../shared/responses-output-builder.js';
-import { consumeResponsesPayloadSnapshot, consumeResponsesPassthrough } from '../shared/responses-reasoning-registry.js';
 function isObject(v) {
     return !!v && typeof v === 'object' && !Array.isArray(v);
 }
@@ -29,7 +28,7 @@ export function captureResponsesContext(payload, dto) {
         store: payload.store,
         toolChoice: payload.tool_choice,
         parallelToolCalls: typeof payload.parallel_tool_calls === 'boolean' ? payload.parallel_tool_calls : undefined,
-        metadata: (payload.metadata && typeof payload.metadata === 'object') ? { ...payload.metadata } : undefined,
+        metadata: (payload.metadata && typeof payload.metadata === 'object') ? payload.metadata : undefined,
         responseFormat: payload.response_format,
         stream: typeof payload.stream === 'boolean' ? payload.stream : undefined,
         isChatPayload: Array.isArray(payload.messages)
@@ -461,17 +460,6 @@ export function buildResponsesPayloadFromChat(payload, context) {
     const response = unwrapData(payload);
     if (!response || typeof response !== 'object')
         return payload;
-    const snapshotKey = resolveSnapshotLookupKey(response, context);
-    if (snapshotKey) {
-        const passthrough = consumeResponsesPassthrough(snapshotKey);
-        if (passthrough) {
-            return passthrough;
-        }
-        const snapshot = consumeResponsesPayloadSnapshot(snapshotKey);
-        if (snapshot) {
-            return snapshot;
-        }
-    }
     if (response.object === 'response' && Array.isArray(response.output)) {
         return response;
     }

package/dist/conversion/shared/text-markup-normalizer.d.ts

@@ -0,0 +1,20 @@
+export type ToolCallLite = {
+    id?: string;
+    name: string;
+    args: string;
+};
+export declare function extractApplyPatchCallsFromText(text: string): ToolCallLite[] | null;
+export declare function extractExecuteBlocksFromText(text: string): ToolCallLite[] | null;
+export declare function extractXMLToolCallsFromText(text: string): ToolCallLite[] | null;
+/**
+ * 提取简单 XML 形式的工具调用块，例如：
+ *
+ *   <list_directory>
+ *     <path>/path/to/dir</path>
+ *     <recursive>false</recursive>
+ *   </list_directory>
+ *
+ * 仅针对已知工具名（目前为 list_directory），避免误伤普通 XML 文本。
+ */
+export declare function extractSimpleXmlToolsFromText(text: string): ToolCallLite[] | null;
+export declare function normalizeAssistantTextToToolCalls(message: Record<string, any>): Record<string, any>;

package/dist/conversion/shared/text-markup-normalizer.js

@@ -11,7 +11,9 @@ const KNOWN_TOOLS = new Set([
     'view_image',
     'list_mcp_resources',
     'read_mcp_resource',
-    'list_mcp_resource_templates'
+    'list_mcp_resource_templates',
+    // 文件/目录类工具（CLI 侧已有约定；此处只做文本→tool_calls 收割）
+    'list_directory'
 ]);
 const ALLOWED_KEYS = {
     shell: new Set(['command', 'justification', 'timeout_ms', 'with_escalated_permissions', 'workdir']),
@@ -20,7 +22,8 @@ const ALLOWED_KEYS = {
     view_image: new Set(['path']),
     list_mcp_resources: new Set(['server', 'cursor', 'filter', 'root']),
     read_mcp_resource: new Set(['server', 'uri', 'cursor']),
-    list_mcp_resource_templates: new Set(['server', 'cursor'])
+    list_mcp_resource_templates: new Set(['server', 'cursor']),
+    list_directory: new Set(['path', 'recursive'])
 };
 function normalizeKey(raw) {
     try {
@@ -259,9 +262,16 @@ export function extractXMLToolCallsFromText(text) {
                         name = cand;
                 }
                 catch { /* ignore */ }
+                // 如果前一行抽不到合法函数名，但 arg_key 明显是 toon/command，
+                // 视为 CLI 通路下的 exec_command 工具，避免把半截 <tool_call> 当成纯文本丢弃。
+                const rawKey = (pm[1] || '').trim();
+                const normalizedKey = normalizeKey(rawKey).toLowerCase();
+                if (!name && (normalizedKey === 'toon' || normalizedKey === 'command')) {
+                    name = 'exec_command';
+                }
                 if (!name)
                     continue;
-                const k = normalizeKey((pm[1] || '').trim());
+                const k = normalizeKey(rawKey);
                 let vRaw = (pm[2] || '').trim();
                 const argsObj = {};
                 if (k) {
@@ -305,6 +315,74 @@ export function extractXMLToolCallsFromText(text) {
         return null;
     }
 }
+/**
+ * 提取简单 XML 形式的工具调用块，例如：
+ *
+ *   <list_directory>
+ *     <path>/path/to/dir</path>
+ *     <recursive>false</recursive>
+ *   </list_directory>
+ *
+ * 仅针对已知工具名（目前为 list_directory），避免误伤普通 XML 文本。
+ */
+export function extractSimpleXmlToolsFromText(text) {
+    try {
+        if (typeof text !== 'string' || !text)
+            return null;
+        const out = [];
+        const blockRe = /<\s*([A-Za-z0-9_.-]+)\s*>([\s\S]*?)<\/\s*\1\s*>/gi;
+        let bm;
+        while ((bm = blockRe.exec(text)) !== null) {
+            const rawName = (bm[1] || '').trim();
+            const lname = rawName.toLowerCase();
+            if (!lname || lname === 'tool_call')
+                continue;
+            // 目前仅支持 list_directory，后续按需扩展
+            if (lname !== 'list_directory')
+                continue;
+            const inner = bm[2] || '';
+            const args = {};
+            const argRe = /<\s*([A-Za-z0-9_]+)\s*>([\s\S]*?)<\/\s*\1\s*>/gi;
+            let am;
+            while ((am = argRe.exec(inner)) !== null) {
+                const key = normalizeKey((am[1] || '').trim());
+                if (!key)
+                    continue;
+                let rawVal = (am[2] || '').trim();
+                let v = rawVal;
+                if ((rawVal.startsWith('[') && rawVal.endsWith(']')) || (rawVal.startsWith('{') && rawVal.endsWith('}'))) {
+                    try {
+                        v = JSON.parse(rawVal);
+                    }
+                    catch {
+                        v = rawVal;
+                    }
+                }
+                else if (rawVal === 'true' || rawVal === 'false') {
+                    v = rawVal === 'true';
+                }
+                args[key] = v;
+            }
+            const filtered = filterArgsForTool(lname, args);
+            let argsStr = '{}';
+            try {
+                argsStr = JSON.stringify(filtered);
+            }
+            catch {
+                argsStr = '{}';
+            }
+            out.push({
+                id: `call_${Math.random().toString(36).slice(2, 10)}`,
+                name: lname,
+                args: argsStr
+            });
+        }
+        return out.length ? out : null;
+    }
+    catch {
+        return null;
+    }
+}
 export function normalizeAssistantTextToToolCalls(message) {
     if (!enabled())
         return message;
@@ -317,10 +395,11 @@ export function normalizeAssistantTextToToolCalls(message) {
         const text = typeof content === 'string' ? content : null;
         if (!text)
             return message;
-        // Order: xml-like tool_call → apply_patch → execute blocks
+        // Order: xml-like <tool_call> → apply_patch → execute blocks → 简单 XML 工具（list_directory 等）
         const calls = (extractXMLToolCallsFromText(text) ||
             extractApplyPatchCallsFromText(text) ||
-            extractExecuteBlocksFromText(text));
+            extractExecuteBlocksFromText(text) ||
+            extractSimpleXmlToolsFromText(text));
         if (calls && calls.length) {
             const toolCalls = calls.map((c) => ({ id: c.id, type: 'function', function: { name: c.name, arguments: c.args } }));
             const copy = { ...message };

package/dist/conversion/shared/tool-filter-pipeline.d.ts

@@ -1,4 +1,4 @@
-import { ToolFilterHints } from '../../filters/index.js';
+import type { ToolFilterHints } from '../../filters/index.js';
 interface RequestFilterOptions {
     entryEndpoint?: string;
     requestId?: string;