@jsonstudio/llms 0.6.753 → 0.6.795

package/dist/conversion/compat/profiles/responses-output2choices-test.json

@@ -1,11 +1,12 @@
 {
-    "id": "responses:output2choices-test",
-    "protocol": "openai-responses",
-    "response": {
-        "mappings": [
-            {
-                "action": "convert_responses_output_to_choices"
-            }
-        ]
-    }
+  "id": "responses:output2choices-test",
+  "protocol": "openai-responses",
+  "response": {
+    "mappings": [
+      {
+        "action": "convert_responses_output_to_choices"
+      }
+    ]
+  }
 }
+

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

@@ -64,7 +64,13 @@ export declare class HubPipeline {
     private config;
     private unsubscribeProviderErrors?;
     constructor(config: HubPipelineConfig);
+    updateRuntimeDeps(deps: {
+        healthStore?: HubPipelineConfig['healthStore'] | null;
+        routingStateStore?: HubPipelineConfig['routingStateStore'] | null;
+        quotaView?: HubPipelineConfig['quotaView'] | null;
+    }): void;
     updateVirtualRouterConfig(nextConfig: VirtualRouterConfig): void;
+    dispose(): void;
     private executeRequestStagePipeline;
     execute(request: HubPipelineRequest): Promise<HubPipelineResult>;
     private captureAnthropicAliasMap;

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

@@ -51,6 +51,30 @@ export class HubPipeline {
             this.unsubscribeProviderErrors = undefined;
         }
     }
+    updateRuntimeDeps(deps) {
+        if (!deps || typeof deps !== 'object') {
+            return;
+        }
+        if ('healthStore' in deps) {
+            this.config.healthStore = deps.healthStore ?? undefined;
+        }
+        if ('routingStateStore' in deps) {
+            this.config.routingStateStore = (deps.routingStateStore ?? undefined);
+        }
+        if ('quotaView' in deps) {
+            this.config.quotaView = deps.quotaView ?? undefined;
+        }
+        try {
+            this.routerEngine.updateDeps({
+                healthStore: this.config.healthStore ?? null,
+                routingStateStore: (this.config.routingStateStore ?? null),
+                quotaView: this.config.quotaView ?? null
+            });
+        }
+        catch {
+            // best-effort: runtime deps updates must never break routing
+        }
+    }
     updateVirtualRouterConfig(nextConfig) {
         if (!nextConfig || typeof nextConfig !== 'object') {
             throw new Error('HubPipeline updateVirtualRouterConfig requires VirtualRouterConfig payload');
@@ -58,6 +82,17 @@ export class HubPipeline {
         this.config.virtualRouter = nextConfig;
         this.routerEngine.initialize(nextConfig);
     }
+    dispose() {
+        if (this.unsubscribeProviderErrors) {
+            try {
+                this.unsubscribeProviderErrors();
+            }
+            catch {
+                // ignore dispose failures
+            }
+            this.unsubscribeProviderErrors = undefined;
+        }
+    }
     async executeRequestStagePipeline(normalized, hooks) {
         const formatAdapter = hooks.createFormatAdapter();
         const semanticMapper = hooks.createSemanticMapper();

package/dist/conversion/shared/bridge-message-utils.d.ts

@@ -20,3 +20,4 @@ export interface BridgeInputToChatOptions {
     toolResultFallbackText?: string;
 }
 export declare function convertBridgeInputToChatMessages(options: BridgeInputToChatOptions): Array<Record<string, unknown>>;
+export declare function ensureMessagesArray(state: any): Array<Record<string, unknown>>;

package/dist/conversion/shared/bridge-message-utils.js

@@ -644,3 +644,10 @@ export function convertBridgeInputToChatMessages(options) {
     }
     return messages;
 }
+export function ensureMessagesArray(state) {
+    if (Array.isArray(state.messages))
+        return state.messages;
+    if (!state.messages)
+        state.messages = [];
+    return state.messages;
+}

package/dist/conversion/shared/bridge-policies.js

@@ -171,7 +171,7 @@ const OPENAI_CHAT_POLICY = {
     request: {
         inbound: [
             reasoningAction('openai_chat_reasoning'),
-            toolCallNormalizationAction('openai_chat_tool_call'),
+            toolCallNormalizationAction('openai_chat_tool_call'), { name: 'compat.fix-apply-patch' },
             { name: 'messages.ensure-system-instruction' },
             { name: 'metadata.extra-fields', options: { allowedKeys: OPENAI_CHAT_ALLOWED_FIELDS } },
             { name: 'metadata.provider-field', options: { field: 'metadata', target: 'providerMetadata' } },
@@ -180,7 +180,7 @@ const OPENAI_CHAT_POLICY = {
         outbound: [
             { name: 'messages.normalize-history' },
             { name: 'tools.capture-results' },
-            toolCallNormalizationAction('openai_chat_tool_call'),
+            toolCallNormalizationAction('openai_chat_tool_call'), { name: 'compat.fix-apply-patch' },
             { name: 'tools.ensure-placeholders' },
             { name: 'messages.ensure-output-fields', options: { toolFallback: 'Tool call completed (no output).' } },
             { name: 'messages.ensure-system-instruction' },
@@ -193,12 +193,12 @@ const OPENAI_CHAT_POLICY = {
     response: {
         inbound: [
             reasoningAction('openai_chat_reasoning'),
-            toolCallNormalizationAction('openai_chat_tool_call'),
+            toolCallNormalizationAction('openai_chat_tool_call'), { name: 'compat.fix-apply-patch' },
             { name: 'metadata.extra-fields', options: { allowedKeys: OPENAI_CHAT_ALLOWED_FIELDS } }
         ],
         outbound: [
             reasoningAction('openai_chat_reasoning'),
-            toolCallNormalizationAction('openai_chat_tool_call'),
+            toolCallNormalizationAction('openai_chat_tool_call'), { name: 'compat.fix-apply-patch' },
             { name: 'metadata.extra-fields', options: { allowedKeys: OPENAI_CHAT_ALLOWED_FIELDS } }
         ]
     }
@@ -242,7 +242,7 @@ const GEMINI_POLICY = {
     protocol: 'gemini-chat',
     request: {
         inbound: [
-            reasoningAction('gemini_reasoning'),
+            reasoningAction('gemini_reasoning'), { name: 'compat.fix-apply-patch' },
             { name: 'messages.ensure-system-instruction' },
             { name: 'metadata.extra-fields', options: { allowedKeys: GEMINI_ALLOWED_FIELDS } }
         ],
@@ -252,17 +252,17 @@ const GEMINI_POLICY = {
             { name: 'tools.ensure-placeholders' },
             { name: 'messages.ensure-output-fields', options: { toolFallback: 'Tool call completed (no output).' } },
             { name: 'messages.ensure-system-instruction' },
-            reasoningAction('gemini_reasoning'),
+            reasoningAction('gemini_reasoning'), { name: 'compat.fix-apply-patch' },
             { name: 'metadata.extra-fields', options: { allowedKeys: GEMINI_ALLOWED_FIELDS } }
         ]
     },
     response: {
         inbound: [
-            reasoningAction('gemini_reasoning'),
+            reasoningAction('gemini_reasoning'), { name: 'compat.fix-apply-patch' },
             { name: 'metadata.extra-fields', options: { allowedKeys: GEMINI_ALLOWED_FIELDS } }
         ],
         outbound: [
-            reasoningAction('gemini_reasoning'),
+            reasoningAction('gemini_reasoning'), { name: 'compat.fix-apply-patch' },
             { name: 'metadata.extra-fields', options: { allowedKeys: GEMINI_ALLOWED_FIELDS } }
         ]
     }

package/dist/conversion/shared/tool-governor.js

@@ -4,7 +4,8 @@
 // enforceChatBudget: 为避免在请求侧引入多余依赖，这里提供最小实现（保留形状，不裁剪）。
 import { augmentOpenAITools } from '../../guidance/index.js';
 import { validateToolCall } from '../../tools/tool-registry.js';
-import { repairFindMeta } from './tooling.js';
+import { captureApplyPatchRegression } from '../../tools/patch-regression-capturer.js';
+import { normalizeExecCommandArgs } from '../../tools/exec-command/normalize.js';
 function isObject(v) { return !!v && typeof v === 'object' && !Array.isArray(v); }
 // Note: tool schema strict augmentation removed per alignment
 function enforceChatBudget(chat, _modelId) { return chat; }
@@ -245,6 +246,13 @@ export function normalizeApplyPatchToolCallsOnResponse(chat) {
                     else if (validation && !validation.ok) {
                         try {
                             const reason = validation.reason ?? 'unknown';
+                            captureApplyPatchRegression({
+                                errorType: reason,
+                                originalArgs: rawArgs,
+                                normalizedArgs: argsStr,
+                                validationError: reason,
+                                source: 'tool-governor.response'
+                            });
                             const snippet = typeof argsStr === 'string' && argsStr.trim().length
                                 ? argsStr.trim().slice(0, 200).replace(/\s+/g, ' ')
                                 : '';
@@ -312,6 +320,13 @@ function normalizeSpecialToolCallsOnRequest(request) {
                         else if (validation && !validation.ok) {
                             try {
                                 const reason = validation.reason ?? 'unknown';
+                                captureApplyPatchRegression({
+                                    errorType: reason,
+                                    originalArgs: rawArgs,
+                                    normalizedArgs: argsStr,
+                                    validationError: reason,
+                                    source: 'tool-governor.request'
+                                });
                                 const snippet = typeof argsStr === 'string' && argsStr.trim().length
                                     ? argsStr.trim().slice(0, 200).replace(/\s+/g, ' ')
                                     : '';
@@ -336,8 +351,9 @@ function normalizeSpecialToolCallsOnRequest(request) {
                         }
                         if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
                             const normalized = normalizeExecCommandArgs(parsed);
+                            const next = normalized.ok ? normalized.normalized : parsed;
                             try {
-                                fn.arguments = JSON.stringify(normalized ?? {});
+                                fn.arguments = JSON.stringify(next ?? {});
                             }
                             catch {
                                 fn.arguments = '{}';
@@ -356,27 +372,6 @@ function normalizeSpecialToolCallsOnRequest(request) {
         return request;
     }
 }
-function normalizeExecCommandArgs(args) {
-    try {
-        const out = { ...args };
-        const rawCmd = typeof out.cmd === 'string' && out.cmd.trim().length
-            ? String(out.cmd)
-            : typeof out.command === 'string' && out.command.trim().length
-                ? String(out.command)
-                : undefined;
-        if (rawCmd) {
-            const fixed = repairFindMeta(rawCmd);
-            out.cmd = fixed;
-            if (typeof out.command === 'string') {
-                out.command = fixed;
-            }
-        }
-        return out;
-    }
-    catch {
-        return args;
-    }
-}
 function enhanceResponseToolArguments(chat) {
     try {
         const enable = String(process?.env?.RCC_TOOL_ENHANCE ?? '1').trim() !== '0';

package/dist/filters/special/response-tool-arguments-stringify.js

@@ -1,28 +1,8 @@
 import { repairFindMeta } from '../../conversion/shared/tooling.js';
+import { normalizeExecCommandArgs } from '../../tools/exec-command/normalize.js';
 function isObject(v) {
     return !!v && typeof v === 'object' && !Array.isArray(v);
 }
-function normalizeExecCommandArgs(args) {
-    try {
-        const out = { ...args };
-        const rawCmd = typeof out.cmd === 'string' && out.cmd.trim().length
-            ? String(out.cmd)
-            : typeof out.command === 'string' && out.command.trim().length
-                ? String(out.command)
-                : undefined;
-        if (rawCmd) {
-            const fixed = repairFindMeta(rawCmd);
-            out.cmd = fixed;
-            if (typeof out.command === 'string') {
-                out.command = fixed;
-            }
-        }
-        return out;
-    }
-    catch {
-        return args;
-    }
-}
 function packShellCommand(cmd) {
     // Normalize into ["bash","-lc","<single string>"] to support pipes, parens, -exec, etc.
     const normalizeArray = (argv) => {
@@ -104,8 +84,9 @@ export class ResponseToolArgumentsStringifyFilter {
                             }
                             else if ((name === 'exec_command' || name === 'shell_command' || name === 'bash') && isObject(parsed)) {
                                 const normalized = normalizeExecCommandArgs(parsed);
+                                const next = normalized.ok ? normalized.normalized : parsed;
                                 try {
-                                    fn.arguments = JSON.stringify(normalized ?? {});
+                                    fn.arguments = JSON.stringify(next ?? {});
                                 }
                                 catch {
                                     fn.arguments = '{}';

package/dist/router/virtual-router/engine.d.ts

@@ -29,6 +29,11 @@ export declare class VirtualRouterEngine {
         routingStateStore?: RoutingInstructionStateStore;
         quotaView?: ProviderQuotaView;
     });
+    updateDeps(deps: {
+        healthStore?: VirtualRouterHealthStore | null;
+        routingStateStore?: RoutingInstructionStateStore | null;
+        quotaView?: ProviderQuotaView | null;
+    }): void;
     private parseDirectProviderModel;
     initialize(config: VirtualRouterConfig): void;
     route(request: StandardizedRequest | ProcessedRequest, metadata: RouterMetadataInput): {

package/dist/router/virtual-router/engine.js

@@ -44,6 +44,27 @@ export class VirtualRouterEngine {
             this.quotaView = deps.quotaView;
         }
     }
+    updateDeps(deps) {
+        if (!deps || typeof deps !== 'object') {
+            return;
+        }
+        if ('healthStore' in deps) {
+            this.healthStore = deps.healthStore ?? undefined;
+        }
+        if ('routingStateStore' in deps) {
+            this.routingStateStore =
+                deps.routingStateStore ??
+                    {
+                        loadSync: loadRoutingInstructionStateSync,
+                        saveAsync: saveRoutingInstructionStateAsync
+                    };
+            // Routing state store changes require clearing in-memory cache to avoid stale reads.
+            this.routingInstructionState.clear();
+        }
+        if ('quotaView' in deps) {
+            this.quotaView = deps.quotaView ?? undefined;
+        }
+    }
     parseDirectProviderModel(model) {
         const raw = typeof model === 'string' ? model.trim() : '';
         if (!raw) {

package/dist/tools/apply-patch/regression-capturer.d.ts

@@ -0,0 +1,12 @@
+interface RegressionSample {
+    id: string;
+    timestamp: string;
+    errorType: string;
+    originalArgs: string;
+    normalizedArgs?: string;
+    fixerResult?: string;
+    validationError?: string;
+    source?: string;
+}
+export declare function captureApplyPatchRegression(sample: Omit<RegressionSample, 'id' | 'timestamp'>): void;
+export {};

package/dist/tools/apply-patch/regression-capturer.js

@@ -0,0 +1,112 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { createHash } from 'crypto';
+/**
+ * Captures apply_patch payload regressions into a golden samples structure.
+ *
+ * Trigger: apply_patch validation failure OR fixer failure
+ * Condition: non-context errors only (format/json/prefix/etc.)
+ *
+ * Default destination:
+ *   ~/.routecodex/golden_samples/ci-regression/apply_patch/<error-type>/
+ *
+ * Optional repo destination (explicit opt-in):
+ *   ROUTECODEX_APPLY_PATCH_REGRESSION_TO_REPO=1
+ *   → <repoRoot>/samples/ci-goldens/_regressions/apply_patch/<error-type>/
+ *
+ * Explicit override:
+ *   ROUTECODEX_APPLY_PATCH_REGRESSION_DIR=/abs/path
+ */
+const MAX_SAMPLES_PER_TYPE = 50;
+function detectRepoRootFromCwd() {
+    try {
+        let dir = process.cwd();
+        for (let i = 0; i < 12; i += 1) {
+            const marker = path.join(dir, 'samples', 'ci-goldens');
+            const pkg = path.join(dir, 'package.json');
+            if (fs.existsSync(marker) && fs.existsSync(pkg)) {
+                try {
+                    const raw = fs.readFileSync(pkg, 'utf-8');
+                    const json = JSON.parse(raw);
+                    if (json && typeof json === 'object' && String(json.name || '') === 'routecodex') {
+                        return dir;
+                    }
+                }
+                catch {
+                    // ignore parse errors
+                }
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    catch {
+        // ignore
+    }
+    return null;
+}
+function resolveSamplesRoot() {
+    const explicit = String(process?.env?.ROUTECODEX_APPLY_PATCH_REGRESSION_DIR || '').trim();
+    if (explicit) {
+        return path.resolve(explicit);
+    }
+    const toRepo = String(process?.env?.ROUTECODEX_APPLY_PATCH_REGRESSION_TO_REPO || '').trim() === '1';
+    if (toRepo) {
+        const repoRoot = detectRepoRootFromCwd();
+        if (repoRoot) {
+            return path.join(repoRoot, 'samples', 'ci-goldens', '_regressions', 'apply_patch');
+        }
+    }
+    return path.join(os.homedir(), '.routecodex', 'golden_samples', 'ci-regression', 'apply_patch');
+}
+function isContextError(error) {
+    if (!error)
+        return false;
+    const lower = error.toLowerCase();
+    return (lower.includes('failed to find context') ||
+        lower.includes('failed to find expected lines') ||
+        lower.includes('file not found') ||
+        lower.includes('no such file'));
+}
+function stableSampleId(sample) {
+    const key = `${String(sample.errorType || 'unknown')}:${String(sample.originalArgs ?? '')}:` +
+        `${String(sample.normalizedArgs ?? '')}:${String(sample.fixerResult ?? '')}:${String(sample.validationError ?? '')}`;
+    return createHash('sha1').update(key).digest('hex').slice(0, 16);
+}
+export function captureApplyPatchRegression(sample) {
+    try {
+        if (isContextError(sample.validationError))
+            return;
+        const root = resolveSamplesRoot();
+        const safeType = String(sample.errorType || 'unknown').replace(/[^a-z0-9-]/gi, '_');
+        const typeDir = path.join(root, safeType);
+        if (!fs.existsSync(typeDir)) {
+            fs.mkdirSync(typeDir, { recursive: true });
+        }
+        // Check limit (best-effort; keep runtime safe)
+        try {
+            const existing = fs.readdirSync(typeDir).filter((f) => f.endsWith('.json'));
+            if (existing.length >= MAX_SAMPLES_PER_TYPE)
+                return;
+        }
+        catch {
+            // ignore
+        }
+        const id = `sample_${stableSampleId(sample)}`;
+        const file = path.join(typeDir, `${id}.json`);
+        if (fs.existsSync(file))
+            return;
+        const fullSample = {
+            id,
+            timestamp: new Date().toISOString(),
+            ...sample
+        };
+        fs.writeFileSync(file, JSON.stringify(fullSample, null, 2), 'utf-8');
+    }
+    catch {
+        // Silently fail to avoid disrupting runtime
+    }
+}

package/dist/tools/apply-patch/structured.d.ts

@@ -0,0 +1,20 @@
+export type StructuredApplyPatchKind = 'insert_after' | 'insert_before' | 'replace' | 'delete' | 'create_file' | 'delete_file';
+export interface StructuredApplyPatchChange {
+    file?: string;
+    kind: StructuredApplyPatchKind | string;
+    anchor?: string;
+    target?: string;
+    lines?: string[] | string;
+    use_anchor_indent?: boolean;
+}
+export interface StructuredApplyPatchPayload extends Record<string, unknown> {
+    instructions?: string;
+    file?: string;
+    changes: StructuredApplyPatchChange[];
+}
+export declare class StructuredApplyPatchError extends Error {
+    reason: string;
+    constructor(reason: string, message: string);
+}
+export declare function buildStructuredPatch(payload: StructuredApplyPatchPayload): string;
+export declare function isStructuredApplyPatchPayload(candidate: unknown): candidate is StructuredApplyPatchPayload;