@jsonstudio/llms 0.6.1172 → 0.6.1354

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

@@ -10,6 +10,122 @@ import './handlers/clock-auto.js';
 import './handlers/exec-command-guard.js';
 import './handlers/apply-patch-guard.js';
 import './handlers/recursive-detection-guard.js';
+function extractToolCallsFromMessage(message) {
+    const toolCalls = getArray(message.tool_calls);
+    const out = [];
+    for (const raw of toolCalls) {
+        const tc = asObject(raw);
+        if (!tc)
+            continue;
+        const id = typeof tc.id === 'string' && String(tc.id).trim() ? String(tc.id).trim() : '';
+        const fn = asObject(tc.function) ??
+            asObject(tc.functionCall) ??
+            asObject(tc.function_call);
+        const name = fn && typeof fn.name === 'string' && String(fn.name).trim() ? String(fn.name).trim() : '';
+        const rawArgs = (fn ? fn.arguments : undefined) ??
+            (fn ? fn.args : undefined) ??
+            (fn ? fn.input : undefined) ??
+            tc.arguments ??
+            tc.args ??
+            tc.input;
+        let args = '';
+        if (typeof rawArgs === 'string') {
+            args = rawArgs;
+        }
+        else if (rawArgs && typeof rawArgs === 'object') {
+            try {
+                args = JSON.stringify(rawArgs);
+            }
+            catch {
+                args = '';
+            }
+        }
+        else if (rawArgs !== undefined && rawArgs !== null) {
+            args = String(rawArgs);
+        }
+        if (!id || !name)
+            continue;
+        out.push({ raw: tc, parsed: { id, name, arguments: args } });
+    }
+    return out;
+}
+function buildAssistantToolCallMessage(toolCalls) {
+    const calls = toolCalls.map((tc) => ({
+        id: tc.id,
+        type: 'function',
+        function: {
+            name: tc.name,
+            arguments: tc.arguments
+        }
+    }));
+    return { role: 'assistant', content: null, tool_calls: calls };
+}
+function appendToolOutput(base, toolCallId, name, content) {
+    const outputs = Array.isArray(base.tool_outputs) ? base.tool_outputs : [];
+    outputs.push({ tool_call_id: toolCallId, name, content });
+    base.tool_outputs = outputs;
+}
+function buildToolMessagesFromOutputs(base, allowIds) {
+    const outputs = Array.isArray(base.tool_outputs) ? base.tool_outputs : [];
+    const out = [];
+    for (const entry of outputs) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const toolCallId = typeof entry.tool_call_id === 'string' ? String(entry.tool_call_id) : '';
+        if (!toolCallId || !allowIds.has(toolCallId))
+            continue;
+        const name = typeof entry.name === 'string' && String(entry.name).trim()
+            ? String(entry.name).trim()
+            : 'tool';
+        const content = typeof entry.content === 'string' ? String(entry.content) : JSON.stringify(entry.content ?? {});
+        out.push({ role: 'tool', tool_call_id: toolCallId, name, content });
+    }
+    return out;
+}
+function stripToolOutputs(base) {
+    try {
+        delete base.tool_outputs;
+    }
+    catch {
+        /* ignore */
+    }
+}
+function replaceJsonObjectInPlace(target, next) {
+    try {
+        for (const key of Object.keys(target)) {
+            delete target[key];
+        }
+        for (const [k, v] of Object.entries(next)) {
+            target[k] = v;
+        }
+    }
+    catch {
+        // ignore
+    }
+}
+function filterOutExecutedToolCalls(chatResponse, executedIds) {
+    const choices = getArray(chatResponse.choices);
+    for (const choice of choices) {
+        const choiceObj = asObject(choice);
+        if (!choiceObj)
+            continue;
+        const message = asObject(choiceObj.message);
+        if (!message)
+            continue;
+        const toolCalls = getArray(message.tool_calls);
+        if (!toolCalls.length)
+            continue;
+        const next = toolCalls.filter((tc) => {
+            if (!tc || typeof tc !== 'object' || Array.isArray(tc))
+                return true;
+            const id = typeof tc.id === 'string' ? String(tc.id).trim() : '';
+            if (!id)
+                return true;
+            return !executedIds.has(id);
+        });
+        message.tool_calls = next;
+    }
+}
 export async function runServerSideToolEngine(options) {
     const base = asObject(options.chatResponse);
     if (!base) {
@@ -31,20 +147,133 @@ export async function runServerSideToolEngine(options) {
             providerInvoker: typeof options.providerInvoker === 'function'
         }
     };
-    for (const toolCall of toolCalls) {
+    // Tool-call servertools: execute all executable servertool calls first, then decide:
+    // - if only servertools were present -> followup via reenter (existing behavior)
+    // - if mixed (servertool + client tools) -> persist servertool results, return remaining tool_calls to client
+    const executedToolCalls = [];
+    const executedIds = new Set();
+    const baseForExecution = cloneJson(base);
+    const executedFlowIds = [];
+    let lastExecution;
+    const attemptedToolCallsByMessage = [];
+    const choices = getArray(base.choices);
+    for (const choice of choices) {
+        const choiceObj = asObject(choice);
+        if (!choiceObj)
+            continue;
+        const message = asObject(choiceObj.message);
+        if (!message)
+            continue;
+        attemptedToolCallsByMessage.push(...extractToolCallsFromMessage(message));
+    }
+    for (const { parsed: toolCall } of attemptedToolCallsByMessage) {
         const entry = getServerToolHandler(toolCall.name);
-        if (!entry || entry.trigger !== 'tool_call')
+        if (!entry || entry.trigger !== 'tool_call') {
             continue;
-        const ctx = { ...contextBase, toolCall };
-        const planned = await runHandler(entry.handler, ctx);
+        }
+        const ctx = { ...contextBase, base: baseForExecution, toolCall };
+        let planned = null;
+        let lastErr;
+        for (let attempt = 1; attempt <= 2; attempt += 1) {
+            try {
+                planned = await runHandler(entry.handler, ctx);
+                lastErr = undefined;
+                break;
+            }
+            catch (err) {
+                lastErr = err;
+            }
+        }
         const result = planned ? await materializePlannedResult(planned, options) : null;
         if (result) {
+            replaceJsonObjectInPlace(baseForExecution, cloneJson(result.chatResponse));
+            executedToolCalls.push(toolCall);
+            executedIds.add(toolCall.id);
+            if (result.execution?.flowId && typeof result.execution.flowId === 'string' && result.execution.flowId.trim()) {
+                executedFlowIds.push(result.execution.flowId.trim());
+            }
+            lastExecution = result.execution;
+            continue;
+        }
+        if (lastErr) {
+            // Handler failed: report tool error as a tool_output, but do not crash the whole pipeline.
+            const message = lastErr instanceof Error ? lastErr.message : String(lastErr ?? 'unknown');
+            appendToolOutput(baseForExecution, toolCall.id, toolCall.name, JSON.stringify({ ok: false, tool: toolCall.name, message, retryable: true }));
+            executedToolCalls.push(toolCall);
+            executedIds.add(toolCall.id);
+            executedFlowIds.push(`${toolCall.name}_error`);
+        }
+    }
+    if (executedToolCalls.length > 0) {
+        const clientResponse = cloneJson(base);
+        filterOutExecutedToolCalls(clientResponse, executedIds);
+        stripToolOutputs(clientResponse);
+        // Determine whether any non-executed tool_calls remain (client tools).
+        const remainingToolCalls = [];
+        const remainingChoices = getArray(clientResponse.choices);
+        for (const choice of remainingChoices) {
+            const choiceObj = asObject(choice);
+            if (!choiceObj)
+                continue;
+            const message = asObject(choiceObj.message);
+            if (!message)
+                continue;
+            const toolCallsArr = getArray(message.tool_calls);
+            for (const tc of toolCallsArr) {
+                if (!tc || typeof tc !== 'object' || Array.isArray(tc))
+                    continue;
+                const id = typeof tc.id === 'string' ? String(tc.id).trim() : '';
+                if (id)
+                    remainingToolCalls.push(id);
+            }
+        }
+        if (remainingToolCalls.length > 0) {
+            const sessionId = options.adapterContext && typeof options.adapterContext.sessionId === 'string'
+                ? String(options.adapterContext.sessionId).trim()
+                : '';
+            const allowIds = new Set(executedToolCalls.map((t) => t.id));
+            const injectionMessages = [
+                buildAssistantToolCallMessage(executedToolCalls),
+                ...buildToolMessagesFromOutputs(baseForExecution, allowIds)
+            ];
             return {
                 mode: 'tool_flow',
-                finalChatResponse: result.chatResponse,
-                execution: result.execution
+                finalChatResponse: clientResponse,
+                execution: { flowId: 'servertool_mixed' },
+                ...(sessionId && injectionMessages.length
+                    ? {
+                        pendingInjection: {
+                            sessionId,
+                            afterToolCallIds: remainingToolCalls,
+                            messages: injectionMessages
+                        }
+                    }
+                    : {})
             };
         }
+        // Servertool-only: keep tool_outputs and ask orchestration layer to followup/reenter.
+        const genericFollowup = {
+            requestIdSuffix: ':servertool_followup',
+            injection: {
+                ops: [
+                    { op: 'append_assistant_message', required: true },
+                    { op: 'append_tool_messages_from_tool_outputs', required: true }
+                ]
+            }
+        };
+        const followup = executedToolCalls.length === 1 && lastExecution?.followup ? lastExecution.followup : genericFollowup;
+        const flowId = executedToolCalls.length === 1
+            ? (lastExecution?.flowId ?? executedFlowIds[0] ?? executedToolCalls[0].name)
+            : 'servertool_multi';
+        return {
+            mode: 'tool_flow',
+            finalChatResponse: baseForExecution,
+            execution: {
+                ...(lastExecution && executedToolCalls.length === 1 ? lastExecution : { flowId }),
+                flowId,
+                followup
+            }
+        };
     }
     for (const entry of listAutoServerToolHandlers()) {
         const planned = await runHandler(entry.handler, contextBase);

package/dist/servertool/types.d.ts

@@ -50,6 +50,8 @@ export interface ServerSideToolEngineOptions {
     }>;
 }
 export type ServerToolFollowupInjectionOp = {
+    op: 'preserve_tools';
+} | {
     op: 'append_assistant_message';
     required?: boolean;
 } | {
@@ -155,6 +157,17 @@ export interface ServerSideToolEngineResult {
     mode: 'passthrough' | 'tool_flow';
     finalChatResponse: JsonObject;
     execution?: ServerToolExecution;
+    /**
+     * When present, indicates a "mixed tools" flow:
+     * - servertools were executed and their tool results are persisted
+     * - remaining (non-servertool) tool_calls must be returned to client
+     * - on next request, servertool results will be injected after client tool results
+     */
+    pendingInjection?: {
+        sessionId: string;
+        afterToolCallIds: string[];
+        messages: JsonObject[];
+    };
 }
 /**
  * ServerToolHandlerContext：单个工具 handler 的上下文入参。

package/dist/sse/json-to-sse/event-generators/responses.js

@@ -3,7 +3,7 @@
  * 提供纯函数，将Responses响应数据转换为SSE事件对象，不处理流写入
  */
 import { TimeUtils, StringUtils } from '../../shared/utils.js';
-const TEXT_CHUNK_BOUNDARY = /[\n\r\t，。、“”‘’！？,\.\-:\u3000\s]/;
+const TEXT_CHUNK_BOUNDARY = /[\n\r\t，。、“”‘’！？,.\-:\u3000\s]/;
 function cloneRegex(source) {
     return new RegExp(source.source, source.flags);
 }

package/dist/sse/shared/chat-serializer.js

@@ -27,13 +27,13 @@ export function toSSETextStream(objectEventStream) {
             try {
                 out.write('data: {"error":"chat sse serialization failed"}\n\n');
             }
-            catch { }
+            catch { /* ignore */ }
         }
         finally {
             try {
                 out.end();
             }
-            catch { }
+            catch { /* ignore */ }
         }
     })();
     return out;

package/dist/sse/shared/constants.js

@@ -306,7 +306,7 @@ export const LOG_LEVELS = {
 // 正则表达式常量
 export const REGEX_PATTERNS = {
     // 文本分词边界
-    WORD_BOUNDARY: /[\n\r\t，。、"''！？,\.\-:\u3000\s]/,
+    WORD_BOUNDARY: /[\n\r\t，。、"''！？,.\-:\u3000\s]/,
     SENTENCE_BOUNDARY: /[。！？.!?]/,
     PARAGRAPH_BOUNDARY: /[\n\r]{2,}/,
     // JSON验证

package/dist/sse/sse-to-json/anthropic-sse-to-json-converter.d.ts

@@ -1,11 +1,17 @@
+import { DEFAULT_ANTHROPIC_CONVERSION_CONFIG } from '../types/index.js';
 import type { AnthropicMessageResponse, SseToAnthropicJsonOptions } from '../types/index.js';
+type AnthropicSseToJsonConverterConfig = {
+    enableEventValidation: boolean;
+    strictMode: boolean;
+} & typeof DEFAULT_ANTHROPIC_CONVERSION_CONFIG;
 export declare class AnthropicSseToJsonConverter {
     private config;
     private contexts;
-    constructor(config?: Partial<typeof this.config>);
+    constructor(config?: Partial<AnthropicSseToJsonConverterConfig>);
     convertSseToJson(sseStream: AsyncIterable<string | Buffer>, options: SseToAnthropicJsonOptions): Promise<AnthropicMessageResponse>;
     private createContext;
     private chunkStrings;
     private updateStats;
     private wrapError;
 }
+export {};

package/dist/sse/sse-to-json/builders/response-builder.js

@@ -825,6 +825,22 @@ export class ResponsesResponseBuilder {
                 }
                 return { success: true, response: this.response };
             }
+            // 进一步容错：少数上游会在输出流结束前没有发送 output_item.done/response.completed/response.done，
+            // 但已发送 output_item.added/content_part.* 等事件。此时 outputItemBuilders 中已存在内容，
+            // 直接按当前聚合结果构建 output 并视为 completed，避免 SSE_TO_JSON_ERROR: Building not completed。
+            if (this.outputItemBuilders.size > 0) {
+                this.response.status = 'completed';
+                try {
+                    const cur = this.response.output;
+                    if (!Array.isArray(cur) || cur.length === 0) {
+                        this.response.output = this.buildOutputItems();
+                    }
+                }
+                catch {
+                    this.response.output = this.buildOutputItems();
+                }
+                return { success: true, response: this.response };
+            }
         }
         catch { /* ignore */ }
         return { success: false, error: new Error('Building not completed') };

package/dist/sse/sse-to-json/responses-sse-to-json-converter.d.ts

@@ -10,7 +10,7 @@ import type { ResponsesResponse, SseToResponsesJsonContext, SseToResponsesJsonOp
 export declare class ResponsesSseToJsonConverterRefactored {
     private config;
     private contexts;
-    constructor(config?: Partial<typeof this.config>);
+    constructor(config?: Partial<ResponsesSseToJsonConverterRefactored['config']>);
     /**
      * 将SSE流转换为Responses响应
      */

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

@@ -147,7 +147,7 @@ export function captureApplyPatchExecutionFailuresFromProcessedRequest(processed
                 entryEndpoint,
                 providerKey,
                 model,
-                source: 'req_process_stage1_tool_governance',
+                source: 'chat_process.req.stage4.tool_governance',
                 meta: { applyPatchToolMode: resolvedMode },
                 toolCallId,
                 toolCallArgs

package/dist/tools/exec-command/normalize.js

@@ -90,6 +90,10 @@ export function normalizeExecCommandArgs(args) {
     const tty = asBoolean(base.tty);
     if (tty !== undefined)
         normalized.tty = tty;
+    const timeoutMs = asFiniteNumber(base.timeout_ms) ??
+        asFiniteNumber(base.timeoutMs);
+    if (timeoutMs !== undefined)
+        normalized.timeout_ms = timeoutMs;
     const shell = asNonEmptyString(base.shell);
     if (shell)
         normalized.shell = shell;

package/dist/tools/exec-command/regression-capturer.js

@@ -79,7 +79,7 @@ function redactSecrets(text) {
     next = next.replace(/\bcr_[A-Za-z0-9]{20,}\b/g, 'cr_<REDACTED>');
     next = next.replace(/\bAIza[0-9A-Za-z_-]{20,}\b/g, 'AIza<REDACTED>');
     // Authorization headers.
-    next = next.replace(/(authorization\"?\s*:\s*\"?bearer\s+)[^\"]+/gi, '$1<REDACTED>');
+    next = next.replace(/(authorization"?\s*:\s*"?bearer\s+)[^"]+/gi, '$1<REDACTED>');
     next = next.replace(/(authorization:\s*bearer\s+)[^\s]+/gi, '$1<REDACTED>');
     // Shell exports of *_KEY/*_TOKEN/*_SECRET.
     next = next.replace(/(\bexport\s+[A-Z0-9_]*(?:KEY|TOKEN|SECRET)[A-Z0-9_]*=)[^\s'"]+/gi, '$1<REDACTED>');

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "@jsonstudio/llms",
-  "version": "0.6.1172",
+  "version": "0.6.1354",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
-    "build": "node scripts/clean-dist.mjs && node scripts/bump-version.mjs && tsc -p tsconfig.json && node scripts/tools/copy-compat-profiles.mjs",
-    "build:dev": "node scripts/clean-dist.mjs && node scripts/bump-version.mjs && tsc -p tsconfig.json && node scripts/tools/copy-compat-profiles.mjs",
+    "build": "node scripts/clean-dist.mjs && node scripts/bump-version.mjs && node ./node_modules/typescript/bin/tsc -p tsconfig.json && node scripts/tools/copy-compat-profiles.mjs",
+    "build:dev": "node scripts/clean-dist.mjs && node scripts/bump-version.mjs && node ./node_modules/typescript/bin/tsc -p tsconfig.json && node scripts/tools/copy-compat-profiles.mjs",
+    "build:ci": "node scripts/clean-dist.mjs && node ./node_modules/typescript/bin/tsc -p tsconfig.json && node scripts/tools/copy-compat-profiles.mjs",
+    "build:coverage": "node scripts/clean-dist.mjs && node ./node_modules/typescript/bin/tsc -p tsconfig.coverage.json && node scripts/tools/copy-compat-profiles.mjs",
     "lint": "eslint --no-eslintrc -c .eslintrc.json src --ext .ts --no-cache",
     "lint:fix": "eslint --no-eslintrc -c .eslintrc.json src --ext .ts --no-cache --fix",
     "postbuild": "node scripts/tests/run-matrix-ci.mjs",
@@ -25,8 +27,10 @@
     "test:looprt:gemini": "npm run build && node scripts/tests/loop-rt-gemini.mjs",
     "replay:responses:chat-sse": "node scripts/exp3-responses-sse-to-chat-sse.mjs",
     "replay:responses:loop": "node scripts/exp4-responses-sse-loop.mjs",
-    "test:virtual-router": "npm run build:dev && node scripts/tests/virtual-router-prefer-autoclear.mjs && node scripts/tests/virtual-router-dry-run.mjs && node scripts/tests/virtual-router-context.mjs",
-    "test:virtual-router-health": "npm run build:dev && node scripts/tests/virtual-router-health.mjs"
+    "test:virtual-router": "npm run build:dev && node scripts/tests/virtual-router-prefer-autoclear.mjs && node scripts/tests/virtual-router-dry-run.mjs && node scripts/tests/virtual-router-context.mjs && node scripts/tests/virtual-router-antigravity-alias-pin.mjs",
+    "test:virtual-router-health": "npm run build:dev && node scripts/tests/virtual-router-health.mjs",
+    "test:golden": "npm run build:ci && node scripts/tests/chat-golden-roundtrip.mjs && node scripts/tests/anthropic-golden-roundtrip.mjs",
+    "test:coverage": "node scripts/run-ci-coverage.mjs"
   },
   "dependencies": {
     "ajv": "^8.17.1",
@@ -55,6 +59,7 @@
     "@types/node": "^20.11.25",
     "@typescript-eslint/eslint-plugin": "^6.7.4",
     "@typescript-eslint/parser": "^6.7.4",
+    "c8": "^10.1.3",
     "eslint": "^8.50.0",
     "typescript": "^5.4.0"
   },