@jsonstudio/llms 0.6.568 → 0.6.586

package/dist/conversion/hub/pipeline/hub-pipeline.d.ts

@@ -61,7 +61,6 @@ export declare class HubPipeline {
     private buildAdapterContext;
     private maybeCreateStageRecorder;
     private asJsonObject;
-    private pickRawRequestBody;
     private normalizeRequest;
     private convertProcessNodeResult;
     private materializePayload;

package/dist/conversion/hub/pipeline/hub-pipeline.js

@@ -22,6 +22,7 @@ import { runReqOutboundStage1SemanticMap } from './stages/req_outbound/req_outbo
 import { runReqOutboundStage2FormatBuild } from './stages/req_outbound/req_outbound_stage2_format_build/index.js';
 import { runReqOutboundStage3Compat } from './stages/req_outbound/req_outbound_stage3_compat/index.js';
 import { extractSessionIdentifiersFromMetadata } from './session-identifiers.js';
+import { computeRequestTokens } from '../../../router/virtual-router/token-estimator.js';
 export class HubPipeline {
     routerEngine;
     config;
@@ -119,6 +120,18 @@ export class HubPipeline {
             }
         }
         const workingRequest = processedRequest ?? standardizedRequest;
+        // 使用与 VirtualRouter 一致的 tiktoken 计数逻辑，对标准化请求进行一次
+        // 上下文 token 估算，供后续 usage 归一化与统计使用。
+        try {
+            const estimatedTokens = computeRequestTokens(workingRequest, '');
+            if (typeof estimatedTokens === 'number' && Number.isFinite(estimatedTokens) && estimatedTokens > 0) {
+                normalized.metadata = normalized.metadata || {};
+                normalized.metadata.estimatedInputTokens = estimatedTokens;
+            }
+        }
+        catch {
+            // 估算失败不应影响主流程
+        }
         const normalizedMeta = normalized.metadata;
         const responsesResume = normalizedMeta && typeof normalizedMeta.responsesResume === 'object'
             ? normalizedMeta.responsesResume
@@ -182,66 +195,42 @@ export class HubPipeline {
         const outboundEndpoint = resolveEndpointForProviderProtocol(outboundAdapterContext.providerProtocol);
         const outboundRecorder = this.maybeCreateStageRecorder(outboundAdapterContext, outboundEndpoint);
         const outboundStart = Date.now();
-        const isResponsesSubmit = normalized.entryEndpoint === '/v1/responses.submit_tool_outputs' &&
-            outboundProtocol === 'openai-responses';
         let providerPayload;
-        if (isResponsesSubmit) {
-            providerPayload =
-                this.pickRawRequestBody(normalized.metadata) ?? normalized.payload;
-            const outboundEnd = Date.now();
-            nodeResults.push({
-                id: 'req_outbound',
-                success: true,
-                metadata: {
-                    node: 'req_outbound',
-                    executionTime: outboundEnd - outboundStart,
-                    startTime: outboundStart,
-                    endTime: outboundEnd,
-                    dataProcessed: {
-                        messages: 0,
-                        tools: 0
-                    },
-                    bypass: 'responses-submit-passthrough'
-                }
-            });
-        }
-        else {
-            const outboundStage1 = await runReqOutboundStage1SemanticMap({
-                request: workingRequest,
-                adapterContext: outboundAdapterContext,
-                semanticMapper: outboundSemanticMapper,
-                contextSnapshot: outboundContextSnapshot,
-                contextMetadataKey: outboundContextMetadataKey,
-                stageRecorder: outboundRecorder
-            });
-            let formattedPayload = await runReqOutboundStage2FormatBuild({
-                formatEnvelope: outboundStage1.formatEnvelope,
-                adapterContext: outboundAdapterContext,
-                formatAdapter: outboundFormatAdapter,
-                stageRecorder: outboundRecorder
-            });
-            formattedPayload = await runReqOutboundStage3Compat({
-                payload: formattedPayload,
-                adapterContext: outboundAdapterContext,
-                stageRecorder: outboundRecorder
-            });
-            providerPayload = formattedPayload;
-            const outboundEnd = Date.now();
-            nodeResults.push({
-                id: 'req_outbound',
-                success: true,
-                metadata: {
-                    node: 'req_outbound',
-                    executionTime: outboundEnd - outboundStart,
-                    startTime: outboundStart,
-                    endTime: outboundEnd,
-                    dataProcessed: {
-                        messages: workingRequest.messages.length,
-                        tools: workingRequest.tools?.length ?? 0
-                    }
+        const outboundStage1 = await runReqOutboundStage1SemanticMap({
+            request: workingRequest,
+            adapterContext: outboundAdapterContext,
+            semanticMapper: outboundSemanticMapper,
+            contextSnapshot: outboundContextSnapshot,
+            contextMetadataKey: outboundContextMetadataKey,
+            stageRecorder: outboundRecorder
+        });
+        let formattedPayload = await runReqOutboundStage2FormatBuild({
+            formatEnvelope: outboundStage1.formatEnvelope,
+            adapterContext: outboundAdapterContext,
+            formatAdapter: outboundFormatAdapter,
+            stageRecorder: outboundRecorder
+        });
+        formattedPayload = await runReqOutboundStage3Compat({
+            payload: formattedPayload,
+            adapterContext: outboundAdapterContext,
+            stageRecorder: outboundRecorder
+        });
+        providerPayload = formattedPayload;
+        const outboundEnd = Date.now();
+        nodeResults.push({
+            id: 'req_outbound',
+            success: true,
+            metadata: {
+                node: 'req_outbound',
+                executionTime: outboundEnd - outboundStart,
+                startTime: outboundStart,
+                endTime: outboundEnd,
+                dataProcessed: {
+                    messages: workingRequest.messages.length,
+                    tools: workingRequest.tools?.length ?? 0
                 }
-            });
-        }
+            }
+        });
         // 为响应侧 servertool/web_search 提供一次性 Chat 请求快照，便于在 Hub 内部实现
         // 第三跳（将工具结果注入消息历史后重新调用主模型）。
         //
@@ -432,16 +421,6 @@ export class HubPipeline {
         }
         return value;
     }
-    pickRawRequestBody(metadata) {
-        if (!metadata || typeof metadata !== 'object') {
-            return undefined;
-        }
-        const raw = metadata.__raw_request_body;
-        if (!raw || typeof raw !== 'object') {
-            return undefined;
-        }
-        return raw;
-    }
     async normalizeRequest(request) {
         if (!request || typeof request !== 'object') {
             throw new Error('HubPipeline requires request payload');

package/dist/conversion/hub/pipeline/stages/resp_outbound/resp_outbound_stage1_client_remap/index.js

@@ -15,7 +15,6 @@ export function runRespOutboundStage1ClientRemap(options) {
         clientPayload = buildResponsesPayloadFromChat(options.payload, {
             requestId: options.requestId
         });
-        mergeOriginalResponsesPayload(clientPayload, options.adapterContext);
     }
     recordStage(options.stageRecorder, 'resp_outbound_stage1_client_remap', clientPayload);
     return clientPayload;
@@ -42,36 +41,3 @@ function resolveAliasMapFromContext(adapterContext) {
     }
     return Object.keys(map).length ? map : undefined;
 }
-function mergeOriginalResponsesPayload(payload, adapterContext) {
-    if (!adapterContext) {
-        return;
-    }
-    const raw = adapterContext.__raw_responses_payload;
-    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
-        return;
-    }
-    try {
-        if (payload.required_action == null && raw.required_action != null) {
-            payload.required_action = JSON.parse(JSON.stringify(raw.required_action));
-        }
-    }
-    catch {
-        /* ignore clone errors */
-    }
-    const rawStatus = typeof raw.status === 'string' ? raw.status : undefined;
-    if (rawStatus === 'requires_action') {
-        payload.status = 'requires_action';
-    }
-    // 如果桥接后的 payload 没有 usage，而原始 Responses 载荷带有 usage，则回填原始 usage，
-    // 确保 token usage 不在工具/桥接路径中丢失。
-    const payloadUsage = payload.usage;
-    const rawUsage = raw.usage;
-    if ((payloadUsage == null || typeof payloadUsage !== 'object') && rawUsage && typeof rawUsage === 'object') {
-        try {
-            payload.usage = JSON.parse(JSON.stringify(rawUsage));
-        }
-        catch {
-            payload.usage = rawUsage;
-        }
-    }
-}

package/dist/conversion/hub/process/chat-process.js

@@ -1,6 +1,5 @@
 import { runChatRequestToolFilters } from '../../shared/tool-filter-pipeline.js';
 import { ToolGovernanceEngine } from '../tool-governance/index.js';
-import { detectLastAssistantToolCategory } from '../../../router/virtual-router/tool-signals.js';
 import { ensureApplyPatchSchema } from '../../shared/tool-mapping.js';
 const toolGovernanceEngine = new ToolGovernanceEngine();
 export async function runHubChatProcess(options) {
@@ -409,19 +408,10 @@ function maybeInjectWebSearchTool(request, metadata) {
         : 'selective';
     const intent = detectWebSearchIntent(request);
     if (injectPolicy === 'selective') {
+        // 仅当当前这一轮用户输入明确表达“联网搜索”意图时才注入 web_search。
+        // 不再依赖上一轮工具分类（read/search/websearch），避免形成隐式续写语义。
         if (!intent.hasIntent) {
-            // 当最近一条用户消息没有明显的“联网搜索”关键词时，
-            // 如果上一轮 assistant 的工具调用已经属于搜索类（如 web_search），
-            // 则仍然视为 web_search 续写场景，强制注入 web_search 工具，
-            // 以便在后续路由中按 servertool 逻辑跳过不适配的 Provider（例如 serverToolsDisabled 的 crs）。
-            const assistantMessages = Array.isArray(request.messages)
-                ? request.messages.filter((msg) => msg && msg.role === 'assistant')
-                : [];
-            const lastTool = detectLastAssistantToolCategory(assistantMessages);
-            const hasSearchToolContext = lastTool?.category === 'search';
-            if (!hasSearchToolContext) {
-                return request;
-            }
+            return request;
         }
     }
     const existingTools = Array.isArray(request.tools) ? request.tools : [];

package/dist/conversion/hub/response/provider-response.js

@@ -130,14 +130,6 @@ export async function convertProviderResponse(options) {
         catch {
             // ignore conversation capture errors
         }
-        if (formatEnvelope.payload && typeof formatEnvelope.payload === 'object') {
-            try {
-                options.context.__raw_responses_payload = JSON.parse(JSON.stringify(formatEnvelope.payload));
-            }
-            catch {
-                /* best-effort clone */
-            }
-        }
     }
     formatEnvelope.payload = runRespInboundStageCompatResponse({
         payload: formatEnvelope.payload,

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

@@ -337,7 +337,13 @@ function buildGeminiRequestFromChat(chat, metadata) {
             else {
                 argsStruct = fn.arguments ?? {};
             }
-            const functionCall = { name, args: cloneAsJsonValue(argsStruct) };
+            let argsJson = cloneAsJsonValue(argsStruct);
+            // Gemini / Antigravity 期望 functionCall.args 为对象（Struct），
+            // 若顶层为数组或原始类型，则包装到 value 字段下，避免产生非法的 list 形状。
+            if (!argsJson || typeof argsJson !== 'object' || Array.isArray(argsJson)) {
+                argsJson = { value: argsJson };
+            }
+            const functionCall = { name, args: argsJson };
             const part = { functionCall };
             if (typeof tc.id === 'string') {
                 part.functionCall.id = tc.id;

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

@@ -19,6 +19,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;
@@ -197,6 +198,198 @@ 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 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 || {};
@@ -257,6 +450,28 @@ export class ResponsesSemanticMapper {
         };
     }
     async fromChat(chat, ctx) {
+        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)
+            }
+            : {
+                metadata: 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 +486,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/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>;