@jsonstudio/llms 0.6.749 → 0.6.795

package/dist/servertool/engine.js

@@ -3,7 +3,64 @@ import { ProviderProtocolError } from '../conversion/shared/errors.js';
 import { createHash } from 'node:crypto';
 import { loadRoutingInstructionStateSync, saveRoutingInstructionStateSync } from '../router/virtual-router/sticky-session-store.js';
 import { deserializeRoutingInstructionState, serializeRoutingInstructionState } from '../router/virtual-router/routing-instructions.js';
+function parseTimeoutMs(raw, fallback) {
+    const n = typeof raw === 'string' ? Number(raw.trim()) : typeof raw === 'number' ? raw : NaN;
+    if (!Number.isFinite(n) || n <= 0) {
+        return fallback;
+    }
+    return Math.floor(n);
+}
+function resolveServerToolTimeoutMs() {
+    return parseTimeoutMs(process.env.ROUTECODEX_SERVERTOOL_TIMEOUT_MS ||
+        process.env.RCC_SERVERTOOL_TIMEOUT_MS ||
+        process.env.LLMSWITCH_SERVERTOOL_TIMEOUT_MS, 500_000);
+}
+function resolveServerToolFollowupTimeoutMs(fallback) {
+    return parseTimeoutMs(process.env.ROUTECODEX_SERVERTOOL_FOLLOWUP_TIMEOUT_MS ||
+        process.env.RCC_SERVERTOOL_FOLLOWUP_TIMEOUT_MS ||
+        process.env.LLMSWITCH_SERVERTOOL_FOLLOWUP_TIMEOUT_MS, fallback);
+}
+function withTimeout(promise, timeoutMs, buildError) {
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+        return promise;
+    }
+    let timer;
+    return new Promise((resolve, reject) => {
+        timer = setTimeout(() => reject(buildError()), timeoutMs);
+        promise.then(resolve, reject).finally(() => {
+            if (timer) {
+                clearTimeout(timer);
+                timer = undefined;
+            }
+        });
+    });
+}
+function isServerToolTimeoutError(error) {
+    return Boolean(error &&
+        typeof error === 'object' &&
+        typeof error.code === 'string' &&
+        error.code === 'SERVERTOOL_TIMEOUT');
+}
+function createServerToolTimeoutError(options) {
+    const err = new ProviderProtocolError(`[servertool] ${options.phase} timeout after ${options.timeoutMs}ms` +
+        (options.flowId ? ` flow=${options.flowId}` : ''), {
+        code: 'SERVERTOOL_TIMEOUT',
+        category: 'INTERNAL_ERROR',
+        details: {
+            requestId: options.requestId,
+            phase: options.phase,
+            flowId: options.flowId,
+            timeoutMs: options.timeoutMs,
+            attempt: options.attempt,
+            maxAttempts: options.maxAttempts
+        }
+    });
+    err.status = 504;
+    return err;
+}
 export async function runServerToolOrchestration(options) {
+    const serverToolTimeoutMs = resolveServerToolTimeoutMs();
+    const followupTimeoutMs = resolveServerToolFollowupTimeoutMs(serverToolTimeoutMs);
     const engineOptions = {
         chatResponse: options.chat,
         adapterContext: options.adapterContext,
@@ -13,7 +70,11 @@ export async function runServerToolOrchestration(options) {
         providerInvoker: options.providerInvoker,
         reenterPipeline: options.reenterPipeline
     };
-    const engineResult = await runServerSideToolEngine(engineOptions);
+    const engineResult = await withTimeout(runServerSideToolEngine(engineOptions), serverToolTimeoutMs, () => createServerToolTimeoutError({
+        requestId: options.requestId,
+        phase: 'engine',
+        timeoutMs: serverToolTimeoutMs
+    }));
     if (engineResult.mode === 'passthrough' || !engineResult.execution) {
         return {
             chat: engineResult.finalChatResponse,
@@ -70,12 +131,19 @@ export async function runServerToolOrchestration(options) {
             if (isStopMessageFlow) {
                 reservation = reserveStopMessageUsage(options.adapterContext);
             }
-            followup = await options.reenterPipeline({
+            followup = await withTimeout(options.reenterPipeline({
                 entryEndpoint: followupEntryEndpoint,
                 requestId: followupRequestId,
                 body: engineResult.execution.followup.payload,
                 metadata
-            });
+            }), followupTimeoutMs, () => createServerToolTimeoutError({
+                requestId: options.requestId,
+                phase: 'followup',
+                timeoutMs: followupTimeoutMs,
+                flowId: engineResult.execution.flowId,
+                attempt,
+                maxAttempts
+            }));
             lastError = undefined;
             break;
         }
@@ -84,6 +152,9 @@ export async function runServerToolOrchestration(options) {
                 rollbackStopMessageUsage(reservation);
                 reservation = null;
             }
+            if (isServerToolTimeoutError(error)) {
+                throw error;
+            }
             lastError = error;
             if (attempt >= maxAttempts) {
                 const wrapped = new ProviderProtocolError(`[servertool] Followup failed for flow ${engineResult.execution.flowId ?? 'unknown'} ` +

package/dist/servertool/server-side-tools.js

@@ -1,4 +1,5 @@
 import { getServerToolHandler, listAutoServerToolHandlers } from './registry.js';
+import { ProviderProtocolError } from '../conversion/shared/errors.js';
 import './handlers/web-search.js';
 import './handlers/vision.js';
 import './handlers/iflow-model-error-retry.js';
@@ -49,14 +50,24 @@ async function runHandler(handler, ctx) {
         return await handler(ctx);
     }
     catch (error) {
-        try {
-            // eslint-disable-next-line no-console
-            console.error('[servertool] handler failed', error);
-        }
-        catch {
-            /* logging best-effort */
-        }
-        return null;
+        const toolName = ctx && ctx.toolCall && typeof ctx.toolCall.name === 'string' && ctx.toolCall.name.trim()
+            ? ctx.toolCall.name.trim()
+            : 'auto';
+        const message = error instanceof Error ? error.message : String(error ?? 'unknown');
+        const wrapped = new ProviderProtocolError(`[servertool] handler failed: ${toolName}: ${message}`, {
+            code: 'SERVERTOOL_HANDLER_FAILED',
+            category: 'INTERNAL_ERROR',
+            details: {
+                toolName,
+                requestId: ctx.options?.requestId,
+                entryEndpoint: ctx.options?.entryEndpoint,
+                providerProtocol: ctx.options?.providerProtocol,
+                error: message
+            }
+        });
+        wrapped.status = 500;
+        wrapped.cause = error;
+        throw wrapped;
     }
 }
 export function extractToolCalls(chatResponse) {

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;