@jsonstudio/llms 0.6.938 → 0.6.954

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

@@ -26,6 +26,22 @@ import { extractSessionIdentifiersFromMetadata } from './session-identifiers.js'
 import { computeRequestTokens } from '../../../router/virtual-router/token-estimator.js';
 import { isCompactionRequest } from '../../shared/compaction-detect.js';
 import { applyHubProviderOutboundPolicy, recordHubPolicyObservation, setHubPolicyRuntimePolicy } from '../policy/policy-engine.js';
+function extractHubPolicyOverride(metadata) {
+    const raw = metadata ? metadata.__hubPolicyOverride : undefined;
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return undefined;
+    }
+    const obj = raw;
+    const mode = typeof obj.mode === 'string' ? obj.mode.trim().toLowerCase() : '';
+    const sampleRate = typeof obj.sampleRate === 'number' && Number.isFinite(obj.sampleRate) ? obj.sampleRate : undefined;
+    if (mode !== 'off' && mode !== 'observe' && mode !== 'enforce') {
+        return undefined;
+    }
+    return {
+        mode: mode,
+        ...(sampleRate !== undefined ? { sampleRate } : {})
+    };
+}
 export class HubPipeline {
     routerEngine;
     config;
@@ -116,11 +132,15 @@ export class HubPipeline {
             normalized.metadata = normalized.metadata || {};
             normalized.metadata.compactionRequest = true;
         }
+        const effectivePolicy = normalized.policyOverride ?? this.config.policy;
         const inboundAdapterContext = this.buildAdapterContext(normalized);
-        const inboundRecorder = this.maybeCreateStageRecorder(inboundAdapterContext, normalized.entryEndpoint);
+        const inboundRecorder = this.maybeCreateStageRecorder(inboundAdapterContext, normalized.entryEndpoint, {
+            disableSnapshots: normalized.disableSnapshots === true
+        });
         const inboundStart = Date.now();
         // Phase 0: observe client inbound payload violations (best-effort; no rewrites).
         recordHubPolicyObservation({
+            policy: effectivePolicy,
             providerProtocol: this.resolveClientProtocol(normalized.entryEndpoint),
             payload: rawRequest,
             phase: 'client_inbound',
@@ -280,7 +300,9 @@ export class HubPipeline {
         // Snapshots must be grouped by entry endpoint (client-facing protocol), not by provider protocol.
         // Otherwise one request would be split across multiple folders (e.g. openai-responses + anthropic-messages),
         // which breaks codex-samples correlation.
-        const outboundRecorder = this.maybeCreateStageRecorder(outboundAdapterContext, normalized.entryEndpoint);
+        const outboundRecorder = this.maybeCreateStageRecorder(outboundAdapterContext, normalized.entryEndpoint, {
+            disableSnapshots: normalized.disableSnapshots === true
+        });
         const outboundStart = Date.now();
         let providerPayload;
         const outboundStage1 = await runReqOutboundStage1SemanticMap({
@@ -303,14 +325,14 @@ export class HubPipeline {
             stageRecorder: outboundRecorder
         });
         providerPayload = applyHubProviderOutboundPolicy({
-            policy: this.config.policy,
+            policy: effectivePolicy,
             providerProtocol: outboundProtocol,
             payload: formattedPayload,
             stageRecorder: outboundRecorder,
             requestId: normalized.id
         });
         recordHubPolicyObservation({
-            policy: this.config.policy,
+            policy: effectivePolicy,
             providerProtocol: outboundProtocol,
             payload: providerPayload,
             stageRecorder: outboundRecorder,
@@ -481,6 +503,10 @@ export class HubPipeline {
             streamingHint,
             toolCallIdStyle
         };
+        const runtime = metadata.runtime;
+        if (runtime && typeof runtime === 'object' && !Array.isArray(runtime)) {
+            adapterContext.runtime = jsonClone(runtime);
+        }
         const clientRequestId = typeof metadata.clientRequestId === 'string'
             ? metadata.clientRequestId.trim()
             : '';
@@ -569,7 +595,10 @@ export class HubPipeline {
         }
         return adapterContext;
     }
-    maybeCreateStageRecorder(context, endpoint) {
+    maybeCreateStageRecorder(context, endpoint, options) {
+        if (options?.disableSnapshots === true) {
+            return undefined;
+        }
         if (!shouldRecordSnapshots()) {
             return undefined;
         }
@@ -596,6 +625,14 @@ export class HubPipeline {
         const metadataRecord = {
             ...(request.metadata ?? {})
         };
+        const policyOverride = extractHubPolicyOverride(metadataRecord);
+        if (Object.prototype.hasOwnProperty.call(metadataRecord, '__hubPolicyOverride')) {
+            delete metadataRecord.__hubPolicyOverride;
+        }
+        const disableSnapshots = metadataRecord.__disableHubSnapshots === true;
+        if (Object.prototype.hasOwnProperty.call(metadataRecord, '__disableHubSnapshots')) {
+            delete metadataRecord.__disableHubSnapshots;
+        }
         const entryEndpoint = typeof metadataRecord.entryEndpoint === 'string'
             ? normalizeEndpoint(metadataRecord.entryEndpoint)
             : endpoint;
@@ -633,6 +670,8 @@ export class HubPipeline {
             providerProtocol,
             payload,
             metadata: normalizedMetadata,
+            policyOverride: policyOverride ?? undefined,
+            disableSnapshots,
             processMode,
             direction,
             stage,

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

@@ -312,9 +312,6 @@ function buildApplyPatchDiagnostics(output) {
 }
 function appendDiagnosticsToRecord(record) {
     const name = typeof record.name === 'string' ? record.name.trim() : undefined;
-    if (name !== 'apply_patch') {
-        return;
-    }
     let text;
     if (typeof record.output === 'string') {
         text = record.output;
@@ -329,6 +326,12 @@ function appendDiagnosticsToRecord(record) {
     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') {
+        return;
+    }
     const merged = `${text}${diag}`;
     if (typeof record.output === 'string') {
         record.output = merged;

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

@@ -59,6 +59,25 @@ function normalizeToolContent(content) {
         return String(content ?? '');
     }
 }
+function maybeAugmentRouteCodexApplyPatchPrecheck(content) {
+    if (!content || typeof content !== 'string') {
+        return content;
+    }
+    if (content.includes('[RouteCodex precheck]')) {
+        return content;
+    }
+    const lower = content.toLowerCase();
+    if (!lower.includes('failed to parse function arguments')) {
+        return content;
+    }
+    if (content.includes('missing field `input`')) {
+        return `${content}\n\n[RouteCodex precheck] apply_patch 参数解析失败：缺少字段 "input"。当前 RouteCodex 期望 { input, patch } 形态，并且两个字段都应包含完整统一 diff 文本。`;
+    }
+    if (content.includes('invalid type: map, expected a string')) {
+        return `${content}\n\n[RouteCodex precheck] apply_patch 参数类型错误：检测到 JSON 对象（map），但客户端期望字符串。请先对参数做 JSON.stringify 再写入 arguments，或直接提供 { patch: "<统一 diff>" } 形式。`;
+    }
+    return content;
+}
 export function maybeAugmentApplyPatchErrorContent(content, toolName) {
     if (!content)
         return content;
@@ -175,9 +194,21 @@ function normalizeChatMessages(raw) {
                 return;
             }
             const nameValue = typeof value.name === 'string' && value.name.trim().length ? value.name : undefined;
+            const normalizedToolOutput = normalizeToolContent(value.content ?? value.output);
+            const routeCodexPrechecked = maybeAugmentRouteCodexApplyPatchPrecheck(normalizedToolOutput);
+            if (routeCodexPrechecked !== normalizedToolOutput) {
+                // Keep tool role message content aligned with outbound provider requests (e.g. Chat→Responses),
+                // while avoiding double-injection.
+                if (typeof chatMessage.content === 'string' || chatMessage.content === undefined || chatMessage.content === null) {
+                    chatMessage.content = routeCodexPrechecked;
+                }
+                else if (typeof chatMessage.output === 'string') {
+                    chatMessage.output = routeCodexPrechecked;
+                }
+            }
             const outputEntry = {
                 tool_call_id: toolCallId,
-                content: normalizeToolContent(value.content ?? value.output),
+                content: routeCodexPrechecked,
                 name: nameValue
             };
             outputEntry.content = maybeAugmentApplyPatchErrorContent(outputEntry.content, outputEntry.name);

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

@@ -624,20 +624,25 @@ function alignToolCallArgsToSchema(options) {
     const next = { ...options.args };
     // Align historical Codex tool args to the *declared schema* for Gemini.
     // Gemini validates historical functionCall.args against tool declarations, so mismatches like:
-    // - exec_command: { cmd } vs schema { command }
-    // - apply_patch: { patch/input } vs schema { instructions/changes }
+    // - exec_command: { cmd } vs schema { command } (or vice-versa)
+    // - apply_patch: { patch/input } vs schema { instructions } (or vice-versa)
     // can cause MALFORMED_FUNCTION_CALL and empty responses.
     if (lowered === 'exec_command') {
+        // Prefer the declared schema key; do not delete keys blindly.
+        if (schema.has('cmd') && !Object.prototype.hasOwnProperty.call(next, 'cmd') && Object.prototype.hasOwnProperty.call(next, 'command')) {
+            next.cmd = next.command;
+        }
         if (schema.has('command') && !Object.prototype.hasOwnProperty.call(next, 'command') && Object.prototype.hasOwnProperty.call(next, 'cmd')) {
             next.command = next.cmd;
         }
-        delete next.cmd;
     }
     else if (lowered === 'write_stdin') {
         if (schema.has('chars') && !Object.prototype.hasOwnProperty.call(next, 'chars') && Object.prototype.hasOwnProperty.call(next, 'text')) {
             next.chars = next.text;
         }
-        delete next.text;
+        if (schema.has('text') && !Object.prototype.hasOwnProperty.call(next, 'text') && Object.prototype.hasOwnProperty.call(next, 'chars')) {
+            next.text = next.chars;
+        }
     }
     else if (lowered === 'apply_patch') {
         if (schema.has('instructions') && !Object.prototype.hasOwnProperty.call(next, 'instructions')) {
@@ -648,8 +653,12 @@ function alignToolCallArgsToSchema(options) {
                 next.instructions = candidate;
             }
         }
-        delete next.patch;
-        delete next.input;
+        if (schema.has('patch') && !Object.prototype.hasOwnProperty.call(next, 'patch')) {
+            const input = typeof next.input === 'string' ? next.input : undefined;
+            if (input && input.trim().length) {
+                next.patch = input;
+            }
+        }
     }
     // Prune to schema keys for known Codex tools to reduce strict upstream validation failures.
     if (lowered === 'exec_command' || lowered === 'write_stdin' || lowered === 'apply_patch') {

package/dist/conversion/shared/gemini-tool-utils.js

@@ -73,8 +73,8 @@ function cloneParameters(value) {
                     continue;
                 if (key === 'exclusiveMinimum' || key === 'exclusiveMaximum' || key === 'propertyNames')
                     continue;
-                // Keep Gemini tool schemas permissive to avoid upstream MALFORMED_FUNCTION_CALL on strict validation.
-                // Validation is enforced by llmswitch-core / servertool layers instead.
+                // Keep Gemini tool schemas mostly permissive to avoid upstream MALFORMED_FUNCTION_CALL on strict validation.
+                // We selectively re-introduce safe required fields for critical tools in `buildGeminiToolsFromBridge`.
                 if (key === 'required' || key === 'additionalProperties')
                     continue;
                 // Combinators are handled at the node level above.
@@ -166,6 +166,49 @@ export function buildGeminiToolsFromBridge(defs) {
         return undefined;
     }
     const tools = [];
+    const applyFixups = (name, parameters) => {
+        if (!parameters || typeof parameters !== 'object' || Array.isArray(parameters)) {
+            return parameters;
+        }
+        const params = parameters;
+        const propsRaw = params.properties;
+        const props = isPlainRecord(propsRaw) ? propsRaw : {};
+        const lowered = String(name || '').trim().toLowerCase();
+        if (lowered === 'exec_command') {
+            // Keep Gemini tool schema aligned with historical functionCall args. We observed large
+            // conversations containing exec_command args as { command, workdir } and strict Gemini
+            // validation will emit MALFORMED_FUNCTION_CALL when schema/args mismatch.
+            if (!Object.prototype.hasOwnProperty.call(props, 'command') && Object.prototype.hasOwnProperty.call(props, 'cmd')) {
+                props.command = props.cmd;
+                try {
+                    delete props.cmd;
+                }
+                catch {
+                    // ignore
+                }
+            }
+            if (!Object.prototype.hasOwnProperty.call(props, 'command')) {
+                props.command = { type: 'string' };
+            }
+            params.properties = props;
+            params.required = ['command'];
+            return params;
+        }
+        if (lowered === 'write_stdin') {
+            params.required = ['session_id'];
+            return params;
+        }
+        if (lowered === 'apply_patch') {
+            // Force a non-empty patch payload; leaving the schema fully permissive results in repeated `{}` tool calls.
+            if (!Object.prototype.hasOwnProperty.call(props, 'patch')) {
+                props.patch = { type: 'string' };
+            }
+            params.properties = props;
+            params.required = ['patch'];
+            return params;
+        }
+        return params;
+    };
     defs.forEach((def) => {
         if (!def || typeof def !== 'object') {
             return;
@@ -184,7 +227,7 @@ export function buildGeminiToolsFromBridge(defs) {
             : typeof def.description === 'string'
                 ? def.description
                 : undefined;
-        const parameters = cloneParameters(fnNode?.parameters ?? def.parameters ?? { type: 'object', properties: {} });
+        const parameters = applyFixups(name, cloneParameters(fnNode?.parameters ?? def.parameters ?? { type: 'object', properties: {} }));
         tools.push({
             functionDeclarations: [
                 {

package/dist/servertool/engine.js

@@ -185,10 +185,12 @@ export async function runServerToolOrchestration(options) {
     }
     const isStopMessageFlow = engineResult.execution.flowId === 'stop_message_flow';
     const isGeminiEmptyReplyContinue = engineResult.execution.flowId === 'gemini_empty_reply_continue';
+    const isApplyPatchGuard = engineResult.execution.flowId === 'apply_patch_guard';
+    const isExecCommandGuard = engineResult.execution.flowId === 'exec_command_guard';
     const stopMessageSource = isStopMessageFlow ? getStopMessageSource(options.adapterContext) : undefined;
     const isAutoStopMessage = isStopMessageFlow && stopMessageSource !== 'explicit';
     const isErrorAutoFlow = engineResult.execution.flowId === 'iflow_model_error_retry';
-    const applyAutoLimit = isAutoStopMessage || isErrorAutoFlow;
+    const applyAutoLimit = isAutoStopMessage || isErrorAutoFlow || isGeminiEmptyReplyContinue || isApplyPatchGuard || isExecCommandGuard;
     // ServerTool followups must not inherit or inject any routeHint; always route fresh.
     const preserveRouteHint = false;
     const loopState = buildServerToolLoopState(options.adapterContext, engineResult.execution.flowId, engineResult.execution.followup.payload);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsonstudio/llms",
-  "version": "0.6.938",
+  "version": "0.6.954",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",