@jsonstudio/rcc 0.90.876 → 0.90.1270

package/dist/server/runtime/http-server/executor/provider-response-converter.js

@@ -1,40 +1,17 @@
 import { asRecord } from '../provider-utils.js';
 import { convertProviderResponse as bridgeConvertProviderResponse, createSnapshotRecorder as bridgeCreateSnapshotRecorder } from '../../../../modules/llmswitch/bridge.js';
-import { applyClientConnectionStateToContext } from '../../../utils/client-connection-state.js';
-import { resolveStopMessageClientInjectReadiness, runClientInjectionFlowBeforeReenter } from './client-injection-flow.js';
-import { extractClientModelId, normalizeProviderResponse } from './provider-response-utils.js';
+import { normalizeProviderResponse } from './provider-response-utils.js';
 import { isVerboseErrorLoggingEnabled } from './env-config.js';
+import { logExecutorRuntimeNonBlockingWarning } from './servertool-runtime-log.js';
 import { extractSseWrapperError } from './sse-error-handler.js';
 import { isRateLimitLikeError } from './request-retry-helpers.js';
 import { extractUsageFromResult } from './usage-aggregator.js';
-import { deriveFinishReason, STREAM_LOG_FINISH_REASON_KEY } from '../../../utils/finish-reason.js';
+import { deriveFinishReason } from '../../../utils/finish-reason.js';
 import { logPipelineStage } from '../../../utils/stage-logger.js';
-const FOLLOWUP_SESSION_HEADER_KEYS = new Set([
-    'sessionid',
-    'conversationid',
-    'xsessionid',
-    'xconversationid',
-    'anthropicsessionid',
-    'anthropicconversationid',
-    'xroutecodexsessionid',
-    'xroutecodexconversationid',
-    'xroutecodexclientdaemonid',
-    'xroutecodexclientdid',
-    'xrccclientdaemonid',
-    'xroutecodexsessiondaemonid',
-    'xroutecodexdaemonid',
-    'xrccsessiondaemonid',
-    'xroutecodexclienttmuxsessionid',
-    'xrccclienttmuxsessionid',
-    'xroutecodextmuxsessionid',
-    'xrcctmuxsessionid',
-    'xtmuxsessionid',
-    'xroutecodexclientworkdir',
-    'xrccclientworkdir',
-    'xroutecodexworkdir',
-    'xrccworkdir',
-    'xworkdir'
-]);
+import { buildServerToolSseWrapperBody } from './servertool-response-normalizer.js';
+import { buildServerToolAdapterContext } from './servertool-adapter-context.js';
+import { executeServerToolClientInjectDispatch, executeServerToolReenterPipeline } from './servertool-followup-dispatch.js';
+import { compactFollowupLogReason, extractServerToolFollowupErrorLogDetails, finalizeServerToolBridgeConvertError } from './servertool-followup-error.js';
 const CONTEXT_LENGTH_MESSAGE_HINTS = [
     'context_length_exceeded',
     'context_window_exceeded',
@@ -71,6 +48,555 @@ const RETRYABLE_NETWORK_CODE_HINTS = [
     'timeout'
 ];
 const truthy = new Set(['1', 'true', 'yes', 'on']);
+const FATAL_CONVERSION_ERROR_CODES = new Set([
+    'CLIENT_TOOL_ARGS_INVALID',
+]);
+const STOPLESS_DIRECTIVE_PATTERN = /<\*\*stopless:[^*]+\*\*>/i;
+function isImagePathLike(value) {
+    return /\.(png|jpg|jpeg|gif|webp|bmp|svg|tiff?|ico|heic|jxl)$/i.test(value);
+}
+function parseToolArgsRecord(argsString) {
+    const trimmed = String(argsString || '').trim();
+    if (!trimmed || !(trimmed.startsWith('{') || trimmed.startsWith('['))) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        return asFlatRecord(parsed) ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function buildMissingFields(fields) {
+    const normalized = fields
+        .map((field) => (typeof field === 'string' ? field.trim() : ''))
+        .filter((field) => Boolean(field));
+    return normalized.length ? normalized : undefined;
+}
+function buildToolValidationFailure(args) {
+    return {
+        ok: false,
+        reason: args.reason,
+        message: args.message,
+        ...(args.missingFields?.length ? { missingFields: args.missingFields } : {})
+    };
+}
+function readReasoningStopBoolean(value) {
+    if (value === true) {
+        return true;
+    }
+    if (value === false) {
+        return false;
+    }
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'true') {
+        return true;
+    }
+    if (normalized === 'false') {
+        return false;
+    }
+    return undefined;
+}
+function validateCanonicalClientToolCall(name, argsString, declaredToolNames) {
+    const parsed = parseToolArgsRecord(argsString);
+    const normalizedName = name.trim().toLowerCase();
+    switch (normalizedName) {
+        case 'exec_command': {
+            const cmd = typeof parsed?.cmd === 'string' ? parsed.cmd.trim() : '';
+            if (!cmd) {
+                return buildToolValidationFailure({
+                    reason: 'missing_cmd',
+                    message: 'exec_command requires input.cmd as a non-empty string.',
+                    missingFields: ['cmd']
+                });
+            }
+            return { ok: true, normalizedArgs: JSON.stringify({ ...parsed, cmd }) };
+        }
+        case 'view_image': {
+            const pathValue = typeof parsed?.path === 'string' ? parsed.path.trim() : '';
+            if (!pathValue || !isImagePathLike(pathValue)) {
+                return buildToolValidationFailure({
+                    reason: 'invalid_image_path',
+                    message: 'view_image requires input.path pointing to an image file.'
+                });
+            }
+            return { ok: true, normalizedArgs: JSON.stringify({ path: pathValue }) };
+        }
+        case 'apply_patch': {
+            const patch = typeof parsed?.patch === 'string' && parsed.patch.trim()
+                ? parsed.patch
+                : typeof parsed?.input === 'string' && parsed.input.trim()
+                    ? parsed.input
+                    : '';
+            if (!patch) {
+                return buildToolValidationFailure({
+                    reason: 'missing_patch',
+                    message: 'apply_patch requires patch content in input.patch or input.input.',
+                    missingFields: ['patch']
+                });
+            }
+            return { ok: true, normalizedArgs: JSON.stringify({ patch, input: patch }) };
+        }
+        case 'update_plan': {
+            if (!Array.isArray(parsed?.plan)) {
+                return buildToolValidationFailure({
+                    reason: 'missing_plan',
+                    message: 'update_plan requires input.plan as an array.',
+                    missingFields: ['plan']
+                });
+            }
+            return { ok: true, normalizedArgs: JSON.stringify({ explanation: parsed?.explanation, plan: parsed.plan }) };
+        }
+        case 'shell_command':
+        case 'bash': {
+            const command = typeof parsed?.command === 'string' ? parsed.command.trim() : '';
+            if (!command) {
+                return buildToolValidationFailure({
+                    reason: 'missing_command',
+                    message: `${normalizedName} requires input.command as a non-empty string.`,
+                    missingFields: ['command']
+                });
+            }
+            return { ok: true, normalizedArgs: JSON.stringify(parsed) };
+        }
+        case 'shell': {
+            const command = parsed?.command;
+            if (!(Array.isArray(command) && command.every((entry) => typeof entry === 'string' && entry.trim().length > 0))) {
+                return buildToolValidationFailure({
+                    reason: 'invalid_command',
+                    message: 'shell requires input.command as a non-empty string array.'
+                });
+            }
+            return { ok: true, normalizedArgs: JSON.stringify(parsed) };
+        }
+        case 'read_mcp_resource': {
+            const server = typeof parsed?.server === 'string' ? parsed.server.trim() : '';
+            const uri = typeof parsed?.uri === 'string' ? parsed.uri.trim() : '';
+            if (!server || !uri) {
+                return buildToolValidationFailure({
+                    reason: 'missing_server_or_uri',
+                    message: 'read_mcp_resource requires both input.server and input.uri.',
+                    missingFields: buildMissingFields([
+                        !server ? 'server' : undefined,
+                        !uri ? 'uri' : undefined
+                    ])
+                });
+            }
+            return { ok: true, normalizedArgs: JSON.stringify({ server, uri }) };
+        }
+        case 'reasoning.stop': {
+            if (!parsed) {
+                return buildToolValidationFailure({
+                    reason: 'invalid_reasoning_stop_arguments',
+                    message: 'reasoning.stop requires a JSON object arguments payload.'
+                });
+            }
+            const taskGoal = typeof parsed.task_goal === 'string'
+                ? parsed.task_goal.trim()
+                : typeof parsed.taskGoal === 'string'
+                    ? parsed.taskGoal.trim()
+                    : typeof parsed.goal === 'string'
+                        ? parsed.goal.trim()
+                        : '';
+            if (!taskGoal) {
+                return buildToolValidationFailure({
+                    reason: 'invalid_reasoning_stop_arguments',
+                    message: 'reasoning.stop requires task_goal.',
+                    missingFields: ['task_goal']
+                });
+            }
+            const completed = readReasoningStopBoolean(parsed.is_completed ?? parsed.isCompleted ?? parsed.completed);
+            if (typeof completed !== 'boolean') {
+                return buildToolValidationFailure({
+                    reason: 'invalid_reasoning_stop_arguments',
+                    message: 'reasoning.stop requires is_completed(boolean).',
+                    missingFields: ['is_completed']
+                });
+            }
+            return { ok: true, normalizedArgs: JSON.stringify(parsed) };
+        }
+        case 'list_mcp_resources':
+        case 'list_mcp_resource_templates':
+            return { ok: true, normalizedArgs: JSON.stringify(parsed ?? {}) };
+        default:
+            if (declaredToolNames?.has(normalizedName)) {
+                if (!parsed) {
+                    return buildToolValidationFailure({
+                        reason: 'invalid_declared_tool_arguments',
+                        message: `Tool "${name.trim()}" requires JSON object arguments.`
+                    });
+                }
+                return { ok: true, normalizedArgs: JSON.stringify(parsed) };
+            }
+            const declaredList = declaredToolNames && declaredToolNames.size > 0
+                ? Array.from(declaredToolNames).sort().join(', ')
+                : '';
+            return buildToolValidationFailure({
+                reason: 'unknown_tool',
+                message: declaredList
+                    ? `Tool "${name.trim()}" is not declared for this request. Declared tools: ${declaredList}.`
+                    : `Tool "${name.trim()}" is not declared for this request.`
+            });
+    }
+}
+function readSessionLikeToken(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed || undefined;
+}
+function asFlatRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function tryParseJsonLikeString(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    if (!(trimmed.startsWith('{') || trimmed.startsWith('['))
+        && !trimmed.includes('{"')
+        && !trimmed.includes("{'")) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        const balanced = extractFirstBalancedJsonObject(trimmed);
+        if (!balanced) {
+            return undefined;
+        }
+        try {
+            return JSON.parse(balanced);
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
+function extractContentTextForStoplessScan(content) {
+    if (typeof content === 'string') {
+        return content;
+    }
+    if (!Array.isArray(content)) {
+        return '';
+    }
+    const parts = [];
+    for (const item of content) {
+        if (typeof item === 'string') {
+            parts.push(item);
+            continue;
+        }
+        if (!item || typeof item !== 'object' || Array.isArray(item)) {
+            continue;
+        }
+        const text = typeof item.text === 'string'
+            ? String(item.text)
+            : '';
+        if (text) {
+            parts.push(text);
+        }
+    }
+    return parts.join('\n');
+}
+function extractLatestUserTextForStoplessScan(source) {
+    const record = asFlatRecord(source);
+    if (!record) {
+        return '';
+    }
+    const rows = Array.isArray(record.messages)
+        ? record.messages
+        : Array.isArray(record.input)
+            ? record.input
+            : [];
+    for (let i = rows.length - 1; i >= 0; i -= 1) {
+        const row = asFlatRecord(rows[i]);
+        if (!row) {
+            continue;
+        }
+        const role = typeof row.role === 'string' ? row.role.trim().toLowerCase() : '';
+        if (role !== 'user') {
+            continue;
+        }
+        const text = extractContentTextForStoplessScan(row.content).trim();
+        if (text) {
+            return text;
+        }
+    }
+    return '';
+}
+function hasStoplessDirectiveInRequestPayload(source) {
+    return STOPLESS_DIRECTIVE_PATTERN.test(extractLatestUserTextForStoplessScan(source));
+}
+function collectDeclaredToolNames(baseContext) {
+    const capturedRequest = asFlatRecord(baseContext.capturedChatRequest);
+    const tools = Array.isArray(capturedRequest?.tools) ? capturedRequest.tools : [];
+    const names = new Set();
+    for (const tool of tools) {
+        if (!tool || typeof tool !== 'object' || Array.isArray(tool)) {
+            continue;
+        }
+        const row = tool;
+        const fn = row.function && typeof row.function === 'object' && !Array.isArray(row.function)
+            ? row.function
+            : row;
+        const name = typeof fn.name === 'string' ? fn.name.trim().toLowerCase() : '';
+        if (name) {
+            names.add(name);
+        }
+    }
+    return names;
+}
+function findNestedRawString(payload, depth = 3) {
+    if (depth < 0 || payload === null || payload === undefined) {
+        return '';
+    }
+    if (typeof payload === 'string') {
+        return payload;
+    }
+    if (typeof payload !== 'object' || Array.isArray(payload)) {
+        return '';
+    }
+    const record = payload;
+    const directRaw = typeof record.raw === 'string' ? record.raw : '';
+    if (directRaw) {
+        return directRaw;
+    }
+    for (const key of ['body', 'data', 'payload', 'response', 'error']) {
+        const nested = findNestedRawString(record[key], depth - 1);
+        if (nested) {
+            return nested;
+        }
+    }
+    return '';
+}
+function findNestedErrorMarker(payload, depth = 3) {
+    if (depth < 0 || payload === null || payload === undefined) {
+        return '';
+    }
+    if (typeof payload === 'string') {
+        return payload;
+    }
+    if (typeof payload !== 'object' || Array.isArray(payload)) {
+        return '';
+    }
+    const record = payload;
+    const directError = typeof record.error === 'string' ? record.error.trim() : '';
+    if (directError) {
+        return directError;
+    }
+    for (const key of ['body', 'data', 'payload', 'response']) {
+        const nested = findNestedErrorMarker(record[key], depth - 1);
+        if (nested) {
+            return nested;
+        }
+    }
+    return '';
+}
+function extractFirstBalancedJsonObject(raw) {
+    const start = raw.indexOf('{');
+    if (start < 0) {
+        return undefined;
+    }
+    let depth = 0;
+    let inString = false;
+    let escaping = false;
+    for (let i = start; i < raw.length; i += 1) {
+        const ch = raw[i];
+        if (inString) {
+            if (escaping) {
+                escaping = false;
+                continue;
+            }
+            if (ch === '\\') {
+                escaping = true;
+                continue;
+            }
+            if (ch === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+            continue;
+        }
+        if (ch === '{') {
+            depth += 1;
+            continue;
+        }
+        if (ch === '}') {
+            depth -= 1;
+            if (depth === 0) {
+                return raw.slice(start, i + 1);
+            }
+        }
+    }
+    return undefined;
+}
+function normalizeRecoveredToolCalls(value, declaredToolNames) {
+    const rows = Array.isArray(value) ? value : [];
+    const normalized = [];
+    for (const row of rows) {
+        const item = asFlatRecord(row);
+        const functionRecord = asFlatRecord(item?.function);
+        const nameRaw = (typeof item?.name === 'string' ? item.name : '') ||
+            (typeof functionRecord?.name === 'string' ? functionRecord.name : '');
+        const name = nameRaw.trim();
+        if (!name) {
+            continue;
+        }
+        if (declaredToolNames.size > 0 && !declaredToolNames.has(name.toLowerCase())) {
+            continue;
+        }
+        const inputRecord = asFlatRecord(item?.input)
+            ?? asFlatRecord(item?.arguments)
+            ?? asFlatRecord(functionRecord?.arguments)
+            ?? {};
+        const validation = validateCanonicalClientToolCall(name, JSON.stringify(inputRecord ?? {}), declaredToolNames);
+        if (!validation.ok) {
+            return {
+                toolCalls: normalized,
+                invalidCall: {
+                    name,
+                    reason: validation.reason || 'invalid_tool_arguments',
+                    message: validation.message,
+                    ...(validation.missingFields?.length ? { missingFields: validation.missingFields } : {})
+                }
+            };
+        }
+        let normalizedInput = inputRecord;
+        if (typeof validation.normalizedArgs === 'string') {
+            try {
+                const parsed = JSON.parse(validation.normalizedArgs);
+                if (asFlatRecord(parsed)) {
+                    normalizedInput = parsed;
+                }
+            }
+            catch {
+                // keep validated original
+            }
+        }
+        normalized.push({ name, input: normalizedInput });
+    }
+    return { toolCalls: normalized };
+}
+function stringifyToolCallArgumentsForValidation(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    try {
+        return JSON.stringify(value ?? {});
+    }
+    catch {
+        return '{}';
+    }
+}
+function collectConvertedProviderToolCalls(payload) {
+    const result = [];
+    const record = asFlatRecord(payload);
+    if (!record) {
+        return result;
+    }
+    const choices = Array.isArray(record.choices) ? record.choices : [];
+    for (let i = 0; i < choices.length; i += 1) {
+        const choice = asFlatRecord(choices[i]);
+        const message = asFlatRecord(choice?.message);
+        const toolCalls = Array.isArray(message?.tool_calls) ? message.tool_calls : [];
+        for (let j = 0; j < toolCalls.length; j += 1) {
+            const toolCall = asFlatRecord(toolCalls[j]);
+            const fn = asFlatRecord(toolCall?.function);
+            const name = (typeof fn?.name === 'string' ? fn.name : '')
+                || (typeof toolCall?.name === 'string' ? toolCall.name : '');
+            if (!name.trim()) {
+                continue;
+            }
+            result.push({
+                name: name.trim(),
+                argumentsText: stringifyToolCallArgumentsForValidation(fn?.arguments ?? toolCall?.arguments ?? toolCall?.input),
+                path: `choices[${i}].message.tool_calls[${j}]`
+            });
+        }
+    }
+    const requiredAction = asFlatRecord(record.required_action);
+    const submitToolOutputs = asFlatRecord(requiredAction?.submit_tool_outputs);
+    const submitToolCalls = Array.isArray(submitToolOutputs?.tool_calls) ? submitToolOutputs.tool_calls : [];
+    for (let i = 0; i < submitToolCalls.length; i += 1) {
+        const toolCall = asFlatRecord(submitToolCalls[i]);
+        const fn = asFlatRecord(toolCall?.function);
+        const name = (typeof fn?.name === 'string' ? fn.name : '')
+            || (typeof toolCall?.name === 'string' ? toolCall.name : '');
+        if (!name.trim()) {
+            continue;
+        }
+        result.push({
+            name: name.trim(),
+            argumentsText: stringifyToolCallArgumentsForValidation(fn?.arguments ?? toolCall?.arguments ?? toolCall?.input),
+            path: `required_action.submit_tool_outputs.tool_calls[${i}]`
+        });
+    }
+    return result;
+}
+function validateConvertedProviderToolCallsOrThrow(payload, declaredToolNames) {
+    const toolCalls = collectConvertedProviderToolCalls(payload);
+    for (const toolCall of toolCalls) {
+        const validation = validateCanonicalClientToolCall(toolCall.name, toolCall.argumentsText, declaredToolNames);
+        if (validation.ok) {
+            continue;
+        }
+        const err = new Error(validation.message
+            ? `Converted provider tool call has invalid client arguments at ${toolCall.path}: ${toolCall.name}. ${validation.message}`
+            : `Converted provider tool call has invalid client arguments at ${toolCall.path}: ${toolCall.name} (${validation.reason || 'invalid_tool_arguments'})`);
+        err.code = 'CLIENT_TOOL_ARGS_INVALID';
+        err.status = 502;
+        err.statusCode = 502;
+        err.retryable = false;
+        err.upstreamCode = 'CLIENT_TOOL_ARGS_INVALID';
+        err.toolName = toolCall.name;
+        err.validationReason = validation.reason || 'invalid_tool_arguments';
+        err.validationMessage = validation.message;
+        if (validation.missingFields?.length) {
+            err.missingFields = validation.missingFields;
+        }
+        err.details = {
+            ...(err.details ?? {}),
+            toolName: toolCall.name,
+            validationReason: validation.reason || 'invalid_tool_arguments',
+            ...(validation.message ? { validationMessage: validation.message } : {}),
+            ...(validation.missingFields?.length ? { missingFields: validation.missingFields } : {})
+        };
+        throw err;
+    }
+}
+function isGenericBridgeResponseContractError(args) {
+    const code = typeof args.error.code === 'string' ? args.error.code.trim() : '';
+    const name = typeof args.error.name === 'string' ? args.error.name.trim() : '';
+    const normalizedMessage = args.message.trim().toLowerCase();
+    if (name !== 'ProviderProtocolError') {
+        return false;
+    }
+    if (code !== 'MALFORMED_RESPONSE') {
+        return false;
+    }
+    return (normalizedMessage.includes('[hub_response] non-canonical response payload')
+        || normalizedMessage.includes('[hub_response] failed to canonicalize response payload'));
+}
+function logProviderResponseConverterNonBlockingError(stage, error, details) {
+    logExecutorRuntimeNonBlockingWarning({
+        namespace: 'provider-response-converter',
+        stage,
+        error,
+        details,
+        throttleKey: stage
+    });
+}
 function shouldEnableHubStageRecorder() {
     const raw = String(process.env.ROUTECODEX_ENABLE_HUB_STAGE_RECORDER
         ?? process.env.RCC_ENABLE_HUB_STAGE_RECORDER
@@ -146,63 +672,6 @@ function remapBridgeSseErrorToHttp(error, message) {
         error.code = 'HTTP_502';
     }
 }
-function canonicalizeHeaderName(headerName) {
-    return headerName.toLowerCase().replace(/[^a-z0-9]/g, '');
-}
-function extractFollowupSessionHeaders(headers) {
-    if (!headers || typeof headers !== 'object' || Array.isArray(headers)) {
-        return undefined;
-    }
-    const source = headers;
-    const preserved = {};
-    for (const [headerName, headerValue] of Object.entries(source)) {
-        if (!FOLLOWUP_SESSION_HEADER_KEYS.has(canonicalizeHeaderName(headerName))) {
-            continue;
-        }
-        if (typeof headerValue !== 'string') {
-            continue;
-        }
-        const normalizedValue = headerValue.trim();
-        if (!normalizedValue) {
-            continue;
-        }
-        preserved[headerName] = normalizedValue;
-    }
-    return Object.keys(preserved).length ? preserved : undefined;
-}
-function extractPreservedSessionToken(headers, field) {
-    if (!headers) {
-        return undefined;
-    }
-    for (const [headerName, headerValue] of Object.entries(headers)) {
-        const normalizedName = canonicalizeHeaderName(headerName);
-        if (field === 'session' && normalizedName.endsWith('sessionid')) {
-            return headerValue;
-        }
-        if (field === 'conversation' && normalizedName.endsWith('conversationid')) {
-            return headerValue;
-        }
-    }
-    return undefined;
-}
-function extractPreservedDaemonOrInjectToken(headers, field) {
-    if (!headers) {
-        return undefined;
-    }
-    for (const [headerName, headerValue] of Object.entries(headers)) {
-        const normalizedName = canonicalizeHeaderName(headerName);
-        if (field === 'daemon' && (normalizedName.endsWith('sessiondaemonid') || normalizedName.endsWith('daemonid'))) {
-            return headerValue;
-        }
-        if (field === 'tmux' && normalizedName.endsWith('tmuxsessionid')) {
-            return headerValue;
-        }
-        if (field === 'workdir' && normalizedName.endsWith('workdir')) {
-            return headerValue;
-        }
-    }
-    return undefined;
-}
 function syncHubStageTopBackToPipelineMetadata(options) {
     const pipelineMetadata = asRecord(options.pipelineMetadata);
     if (!pipelineMetadata) {
@@ -226,6 +695,7 @@ export async function convertProviderResponseIfNeeded(options, deps) {
             const codeSuffix = wrapperError.errorCode ? ` [${wrapperError.errorCode}]` : '';
             const error = new Error(`Upstream SSE error event${codeSuffix}: ${wrapperError.message}`);
             error.code = 'SSE_DECODE_ERROR';
+            error.requestExecutorProviderErrorStage = 'provider.sse_decode';
             if (wrapperError.errorCode) {
                 error.upstreamCode = wrapperError.errorCode;
             }
@@ -294,76 +764,23 @@ export async function convertProviderResponseIfNeeded(options, deps) {
             }
         };
     };
+    let adapterContext;
     try {
         const metadataBag = asRecord(options.pipelineMetadata);
-        const originalModelId = extractClientModelId(metadataBag, options.originalRequest);
-        const assignedModelId = typeof metadataBag?.assignedModelId === 'string'
-            ? String(metadataBag.assignedModelId)
-            : metadataBag &&
-                typeof metadataBag === 'object' &&
-                metadataBag.target &&
-                typeof metadataBag.target === 'object' &&
-                typeof metadataBag.target.modelId === 'string'
-                ? metadataBag.target.modelId
-                : typeof metadataBag?.modelId === 'string'
-                    ? String(metadataBag.modelId)
-                    : undefined;
-        const baseContext = {
-            ...(metadataBag ?? {})
-        };
-        if (baseContext.capturedChatRequest === undefined &&
-            options.originalRequest &&
-            typeof options.originalRequest === 'object' &&
-            !Array.isArray(options.originalRequest)) {
-            baseContext.capturedChatRequest = options.originalRequest;
-        }
-        if (typeof metadataBag?.routeName === 'string') {
-            baseContext.routeId = metadataBag.routeName;
-        }
-        baseContext.requestId = options.requestId;
-        baseContext.entryEndpoint = options.entryEndpoint || entry;
-        baseContext.providerProtocol = options.providerProtocol;
-        baseContext.originalModelId = originalModelId;
-        if (assignedModelId && assignedModelId.trim()) {
-            baseContext.modelId = assignedModelId.trim();
-        }
-        applyClientConnectionStateToContext(metadataBag, baseContext);
-        const adapterContext = baseContext;
-        const stopMessageInjectReadiness = resolveStopMessageClientInjectReadiness(baseContext);
-        {
-            const rt = asRecord(adapterContext.__rt) ?? {};
-            adapterContext.__rt = {
-                ...rt,
-                stopMessageClientInjectReady: stopMessageInjectReadiness.ready,
-                stopMessageClientInjectReason: stopMessageInjectReadiness.reason,
-                ...(stopMessageInjectReadiness.sessionScope
-                    ? { stopMessageClientInjectSessionScope: stopMessageInjectReadiness.sessionScope }
-                    : {}),
-                ...(stopMessageInjectReadiness.tmuxSessionId
-                    ? { stopMessageClientInjectTmuxSessionId: stopMessageInjectReadiness.tmuxSessionId }
-                    : {})
-            };
-        }
-        const hasTargetMetadata = metadataBag &&
-            typeof metadataBag === 'object' &&
-            metadataBag.target &&
-            typeof metadataBag.target === 'object';
-        const targetCompatProfile = hasTargetMetadata &&
-            typeof metadataBag.target.compatibilityProfile === 'string'
-            ? metadataBag.target.compatibilityProfile
-            : undefined;
-        const metadataCompatProfile = typeof metadataBag?.compatibilityProfile === 'string'
-            ? String(metadataBag.compatibilityProfile)
-            : undefined;
-        const compatProfile = hasTargetMetadata ? targetCompatProfile : metadataCompatProfile;
-        if (compatProfile && compatProfile.trim()) {
-            adapterContext.compatibilityProfile = compatProfile.trim();
-        }
+        const baseContext = buildServerToolAdapterContext({
+            metadata: metadataBag,
+            originalRequest: options.originalRequest,
+            requestSemantics: options.requestSemantics,
+            requestId: options.requestId,
+            entryEndpoint: options.entryEndpoint || entry,
+            providerProtocol: options.providerProtocol,
+            serverToolsEnabled: options.serverToolsEnabled !== false,
+            onReasoningStopSeedError: (error) => {
+                logProviderResponseConverterNonBlockingError('seedReasoningStopStateFromCapturedRequest', error);
+            }
+        });
+        adapterContext = baseContext;
         const serverToolsEnabled = options.serverToolsEnabled !== false;
-        adapterContext.serverToolsEnabled = serverToolsEnabled;
-        if (!serverToolsEnabled) {
-            adapterContext.serverToolsDisabled = true;
-        }
         let stageRecorder;
         if (shouldEnableHubStageRecorder()) {
             logPipelineStage('convert.snapshot_recorder.start', options.requestId, {
@@ -440,69 +857,31 @@ export async function convertProviderResponseIfNeeded(options, deps) {
         };
         const reenterPipeline = async (reenterOpts) => {
             const reenterStartMs = Date.now();
+            const nestedEntry = reenterOpts.entryEndpoint || options.entryEndpoint || entry;
             logPipelineStage('convert.reenter.start', reenterOpts.requestId, {
-                entryEndpoint: reenterOpts.entryEndpoint || options.entryEndpoint || entry
+                entryEndpoint: nestedEntry
             });
-            const nestedEntry = reenterOpts.entryEndpoint || options.entryEndpoint || entry;
-            const nestedExtra = asRecord(reenterOpts.metadata) ?? {};
-            const buildNestedMetadata = (extra, resolvedEntry) => {
-                const out = {
-                    ...(metadataBag ?? {}),
-                    ...extra,
-                    entryEndpoint: resolvedEntry,
-                    direction: 'request',
-                    stage: 'inbound'
-                };
-                try {
-                    const baseRt = asRecord(metadataBag?.__rt) ?? {};
-                    const extraRt = asRecord(extra?.__rt) ?? {};
-                    if (Object.keys(baseRt).length || Object.keys(extraRt).length) {
-                        out.__rt = { ...baseRt, ...extraRt };
-                    }
-                }
-                catch {
-                    // best-effort
-                }
-                if (asRecord(out.__rt)?.serverToolFollowup === true) {
-                    const preservedClientHeaders = extractFollowupSessionHeaders(out.clientHeaders);
-                    if (preservedClientHeaders) {
-                        out.clientHeaders = preservedClientHeaders;
-                        const sessionId = extractPreservedSessionToken(preservedClientHeaders, 'session');
-                        const conversationId = extractPreservedSessionToken(preservedClientHeaders, 'conversation');
-                        if (sessionId) {
-                            out.sessionId = sessionId;
-                        }
-                        if (conversationId) {
-                            out.conversationId = conversationId;
-                        }
-                    }
-                    else {
-                        delete out.clientHeaders;
-                    }
-                    delete out.clientRequestId;
-                }
-                return out;
-            };
-            const nestedMetadata = buildNestedMetadata(nestedExtra, nestedEntry);
-            const nestedInput = {
-                entryEndpoint: nestedEntry,
-                method: 'POST',
+            const nestedResult = await executeServerToolReenterPipeline({
+                entryEndpoint: reenterOpts.entryEndpoint,
+                fallbackEntryEndpoint: options.entryEndpoint || entry,
                 requestId: reenterOpts.requestId,
-                headers: {},
-                query: {},
                 body: reenterOpts.body,
-                metadata: nestedMetadata
-            };
-            const nestedResult = await deps.executeNested(nestedInput);
+                metadata: reenterOpts.metadata,
+                baseMetadata: metadataBag,
+                executeNested: deps.executeNested,
+                runClientInjectBeforeNested: false,
+                onMergeRuntimeMetaError: (error, details) => {
+                    logProviderResponseConverterNonBlockingError('reenter.buildNestedMetadata.mergeRuntimeMeta', error, {
+                        requestId: details.requestId,
+                        entryEndpoint: details.entryEndpoint
+                    });
+                }
+            });
             logPipelineStage('convert.reenter.completed', reenterOpts.requestId, {
                 entryEndpoint: nestedEntry,
-                status: nestedResult.status,
                 elapsedMs: Date.now() - reenterStartMs
             });
-            const nestedBody = nestedResult.body && typeof nestedResult.body === 'object'
-                ? nestedResult.body
-                : undefined;
-            return { body: nestedBody };
+            return nestedResult;
         };
         const clientInjectDispatch = async (injectOpts) => {
             const clientInjectAttemptStartedAt = Date.now();
@@ -511,47 +890,22 @@ export async function convertProviderResponseIfNeeded(options, deps) {
                 entryEndpoint: injectOpts.entryEndpoint || options.entryEndpoint || entry
             });
             const nestedEntry = injectOpts.entryEndpoint || options.entryEndpoint || entry;
-            const nestedExtra = asRecord(injectOpts.metadata) ?? {};
-            const nestedMetadata = (() => {
-                const out = {
-                    ...(metadataBag ?? {}),
-                    ...nestedExtra,
-                    entryEndpoint: nestedEntry,
-                    direction: 'request',
-                    stage: 'inbound'
-                };
-                try {
-                    const baseRt = asRecord(metadataBag?.__rt) ?? {};
-                    const extraRt = asRecord(nestedExtra?.__rt) ?? {};
-                    if (Object.keys(baseRt).length || Object.keys(extraRt).length) {
-                        out.__rt = { ...baseRt, ...extraRt };
-                    }
-                }
-                catch {
-                    // best-effort
+            const injectResult = await executeServerToolClientInjectDispatch({
+                entryEndpoint: injectOpts.entryEndpoint,
+                fallbackEntryEndpoint: options.entryEndpoint || entry,
+                requestId: injectOpts.requestId,
+                body: injectOpts.body,
+                metadata: injectOpts.metadata,
+                baseMetadata: metadataBag,
+                onMergeRuntimeMetaError: (error, details) => {
+                    logProviderResponseConverterNonBlockingError('clientInjectDispatch.mergeRuntimeMeta', error, {
+                        requestId: details.requestId,
+                        entryEndpoint: details.entryEndpoint
+                    });
                 }
-                if (asRecord(out.__rt)?.serverToolFollowup === true) {
-                    const preservedClientHeaders = extractFollowupSessionHeaders(out.clientHeaders);
-                    if (preservedClientHeaders) {
-                        out.clientHeaders = preservedClientHeaders;
-                    }
-                    else {
-                        delete out.clientHeaders;
-                    }
-                    delete out.clientRequestId;
-                }
-                return out;
-            })();
-            const requestBody = injectOpts.body && typeof injectOpts.body === 'object' && !Array.isArray(injectOpts.body)
-                ? injectOpts.body
-                : {};
-            const injectResult = await runClientInjectionFlowBeforeReenter({
-                nestedMetadata,
-                requestBody,
-                requestId: injectOpts.requestId
             });
             clientInjectWaitMs += Math.max(0, Date.now() - clientInjectAttemptStartedAt);
-            if (injectResult.clientInjectOnlyHandled) {
+            if (injectResult.ok) {
                 logPipelineStage('convert.client_inject.completed', injectOpts.requestId, {
                     entryEndpoint: nestedEntry,
                     handled: true,
@@ -562,10 +916,10 @@ export async function convertProviderResponseIfNeeded(options, deps) {
             logPipelineStage('convert.client_inject.completed', injectOpts.requestId, {
                 entryEndpoint: nestedEntry,
                 handled: false,
-                reason: 'client_inject_not_handled',
+                reason: injectResult.reason || 'client_inject_not_handled',
                 elapsedMs: Date.now() - clientInjectStartMs
             });
-            return { ok: false, reason: 'client_inject_not_handled' };
+            return { ok: false, reason: injectResult.reason || 'client_inject_not_handled' };
         };
         logPipelineStage('convert.bridge.start', options.requestId, {
             entryEndpoint: options.entryEndpoint || entry,
@@ -596,6 +950,7 @@ export async function convertProviderResponseIfNeeded(options, deps) {
             hasBody: converted.body !== undefined && converted.body !== null,
             elapsedMs: Date.now() - bridgeStartMs
         });
+        validateConvertedProviderToolCallsOrThrow(converted.body ?? body, collectDeclaredToolNames(baseContext));
         if (converted.__sse_responses) {
             const usage = converted.body
                 ? extractUsageFromResult({ body: converted.body })
@@ -605,16 +960,13 @@ export async function convertProviderResponseIfNeeded(options, deps) {
                 hasUsage: Boolean(usage),
                 finishReason
             });
-            const body = { __sse_responses: converted.__sse_responses };
-            if (usage) {
-                body.usage = usage;
-            }
-            if (finishReason) {
-                body[STREAM_LOG_FINISH_REASON_KEY] = finishReason;
-            }
             return attachTimingBreakdown({
                 ...options.response,
-                body
+                body: buildServerToolSseWrapperBody({
+                    sseResponses: converted.__sse_responses,
+                    convertedBody: converted.body,
+                    usage
+                })
             });
         }
         return attachTimingBreakdown({
@@ -635,40 +987,61 @@ export async function convertProviderResponseIfNeeded(options, deps) {
             : undefined;
         const detailReason = typeof detailRecord?.reason === 'string'
             ? String(detailRecord.reason)
-            : undefined;
+            : typeof detailRecord?.error === 'string'
+                ? String(detailRecord.error)
+                : undefined;
         const normalizedUpstreamCode = (upstreamCode || detailUpstreamCode || '').trim().toLowerCase();
+        const fatalConversionCode = (typeof errCode === 'string' && FATAL_CONVERSION_ERROR_CODES.has(errCode) ? errCode : undefined)
+            ?? (typeof upstreamCode === 'string' && FATAL_CONVERSION_ERROR_CODES.has(upstreamCode) ? upstreamCode : undefined)
+            ?? (typeof detailUpstreamCode === 'string' && FATAL_CONVERSION_ERROR_CODES.has(detailUpstreamCode) ? detailUpstreamCode : undefined);
+        if (fatalConversionCode) {
+            logPipelineStage('convert.bridge.error', options.requestId, {
+                code: errCode,
+                upstreamCode: upstreamCode || detailUpstreamCode,
+                reason: detailReason,
+                message
+            });
+            throw error;
+        }
         const isSseDecodeError = errCode === 'SSE_DECODE_ERROR' ||
             errCode === 'HTTP_502' ||
             errCode === 'HTTP_429' ||
             (errName === 'ProviderProtocolError' && message.toLowerCase().includes('sse'));
-        const isServerToolFollowupError = errCode === 'SERVERTOOL_FOLLOWUP_FAILED' ||
-            errCode === 'SERVERTOOL_EMPTY_FOLLOWUP' ||
-            (typeof errCode === 'string' && errCode.startsWith('SERVERTOOL_'));
         const normalizedMessage = message.toLowerCase();
         const isContextLengthExceeded = isContextLengthExceededError(normalizedMessage, upstreamCode || detailUpstreamCode, detailReason);
-        if (isSseDecodeError || isServerToolFollowupError || isContextLengthExceeded) {
+        if (isGenericBridgeResponseContractError({ error: errRecord, message })) {
+            errRecord.requestExecutorProviderErrorStage = 'host.response_contract';
+        }
+        const convertErrorPlan = finalizeServerToolBridgeConvertError({
+            error,
+            requestId: options.requestId,
+            defaultFollowupStatus: 502,
+            message,
+            isSseDecodeError,
+            isContextLengthExceeded,
+            code: errCode,
+            upstreamCode,
+            detailUpstreamCode,
+            detailReason
+        });
+        const isServerToolFollowupFailure = convertErrorPlan.handled
+            && errRecord.requestExecutorProviderErrorStage === 'provider.followup';
+        const followupLogDetails = isServerToolFollowupFailure
+            ? extractServerToolFollowupErrorLogDetails(error)
+            : undefined;
+        if (convertErrorPlan.handled) {
             if (isSseDecodeError || isContextLengthExceeded) {
                 remapBridgeSseErrorToHttp(errRecord, message);
             }
-            const normalizedCode = typeof errRecord.code === 'string' ? errRecord.code : errCode;
-            if (isServerToolFollowupError) {
-                console.error('[RequestExecutor] ServerTool followup failed', {
-                    requestId: options.requestId,
-                    code: normalizedCode,
-                    upstreamCode: upstreamCode || detailUpstreamCode,
-                    reason: detailReason,
-                    message
-                });
-                if (normalizedUpstreamCode === 'client_inject_failed') {
-                    // Followup rejection should not break the main assistant response.
-                    return options.response;
-                }
-            }
             logPipelineStage('convert.bridge.error', options.requestId, {
-                code: normalizedCode,
-                upstreamCode: upstreamCode || detailUpstreamCode,
-                reason: detailReason,
-                message
+                ...(isServerToolFollowupFailure
+                    ? (convertErrorPlan.stageDetails ?? {})
+                    : (convertErrorPlan.stageDetails ?? {
+                        code: followupLogDetails?.code || (typeof errRecord.code === 'string' ? errRecord.code : errCode),
+                        upstreamCode: followupLogDetails?.upstreamCode || upstreamCode || detailUpstreamCode,
+                        reason: followupLogDetails?.reason || compactFollowupLogReason(detailReason),
+                        message
+                    }))
             });
             if (isVerboseErrorLoggingEnabled()) {
                 console.error('[RequestExecutor] Fatal conversion error, bubbling as HTTP error', error);
@@ -684,7 +1057,7 @@ export async function convertProviderResponseIfNeeded(options, deps) {
         if (isVerboseErrorLoggingEnabled()) {
             console.error('[RequestExecutor] Failed to convert provider response via llmswitch-core', error);
         }
-        return options.response;
+        throw error;
     }
 }
 //# sourceMappingURL=provider-response-converter.js.map