@jsonstudio/llms 0.6.954 → 0.6.1172

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

@@ -1,12 +1,15 @@
 import { getServerToolHandler, listAutoServerToolHandlers } from './registry.js';
 import { ProviderProtocolError } from '../conversion/shared/errors.js';
-import './handlers/web-search.js';
-import './handlers/vision.js';
+import { executeWebSearchBackendPlan } from './handlers/web-search.js';
+import { executeVisionBackendPlan } from './handlers/vision.js';
 import './handlers/iflow-model-error-retry.js';
 import './handlers/gemini-empty-reply-continue.js';
 import './handlers/stop-message-auto.js';
+import './handlers/clock.js';
+import './handlers/clock-auto.js';
 import './handlers/exec-command-guard.js';
 import './handlers/apply-patch-guard.js';
+import './handlers/recursive-detection-guard.js';
 export async function runServerSideToolEngine(options) {
     const base = asObject(options.chatResponse);
     if (!base) {
@@ -20,14 +23,21 @@ export async function runServerSideToolEngine(options) {
         base,
         toolCalls,
         adapterContext: options.adapterContext,
-        options
+        requestId: options.requestId,
+        entryEndpoint: options.entryEndpoint,
+        providerProtocol: options.providerProtocol,
+        capabilities: {
+            reenterPipeline: typeof options.reenterPipeline === 'function',
+            providerInvoker: typeof options.providerInvoker === 'function'
+        }
     };
     for (const toolCall of toolCalls) {
         const entry = getServerToolHandler(toolCall.name);
         if (!entry || entry.trigger !== 'tool_call')
             continue;
         const ctx = { ...contextBase, toolCall };
-        const result = await runHandler(entry.handler, ctx);
+        const planned = await runHandler(entry.handler, ctx);
+        const result = planned ? await materializePlannedResult(planned, options) : null;
         if (result) {
             return {
                 mode: 'tool_flow',
@@ -37,7 +47,8 @@ export async function runServerSideToolEngine(options) {
         }
     }
     for (const entry of listAutoServerToolHandlers()) {
-        const result = await runHandler(entry.handler, contextBase);
+        const planned = await runHandler(entry.handler, contextBase);
+        const result = planned ? await materializePlannedResult(planned, options) : null;
         if (result) {
             return {
                 mode: 'tool_flow',
@@ -62,9 +73,9 @@ async function runHandler(handler, ctx) {
             category: 'INTERNAL_ERROR',
             details: {
                 toolName,
-                requestId: ctx.options?.requestId,
-                entryEndpoint: ctx.options?.entryEndpoint,
-                providerProtocol: ctx.options?.providerProtocol,
+                requestId: ctx.requestId,
+                entryEndpoint: ctx.entryEndpoint,
+                providerProtocol: ctx.providerProtocol,
                 error: message
             }
         });
@@ -73,6 +84,27 @@ async function runHandler(handler, ctx) {
         throw wrapped;
     }
 }
+async function materializePlannedResult(planned, options) {
+    if (planned && typeof planned === 'object' && !Array.isArray(planned) && typeof planned.finalize === 'function') {
+        const plan = planned;
+        const backendResult = plan.backend ? await executeBackendPlan(plan.backend, options) : undefined;
+        return await plan.finalize({ ...(backendResult ? { backendResult } : {}) });
+    }
+    return planned;
+}
+async function executeBackendPlan(plan, options) {
+    if (!plan)
+        return undefined;
+    if (plan.kind === 'vision_analysis') {
+        if (!options.reenterPipeline)
+            return undefined;
+        return await executeVisionBackendPlan({ plan, options });
+    }
+    if (plan.kind === 'web_search') {
+        return await executeWebSearchBackendPlan({ plan, options });
+    }
+    return undefined;
+}
 export function extractToolCalls(chatResponse) {
     const choices = getArray(chatResponse.choices);
     const calls = [];
@@ -89,9 +121,31 @@ export function extractToolCalls(chatResponse) {
             if (!tc)
                 continue;
             const id = typeof tc.id === 'string' && tc.id.trim() ? tc.id.trim() : '';
-            const fn = asObject(tc.function);
+            const fn = asObject(tc.function) ??
+                asObject(tc.functionCall) ??
+                asObject(tc.function_call);
             const name = fn && typeof fn.name === 'string' && fn.name.trim() ? fn.name.trim() : '';
-            const args = fn && typeof fn.arguments === 'string' ? fn.arguments : '';
+            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;
             calls.push({ id, name, arguments: args });

package/dist/servertool/types.d.ts

@@ -49,11 +49,94 @@ export interface ServerSideToolEngineOptions {
         format?: string;
     }>;
 }
-export interface ServerToolFollowupPlan {
+export type ServerToolFollowupInjectionOp = {
+    op: 'append_assistant_message';
+    required?: boolean;
+} | {
+    op: 'append_tool_messages_from_tool_outputs';
+    required?: boolean;
+} | {
+    op: 'inject_system_text';
+    text: string;
+} | {
+    op: 'append_user_text';
+    text: string;
+} | {
+    op: 'drop_tool_by_name';
+    name: string;
+} | {
+    op: 'inject_vision_summary';
+    summary: string;
+} | {
+    op: 'trim_openai_messages';
+    maxNonSystemMessages: number;
+};
+export type ServerToolFollowupInjectionPlan = {
+    ops: ServerToolFollowupInjectionOp[];
+};
+export type ServerToolFollowupPlan = {
     requestIdSuffix: string;
     payload: JsonObject;
     metadata?: JsonObject;
     entryEndpoint?: string;
+} | {
+    requestIdSuffix: string;
+    injection: ServerToolFollowupInjectionPlan;
+    metadata?: JsonObject;
+    entryEndpoint?: string;
+};
+export type ServerToolBackendPlan = {
+    kind: 'vision_analysis';
+    requestIdSuffix: string;
+    entryEndpoint: string;
+    payload: JsonObject;
+} | {
+    kind: 'web_search';
+    requestIdSuffix: string;
+    query: string;
+    recency?: string;
+    resultCount: number;
+    engines: {
+        id: string;
+        providerKey: string;
+        description?: string;
+        default?: boolean;
+        serverToolsDisabled?: boolean;
+        searchEngineList?: string[];
+    }[];
+};
+export type ServerToolBackendResult = {
+    kind: 'vision_analysis';
+    response: {
+        body?: JsonObject;
+        __sse_responses?: unknown;
+        format?: string;
+    };
+} | {
+    kind: 'web_search';
+    chosenEngine?: {
+        id: string;
+        providerKey: string;
+    };
+    result: {
+        ok: boolean;
+        summary: string;
+        hits: {
+            title?: string;
+            link: string;
+            media?: string;
+            publish_date?: string;
+            content?: string;
+            refer?: string;
+        }[];
+    };
+};
+export interface ServerToolHandlerPlan {
+    flowId: string;
+    backend?: ServerToolBackendPlan;
+    finalize: (args: {
+        backendResult?: ServerToolBackendResult;
+    }) => Promise<ServerToolHandlerResult | null>;
 }
 export interface ServerToolExecution {
     flowId: string;
@@ -81,7 +164,13 @@ export interface ServerToolHandlerContext {
     toolCall?: ToolCall;
     toolCalls: ToolCall[];
     adapterContext: AdapterContext;
-    options: ServerSideToolEngineOptions;
+    requestId: string;
+    entryEndpoint: string;
+    providerProtocol: string;
+    capabilities: {
+        reenterPipeline: boolean;
+        providerInvoker: boolean;
+    };
 }
 export interface ServerToolHandlerResult {
     chatResponse: JsonObject;
@@ -91,5 +180,5 @@ export interface ServerToolHandlerResult {
  * ServerToolHandler：统一的 ServerTool handler 接口。
  * 后续 web_search / vision / 其它工具都会以 handler 形式挂载到注册表。
  */
-export type ServerToolHandler = (ctx: ServerToolHandlerContext) => Promise<ServerToolHandlerResult | null>;
+export type ServerToolHandler = (ctx: ServerToolHandlerContext) => Promise<ServerToolHandlerPlan | null>;
 export type { JsonObject, JsonValue } from '../conversion/hub/types/json.js';

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

@@ -512,30 +512,12 @@ export function buildReasoningDoneEvent(reasoning, context, config = DEFAULT_RES
  */
 export function buildOutputItemDoneEvent(outputItem, context, config = DEFAULT_RESPONSES_EVENT_GENERATOR_CONFIG) {
     const baseEvent = createBaseEvent(context, config);
+    // NOTE: Codex CLI expects `output_item.done` to contain a fully-formed output item
+    // (e.g. message includes role/content). A minimal `{id,type,status}` breaks parsing.
     const itemDescriptor = {
-        id: outputItem.id,
-        type: outputItem.type,
+        ...outputItem,
         status: 'completed'
     };
-    if (outputItem.name) {
-        itemDescriptor.name = outputItem.name;
-    }
-    if (outputItem.arguments) {
-        itemDescriptor.arguments = outputItem.arguments;
-    }
-    if (outputItem.call_id) {
-        itemDescriptor.call_id = outputItem.call_id;
-    }
-    if (outputItem.type === 'function_call_output') {
-        const result = outputItem;
-        if (result.call_id) {
-            itemDescriptor.call_id = result.call_id;
-        }
-        if (result.tool_call_id) {
-            itemDescriptor.tool_call_id = result.tool_call_id;
-        }
-        itemDescriptor.output = result.output;
-    }
     return {
         type: 'response.output_item.done',
         timestamp: baseEvent.timestamp,

package/dist/sse/shared/serializers/responses-event-serializer.d.ts

@@ -55,6 +55,14 @@ export declare class ResponsesEventSerializer implements EventSerializer<Respons
      * 序列化response.output_item.done事件
      */
     private serializeOutputItemDone;
+    /**
+     * 序列化response.output_text.delta事件
+     */
+    private serializeOutputTextDelta;
+    /**
+     * 序列化response.output_text.done事件
+     */
+    private serializeOutputTextDone;
     /**
      * 序列化response.function_call_arguments.delta事件
      */

package/dist/sse/shared/serializers/responses-event-serializer.js

@@ -28,6 +28,10 @@ export class ResponsesEventSerializer {
                 return this.serializeOutputItemAdded(event);
             case 'response.output_item.done':
                 return this.serializeOutputItemDone(event);
+            case 'response.output_text.delta':
+                return this.serializeOutputTextDelta(event);
+            case 'response.output_text.done':
+                return this.serializeOutputTextDone(event);
             case 'response.function_call_arguments.delta':
                 return this.serializeFunctionCallArgumentsDelta(event);
             case 'response.function_call_arguments.done':
@@ -43,6 +47,9 @@ export class ResponsesEventSerializer {
             case 'response.cancelled':
                 return this.serializeResponseCancelled(event);
             default:
+                if (typeof event.type === 'string' && event.type.startsWith('response.')) {
+                    return this.buildSSEEvent(event.type, event.data, event.timestamp, event.sequenceNumber);
+                }
                 throw new Error(`Unsupported ResponsesSseEvent type: ${event.type}`);
         }
     }
@@ -159,6 +166,18 @@ export class ResponsesEventSerializer {
     serializeOutputItemDone(event) {
         return this.buildSSEEvent('response.output_item.done', event.data, event.timestamp, event.sequenceNumber);
     }
+    /**
+     * 序列化response.output_text.delta事件
+     */
+    serializeOutputTextDelta(event) {
+        return this.buildSSEEvent('response.output_text.delta', event.data, event.timestamp, event.sequenceNumber);
+    }
+    /**
+     * 序列化response.output_text.done事件
+     */
+    serializeOutputTextDone(event) {
+        return this.buildSSEEvent('response.output_text.done', event.data, event.timestamp, event.sequenceNumber);
+    }
     /**
      * 序列化response.function_call_arguments.delta事件
      */

package/dist/sse/shared/writer.js

@@ -156,14 +156,31 @@ export class StreamWriter {
         catch {
             // ignore and fallback
         }
+        const eventType = String(event.type ?? 'response.unknown');
         const rawData = event.data;
-        const dataPayload = typeof rawData === 'string'
-            ? rawData
-            : JSON.stringify({
-                type: event.type,
-                ...(rawData ?? {})
-            });
-        return `event: ${event.type}\ndata: ${dataPayload}\n\n`;
+        const timestamp = typeof event.timestamp === 'number' ? event.timestamp : undefined;
+        const sequenceNumber = typeof event.sequenceNumber === 'number' ? event.sequenceNumber : undefined;
+        let wire = `event: ${eventType}\n`;
+        if (rawData === '[DONE]') {
+            wire += 'data: [DONE]\n';
+        }
+        else if (typeof rawData === 'string') {
+            wire += `data: ${rawData}\n`;
+        }
+        else {
+            const payload = rawData && typeof rawData === 'object' ? { ...rawData } : {};
+            if (!Object.prototype.hasOwnProperty.call(payload, 'type'))
+                payload.type = eventType;
+            if (sequenceNumber !== undefined && !Object.prototype.hasOwnProperty.call(payload, 'sequence_number')) {
+                payload.sequence_number = sequenceNumber;
+            }
+            wire += `data: ${JSON.stringify(payload)}\n`;
+        }
+        if (timestamp !== undefined) {
+            wire += `id: ${timestamp}\n`;
+        }
+        wire += '\n';
+        return wire;
     }
     /**
      * 异步写入事件流

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

@@ -112,6 +112,8 @@ export function captureApplyPatchExecutionFailuresFromProcessedRequest(processed
         const entryEndpoint = typeof metadata?.originalEndpoint === 'string' ? metadata.originalEndpoint : undefined;
         const providerKey = typeof metadata?.providerKey === 'string' ? metadata.providerKey : undefined;
         const model = typeof anyReq?.model === 'string' ? anyReq.model : undefined;
+        const applyPatchToolMode = typeof metadata?.applyPatchToolMode === 'string' ? String(metadata.applyPatchToolMode).trim().toLowerCase() : '';
+        const resolvedMode = applyPatchToolMode === 'schema' ? 'schema' : 'freeform';
         const toolCallArgsById = new Map();
         for (const msg of messages) {
             if (!msg || typeof msg !== 'object')
@@ -146,7 +148,7 @@ export function captureApplyPatchExecutionFailuresFromProcessedRequest(processed
                 providerKey,
                 model,
                 source: 'req_process_stage1_tool_governance',
-                meta: { applyPatchToolMode: 'freeform' },
+                meta: { applyPatchToolMode: resolvedMode },
                 toolCallId,
                 toolCallArgs
             });

package/dist/tools/apply-patch/json/parse-loose.d.ts

@@ -0,0 +1,3 @@
+declare const tryParseJson: (value: unknown) => unknown;
+declare const tryParseJsonLoose: (value: unknown) => unknown;
+export { tryParseJson, tryParseJsonLoose };

package/dist/tools/apply-patch/json/parse-loose.js

@@ -0,0 +1,139 @@
+const tryParseJson = (value) => {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return undefined;
+    if (!(trimmed.startsWith('{') || trimmed.startsWith('[')))
+        return undefined;
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return undefined;
+    }
+};
+const escapeUnescapedQuotesInJsonStrings = (input) => {
+    // Best-effort: when JSON is almost valid but contains unescaped `"` inside string values
+    // (e.g. JSX snippets like className="..."), escape quotes that are not followed by a
+    // valid JSON token delimiter. Deterministic; does not attempt to fix structural issues.
+    let out = '';
+    let inString = false;
+    let escaped = false;
+    for (let i = 0; i < input.length; i += 1) {
+        const ch = input[i] ?? '';
+        if (!inString) {
+            if (ch === '"') {
+                inString = true;
+                escaped = false;
+            }
+            out += ch;
+            continue;
+        }
+        if (escaped) {
+            out += ch;
+            escaped = false;
+            continue;
+        }
+        if (ch === '\\') {
+            out += ch;
+            escaped = true;
+            continue;
+        }
+        if (ch === '"') {
+            let j = i + 1;
+            while (j < input.length && /\s/.test(input[j] ?? ''))
+                j += 1;
+            const next = j < input.length ? input[j] : '';
+            if (next === '' || next === ':' || next === ',' || next === '}' || next === ']') {
+                inString = false;
+                out += ch;
+            }
+            else {
+                out += '\\"';
+            }
+            continue;
+        }
+        out += ch;
+    }
+    return out;
+};
+const balanceJsonContainers = (input) => {
+    // Best-effort bracket/brace balancing for JSON-like strings.
+    // Only operates outside string literals. When encountering a closing token that doesn't
+    // match the current stack top, inserts the missing closer(s) to recover.
+    let out = '';
+    let inString = false;
+    let escaped = false;
+    const stack = [];
+    const closeFor = (open) => (open === '{' ? '}' : ']');
+    for (let i = 0; i < input.length; i += 1) {
+        const ch = input[i] ?? '';
+        if (inString) {
+            out += ch;
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (ch === '\\') {
+                escaped = true;
+                continue;
+            }
+            if (ch === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+            out += ch;
+            continue;
+        }
+        if (ch === '{' || ch === '[') {
+            stack.push(ch);
+            out += ch;
+            continue;
+        }
+        if (ch === '}' || ch === ']') {
+            const expectedOpen = ch === '}' ? '{' : '[';
+            while (stack.length && stack[stack.length - 1] !== expectedOpen) {
+                const open = stack.pop();
+                out += closeFor(open);
+            }
+            if (stack.length && stack[stack.length - 1] === expectedOpen) {
+                stack.pop();
+            }
+            out += ch;
+            continue;
+        }
+        out += ch;
+    }
+    while (stack.length) {
+        const open = stack.pop();
+        out += closeFor(open);
+    }
+    return out;
+};
+const tryParseJsonLoose = (value) => {
+    const parsed = tryParseJson(value);
+    if (parsed !== undefined)
+        return parsed;
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return undefined;
+    if (!(trimmed.startsWith('{') || trimmed.startsWith('[')))
+        return undefined;
+    let repaired = escapeUnescapedQuotesInJsonStrings(trimmed);
+    repaired = balanceJsonContainers(repaired);
+    if (!repaired || repaired === trimmed)
+        return undefined;
+    try {
+        return JSON.parse(repaired);
+    }
+    catch {
+        return undefined;
+    }
+};
+export { tryParseJson, tryParseJsonLoose };

package/dist/tools/apply-patch/patch-text/context-diff.d.ts

@@ -0,0 +1 @@
+export declare const convertContextDiffToApplyPatch: (text: string) => string | null;