@jsonstudio/llms 0.6.1892 → 0.6.2172

package/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage3_context_capture/index.js

@@ -129,6 +129,12 @@ function buildToolOutputSnapshot(payload, providerProtocol) {
     const snapshot = {
         providerProtocol: providerProtocol ?? 'unknown'
     };
+    try {
+        normalizeShellLikeToolCallsBeforeGovernance(payload);
+    }
+    catch {
+        // shape repair is best-effort; never block main flow
+    }
     try {
         injectApplyPatchDiagnostics(payload);
     }
@@ -141,6 +147,161 @@ function buildToolOutputSnapshot(payload, providerProtocol) {
     }
     return snapshot;
 }
+const SHELL_LIKE_TOOL_NAMES = new Set(['exec_command', 'shell_command', 'shell', 'bash', 'terminal']);
+function readTrimmedString(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length ? trimmed : undefined;
+}
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function readStringArrayCommand(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const tokens = value
+        .map((item) => (item == null ? '' : String(item).trim()))
+        .filter((item) => item.length > 0);
+    return tokens.length ? tokens.join(' ') : undefined;
+}
+function parseJsonRecord(value) {
+    if (isRecord(value)) {
+        return value;
+    }
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        return isRecord(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function readCommandFromArgs(args) {
+    const input = isRecord(args.input) ? args.input : undefined;
+    const direct = readTrimmedString(args.cmd) ??
+        readTrimmedString(args.command) ??
+        readTrimmedString(args.script) ??
+        readTrimmedString(args.toon) ??
+        readStringArrayCommand(args.cmd) ??
+        readStringArrayCommand(args.command);
+    if (direct) {
+        return direct;
+    }
+    if (!input) {
+        return undefined;
+    }
+    return (readTrimmedString(input.cmd) ??
+        readTrimmedString(input.command) ??
+        readTrimmedString(input.script) ??
+        readStringArrayCommand(input.cmd) ??
+        readStringArrayCommand(input.command));
+}
+function readWorkdirFromArgs(args) {
+    const input = isRecord(args.input) ? args.input : undefined;
+    return (readTrimmedString(args.workdir) ??
+        readTrimmedString(args.cwd) ??
+        readTrimmedString(args.workDir) ??
+        readTrimmedString(input?.workdir) ??
+        readTrimmedString(input?.cwd));
+}
+function collectRequestedToolNames(payload) {
+    const names = new Set();
+    const root = payload;
+    const tools = Array.isArray(root.tools) ? root.tools : [];
+    for (const tool of tools) {
+        if (!isRecord(tool))
+            continue;
+        const fn = isRecord(tool.function) ? tool.function : undefined;
+        const name = readTrimmedString(fn?.name) ?? readTrimmedString(tool.name);
+        if (name) {
+            names.add(name);
+        }
+    }
+    return names;
+}
+function resolveShellLikeToolName(rawName, requestedToolNames) {
+    if (requestedToolNames.size === 0) {
+        return rawName;
+    }
+    if (requestedToolNames.has(rawName)) {
+        return rawName;
+    }
+    if (requestedToolNames.has('exec_command')) {
+        return 'exec_command';
+    }
+    if (requestedToolNames.has('shell_command')) {
+        return 'shell_command';
+    }
+    return rawName;
+}
+function normalizeShellLikeToolCallsBeforeGovernance(payload) {
+    const root = payload;
+    const messages = Array.isArray(root.messages) ? root.messages : [];
+    if (!messages.length) {
+        return;
+    }
+    const requestedToolNames = collectRequestedToolNames(payload);
+    for (const message of messages) {
+        if (!isRecord(message))
+            continue;
+        const role = readTrimmedString(message.role)?.toLowerCase();
+        if (role !== 'assistant')
+            continue;
+        const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+        if (!toolCalls.length)
+            continue;
+        for (const call of toolCalls) {
+            if (!isRecord(call))
+                continue;
+            const fn = isRecord(call.function) ? call.function : undefined;
+            if (!fn)
+                continue;
+            const rawName = readTrimmedString(fn.name);
+            if (!rawName)
+                continue;
+            if (!SHELL_LIKE_TOOL_NAMES.has(rawName.toLowerCase()))
+                continue;
+            const resolvedName = resolveShellLikeToolName(rawName, requestedToolNames);
+            if (resolvedName !== rawName) {
+                fn.name = resolvedName;
+            }
+            const parsedArgs = parseJsonRecord(fn.arguments);
+            const args = parsedArgs ?? {};
+            const cmd = readCommandFromArgs(args);
+            if (!cmd) {
+                continue;
+            }
+            const nextArgs = {
+                ...args,
+                cmd,
+                command: cmd
+            };
+            const workdir = readWorkdirFromArgs(args);
+            if (workdir) {
+                nextArgs.workdir = workdir;
+            }
+            if (Object.prototype.hasOwnProperty.call(nextArgs, 'toon')) {
+                delete nextArgs.toon;
+            }
+            try {
+                fn.arguments = JSON.stringify(nextArgs);
+            }
+            catch {
+                fn.arguments = JSON.stringify({ cmd, command: cmd, ...(workdir ? { workdir } : {}) });
+            }
+        }
+    }
+}
 function collectToolOutputs(payload) {
     const aggregated = [];
     const seen = new Set();
@@ -319,7 +480,7 @@ function normalizeToolOutputEntry(entry) {
         name
     };
 }
-function buildApplyPatchDiagnostics(output) {
+function buildToolParseDiagnostics(output) {
     if (!output || typeof output !== 'string') {
         return undefined;
     }
@@ -328,10 +489,28 @@ function buildApplyPatchDiagnostics(output) {
         return undefined;
     }
     if (output.includes('missing field `input`')) {
-        return '\n\n[RouteCodex precheck] apply_patch 参数解析失败：缺少字段 "input"。当前 RouteCodex 期望 { input, patch } 形态，并且两个字段都应包含完整统一 diff 文本。';
+        return {
+            kind: 'apply_patch',
+            text: '\n\n[RouteCodex precheck] apply_patch 参数解析失败：缺少字段 "input"。当前 RouteCodex 期望 { input, patch } 形态，并且两个字段都应包含完整统一 diff 文本。'
+        };
     }
     if (output.includes('invalid type: map, expected a string')) {
-        return '\n\n[RouteCodex precheck] apply_patch 参数类型错误：检测到 JSON 对象（map），但客户端期望字符串。请先对参数做 JSON.stringify 再写入 arguments，或直接提供 { patch: "<统一 diff>" } 形式。';
+        return {
+            kind: 'apply_patch',
+            text: '\n\n[RouteCodex precheck] apply_patch 参数类型错误：检测到 JSON 对象（map），但客户端期望字符串。请先对参数做 JSON.stringify 再写入 arguments，或直接提供 { patch: "<统一 diff>" } 形式。'
+        };
+    }
+    if (output.includes('missing field `command`')) {
+        return {
+            kind: 'shell_like',
+            text: '\n\n[RouteCodex precheck] shell/exec 参数解析失败：缺少字段 "command"。请改为 {"tool_calls":[{"name":"shell_command","input":{"command":"<cmd>"}}]}；若调用 exec_command，建议同时提供 {"cmd":"<cmd>","command":"<cmd>"}。'
+        };
+    }
+    if (output.includes('missing field `cmd`')) {
+        return {
+            kind: 'shell_like',
+            text: '\n\n[RouteCodex precheck] shell/exec 参数解析失败：缺少字段 "cmd"。exec_command 推荐形状为 {"cmd":"<cmd>","command":"<cmd>","workdir":"<path>"}。'
+        };
     }
     return undefined;
 }
@@ -347,17 +526,20 @@ function appendDiagnosticsToRecord(record) {
     if (!text || text.includes('[RouteCodex precheck]')) {
         return;
     }
-    const diag = buildApplyPatchDiagnostics(text);
+    const diag = buildToolParseDiagnostics(text);
     if (!diag) {
         return;
     }
-    // Some providers / compatibility layers omit `name` on tool outputs.
-    // When the output text matches apply_patch argument-parse failures, still inject the diagnostics
-    // to keep user-visible behavior stable across modes.
-    if (name && name !== 'apply_patch') {
+    const normalizedName = name?.toLowerCase();
+    if (diag.kind === 'apply_patch' && normalizedName && normalizedName !== 'apply_patch') {
+        return;
+    }
+    if (diag.kind === 'shell_like' &&
+        normalizedName &&
+        !SHELL_LIKE_TOOL_NAMES.has(normalizedName)) {
         return;
     }
-    const merged = `${text}${diag}`;
+    const merged = `${text}${diag.text}`;
     if (typeof record.output === 'string') {
         record.output = merged;
     }

package/dist/conversion/hub/pipeline/stages/resp_inbound/resp_inbound_stage1_sse_decode/index.js

@@ -37,6 +37,66 @@ function resolveProviderType(protocol) {
         return 'gemini';
     return undefined;
 }
+function readFiniteNumber(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return Math.floor(value);
+    }
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (!trimmed.length) {
+            return undefined;
+        }
+        const parsed = Number(trimmed);
+        if (Number.isFinite(parsed)) {
+            return Math.floor(parsed);
+        }
+    }
+    return undefined;
+}
+function readObject(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return undefined;
+    }
+    return value;
+}
+function extractContextLengthDiagnostics(adapterContext) {
+    const ctx = readObject(adapterContext);
+    if (!ctx) {
+        return {};
+    }
+    const runtimeNode = readObject(ctx.__rt);
+    const targetNode = readObject(ctx.target);
+    const estimatedPromptTokens = readFiniteNumber(ctx.estimatedInputTokens) ??
+        readFiniteNumber(ctx.requestTokens) ??
+        readFiniteNumber(ctx.reqTokens) ??
+        readFiniteNumber(runtimeNode?.estimatedInputTokens) ??
+        readFiniteNumber(runtimeNode?.requestTokens) ??
+        readFiniteNumber(runtimeNode?.reqTokens);
+    const maxContextTokens = readFiniteNumber(targetNode?.maxContextTokens) ??
+        readFiniteNumber(ctx.maxContextTokens) ??
+        readFiniteNumber(runtimeNode?.maxContextTokens);
+    return {
+        ...(typeof estimatedPromptTokens === 'number' ? { estimatedPromptTokens } : {}),
+        ...(typeof maxContextTokens === 'number' ? { maxContextTokens } : {})
+    };
+}
+function isContextLengthExceededSignal(args) {
+    const code = typeof args.code === 'string' ? args.code.trim().toLowerCase() : '';
+    if (code.includes('context_length_exceeded')) {
+        return true;
+    }
+    const message = args.message.toLowerCase();
+    if (message.includes('context_length_exceeded') || message.includes('达到对话长度上限') || message.includes('对话长度上限')) {
+        return true;
+    }
+    const finishReason = typeof args.context?.errorData === 'object' &&
+        args.context.errorData &&
+        !Array.isArray(args.context.errorData) &&
+        typeof args.context.errorData.finish_reason === 'string'
+        ? String(args.context.errorData.finish_reason).trim().toLowerCase()
+        : '';
+    return finishReason === 'context_length_exceeded';
+}
 export async function runRespInboundStage1SseDecode(options) {
     // Transport compatibility: some HTTP clients return JSON bodies as plain strings when the upstream
     // mislabels `Content-Type`. Best-effort parse JSON text early so downstream format adapters and
@@ -125,20 +185,36 @@ export async function runRespInboundStage1SseDecode(options) {
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
+        const errRecord = error;
+        const upstreamCode = typeof errRecord.code === 'string' ? errRecord.code : undefined;
+        const upstreamContext = readObject(errRecord.context);
+        const contextLengthExceeded = isContextLengthExceededSignal({
+            code: upstreamCode,
+            message,
+            context: upstreamContext
+        });
+        const diagnostics = extractContextLengthDiagnostics(options.adapterContext);
         recordStage(options.stageRecorder, 'chat_process.resp.stage1.sse_decode', {
             streamDetected: true,
             decoded: false,
             protocol: options.providerProtocol,
-            error: message
+            error: message,
+            ...(upstreamCode ? { upstreamCode } : {}),
+            ...(contextLengthExceeded ? { reason: 'context_length_exceeded' } : {}),
+            ...(Object.keys(diagnostics).length ? diagnostics : {})
         });
-        throw new ProviderProtocolError(`[chat_process.resp.stage1.sse_decode] Failed to decode SSE payload for protocol ${options.providerProtocol}: ${message}`, {
+        throw new ProviderProtocolError(`[chat_process.resp.stage1.sse_decode] Failed to decode SSE payload for protocol ${options.providerProtocol}: ${message}` +
+            (contextLengthExceeded ? ' (context too long; please compress conversation context and retry)' : ''), {
             code: 'SSE_DECODE_ERROR',
             protocol: options.providerProtocol,
             providerType: resolveProviderType(options.providerProtocol),
             details: {
                 phase: 'chat_process.resp.stage1.sse_decode',
                 requestId: options.adapterContext.requestId,
-                message
+                message,
+                ...(upstreamCode ? { upstreamCode } : {}),
+                ...(contextLengthExceeded ? { reason: 'context_length_exceeded' } : {}),
+                ...(Object.keys(diagnostics).length ? diagnostics : {})
             }
         });
     }
@@ -179,43 +255,70 @@ async function tryDecodeJsonBodyFromStream(stream) {
     if (first.done || first.value == null) {
         return null;
     }
+    const consumedChunks = [first.value];
     const firstChunk = first.value;
-    let prefix = (typeof firstChunk === 'string' ? firstChunk : firstChunk.toString('utf8')).trimStart();
+    let prefix = chunkToUtf8(firstChunk).trimStart();
     prefix = prefix.replace(/^\)\]\}',?\s*/u, '');
     prefix = prefix.replace(/^data:\s*/iu, '');
     const looksLikeJson = prefix.startsWith('{') || prefix.startsWith('[');
     if (!looksLikeJson) {
-        // Rewind by re-wrapping the iterator so downstream SSE decoder still sees the first chunk.
-        // eslint-disable-next-line no-param-reassign
-        stream[Symbol.asyncIterator] = () => replayIterator(firstChunk, iterator);
+        rewindStreamWithConsumedChunks(stream, consumedChunks, iterator);
         return null;
     }
-    let body = typeof firstChunk === 'string' ? firstChunk : firstChunk.toString('utf8');
+    let body = chunkToUtf8(firstChunk);
     while (true) {
         const next = await iterator.next();
         if (next.done)
             break;
-        body += typeof next.value === 'string' ? next.value : Buffer.from(next.value).toString('utf8');
+        consumedChunks.push(next.value);
+        body += chunkToUtf8(next.value);
         // Guard: avoid unbounded buffering if the upstream is actually SSE but starts with whitespace.
         if (body.length > 1024 * 1024) {
+            rewindStreamWithConsumedChunks(stream, consumedChunks, iterator);
             return null;
         }
     }
     try {
         const parsed = JSON.parse(body);
-        return (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) ? parsed : null;
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            return parsed;
+        }
+        rewindStreamWithConsumedChunks(stream, consumedChunks, iterator);
+        return null;
     }
     catch {
+        rewindStreamWithConsumedChunks(stream, consumedChunks, iterator);
         return null;
     }
 }
-function replayIterator(firstChunk, iterator) {
-    let yieldedFirst = false;
+function chunkToUtf8(chunk) {
+    if (typeof chunk === 'string') {
+        return chunk;
+    }
+    if (Buffer.isBuffer(chunk)) {
+        return chunk.toString('utf8');
+    }
+    if (chunk instanceof Uint8Array) {
+        return Buffer.from(chunk).toString('utf8');
+    }
+    if (chunk instanceof ArrayBuffer) {
+        return Buffer.from(new Uint8Array(chunk)).toString('utf8');
+    }
+    return String(chunk ?? '');
+}
+function rewindStreamWithConsumedChunks(stream, consumedChunks, iterator) {
+    // Rewind by re-wrapping the iterator so downstream SSE decoder still sees everything consumed here.
+    // eslint-disable-next-line no-param-reassign
+    stream[Symbol.asyncIterator] = () => replayIterator(consumedChunks, iterator);
+}
+function replayIterator(consumedChunks, iterator) {
+    let replayIndex = 0;
     return {
         async next() {
-            if (!yieldedFirst) {
-                yieldedFirst = true;
-                return { done: false, value: firstChunk };
+            if (replayIndex < consumedChunks.length) {
+                const value = consumedChunks[replayIndex];
+                replayIndex += 1;
+                return { done: false, value };
             }
             return iterator.next();
         },

package/dist/conversion/hub/pipeline/stages/resp_process/resp_process_stage1_tool_governance/index.js

@@ -1,9 +1,18 @@
 import { runChatResponseToolFilters } from '../../../../../shared/tool-filter-pipeline.js';
 import { normalizeApplyPatchToolCallsOnResponse } from '../../../../../shared/tool-governor.js';
 import { buildChatResponseFromResponses } from '../../../../../shared/responses-response-utils.js';
+import { normalizeAssistantTextToToolCalls } from '../../../../../shared/text-markup-normalizer.js';
+import { stripOrphanFunctionCallsTag } from '../../../../../compat/actions/strip-orphan-function-calls-tag.js';
 import { ToolGovernanceEngine } from '../../../../tool-governance/index.js';
 import { recordStage } from '../../../stages/utils.js';
 const toolGovernanceEngine = new ToolGovernanceEngine();
+const TOOL_CALL_JSON_MARKER = /["']tool_calls["']\s*:/i;
+const SHELL_TOOL_NAME_ALIASES = {
+    shell_command: 'exec_command',
+    shell: 'exec_command',
+    bash: 'exec_command',
+    terminal: 'exec_command'
+};
 function isCanonicalChatCompletion(payload) {
     if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
         return false;
@@ -36,13 +45,67 @@ function coerceToCanonicalChatCompletion(payload) {
     }
     return payload;
 }
+function maybeHarvestEmptyToolCallsFromJsonContent(payload) {
+    if (!payload || typeof payload !== 'object') {
+        return payload;
+    }
+    const choices = Array.isArray(payload.choices) ? payload.choices : [];
+    if (!choices.length) {
+        return payload;
+    }
+    for (const choice of choices) {
+        if (!choice || typeof choice !== 'object' || Array.isArray(choice)) {
+            continue;
+        }
+        const message = choice.message;
+        if (!message || typeof message !== 'object' || Array.isArray(message)) {
+            continue;
+        }
+        const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : undefined;
+        if (!toolCalls || toolCalls.length !== 0) {
+            continue;
+        }
+        const content = typeof message.content === 'string' ? String(message.content).trim() : '';
+        if (!content || !TOOL_CALL_JSON_MARKER.test(content)) {
+            continue;
+        }
+        const normalized = normalizeAssistantTextToToolCalls(message, {
+            jsonToolRepair: {
+                toolNameAliases: SHELL_TOOL_NAME_ALIASES,
+                argumentAliases: {
+                    exec_command: {
+                        cmd: ['cmd', 'command', 'input.command', 'script'],
+                        command: ['cmd', 'command', 'input.command', 'script'],
+                        workdir: ['workdir', 'cwd', 'input.cwd']
+                    }
+                }
+            }
+        });
+        const repairedCalls = Array.isArray(normalized.tool_calls) ? normalized.tool_calls : [];
+        if (!repairedCalls.length) {
+            continue;
+        }
+        choice.message = normalized;
+        const finish = typeof choice.finish_reason === 'string' ? String(choice.finish_reason).trim().toLowerCase() : '';
+        if (!finish || finish === 'stop') {
+            choice.finish_reason = 'tool_calls';
+        }
+    }
+    return payload;
+}
+function sanitizeResponseShapeBeforeGovernance(payload) {
+    return stripOrphanFunctionCallsTag(payload);
+}
 export async function runRespProcessStage1ToolGovernance(options) {
     const canonicalInput = coerceToCanonicalChatCompletion(options.payload);
+    const shapeSanitizedInput = sanitizeResponseShapeBeforeGovernance(canonicalInput);
+    maybeHarvestEmptyToolCallsFromJsonContent(shapeSanitizedInput);
     recordStage(options.stageRecorder, 'chat_process.resp.stage6.canonicalize_chat_completion', {
         converted: canonicalInput !== options.payload,
-        canonicalPayload: canonicalInput
+        shapeSanitized: shapeSanitizedInput !== canonicalInput,
+        canonicalPayload: shapeSanitizedInput
     });
-    const filtered = await runChatResponseToolFilters(canonicalInput, {
+    const filtered = await runChatResponseToolFilters(shapeSanitizedInput, {
         entryEndpoint: options.entryEndpoint,
         requestId: options.requestId,
         profile: 'openai-chat'

package/dist/conversion/hub/pipeline/stages/resp_process/resp_process_stage3_servertool_orchestration/index.d.ts

@@ -0,0 +1,34 @@
+import type { AdapterContext } from '../../../../types/chat-envelope.js';
+import type { JsonObject } from '../../../../types/json.js';
+import type { StageRecorder } from '../../../../format-adapters/index.js';
+import type { ChatCompletionLike } from '../../../../response/response-mappers.js';
+import type { ProviderInvoker } from '../../../../../../servertool/types.js';
+type ProviderProtocol = 'openai-chat' | 'openai-responses' | 'anthropic-messages' | 'gemini-chat';
+type ReenterPipeline = (options: {
+    entryEndpoint: string;
+    requestId: string;
+    body: JsonObject;
+    metadata?: JsonObject;
+}) => Promise<{
+    body?: JsonObject;
+    __sse_responses?: NodeJS.ReadableStream;
+    format?: string;
+}>;
+export interface RespProcessStage3ServerToolOrchestrationOptions {
+    payload: ChatCompletionLike;
+    adapterContext: AdapterContext;
+    requestId: string;
+    entryEndpoint: string;
+    providerProtocol: ProviderProtocol;
+    stageRecorder?: StageRecorder;
+    providerInvoker?: ProviderInvoker;
+    reenterPipeline?: ReenterPipeline;
+}
+export interface RespProcessStage3ServerToolOrchestrationResult {
+    payload: ChatCompletionLike;
+    executed: boolean;
+    flowId?: string;
+    skipReason?: 'no_servertool_support' | 'missing_reenter_pipeline';
+}
+export declare function runRespProcessStage3ServerToolOrchestration(options: RespProcessStage3ServerToolOrchestrationOptions): Promise<RespProcessStage3ServerToolOrchestrationResult>;
+export {};

package/dist/conversion/hub/pipeline/stages/resp_process/resp_process_stage3_servertool_orchestration/index.js

@@ -0,0 +1,75 @@
+import { runServerToolOrchestration } from '../../../../../../servertool/engine.js';
+import { recordStage } from '../../../stages/utils.js';
+function detectProviderResponseShape(payload) {
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload))
+        return 'unknown';
+    const p = payload;
+    if (Array.isArray(p.choices))
+        return 'openai-chat';
+    if ((typeof p.object === 'string' && p.object === 'response') || Array.isArray(p.output))
+        return 'openai-responses';
+    if (Array.isArray(p.content) || typeof p.stop_reason === 'string')
+        return 'anthropic-messages';
+    if (Array.isArray(p.candidates))
+        return 'gemini-chat';
+    return 'unknown';
+}
+export async function runRespProcessStage3ServerToolOrchestration(options) {
+    const hasServerToolSupport = Boolean(options.providerInvoker) || Boolean(options.reenterPipeline);
+    if (!hasServerToolSupport) {
+        recordStage(options.stageRecorder, 'chat_process.resp.stage5.servertool_orchestration', {
+            executed: false,
+            skipReason: 'no_servertool_support',
+            inputShape: detectProviderResponseShape(options.payload)
+        });
+        return {
+            payload: options.payload,
+            executed: false,
+            skipReason: 'no_servertool_support'
+        };
+    }
+    if (!options.reenterPipeline) {
+        recordStage(options.stageRecorder, 'chat_process.resp.stage5.servertool_orchestration', {
+            executed: false,
+            skipReason: 'missing_reenter_pipeline',
+            inputShape: detectProviderResponseShape(options.payload)
+        });
+        return {
+            payload: options.payload,
+            executed: false,
+            skipReason: 'missing_reenter_pipeline'
+        };
+    }
+    const orchestration = await runServerToolOrchestration({
+        chat: options.payload,
+        adapterContext: options.adapterContext,
+        requestId: options.requestId,
+        entryEndpoint: options.entryEndpoint,
+        providerProtocol: options.providerProtocol,
+        stageRecorder: options.stageRecorder,
+        providerInvoker: options.providerInvoker,
+        reenterPipeline: options.reenterPipeline
+    });
+    if (orchestration.executed) {
+        const outputPayload = orchestration.chat;
+        recordStage(options.stageRecorder, 'chat_process.resp.stage5.servertool_orchestration', {
+            executed: true,
+            flowId: orchestration.flowId,
+            inputShape: detectProviderResponseShape(options.payload),
+            outputShape: detectProviderResponseShape(outputPayload)
+        });
+        return {
+            payload: outputPayload,
+            executed: true,
+            flowId: orchestration.flowId
+        };
+    }
+    recordStage(options.stageRecorder, 'chat_process.resp.stage5.servertool_orchestration', {
+        executed: false,
+        inputShape: detectProviderResponseShape(options.payload)
+    });
+    return {
+        payload: options.payload,
+        executed: false
+    };
+}