@jsonstudio/llms 0.6.2172 → 0.6.3214

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

@@ -1,5 +1,5 @@
 import { getServerToolHandler, listAutoServerToolHooks } from './registry.js';
-import { ProviderProtocolError } from '../conversion/shared/errors.js';
+import { ProviderProtocolError } from '../conversion/provider-protocol-error.js';
 import { executeWebSearchBackendPlan } from './handlers/web-search.js';
 import { executeVisionBackendPlan } from './handlers/vision.js';
 import './handlers/iflow-model-error-retry.js';
@@ -11,8 +11,9 @@ import './handlers/clock-auto.js';
 import './handlers/exec-command-guard.js';
 import './handlers/apply-patch-guard.js';
 import './handlers/continue-execution.js';
+import './handlers/review.js';
 import { runPreCommandHooks } from './pre-command-hooks.js';
-import { readRuntimeMetadata } from '../conversion/shared/runtime-metadata.js';
+import { readRuntimeMetadata } from '../conversion/runtime-metadata.js';
 function traceAutoHook(options, event) {
     try {
         options.onAutoHookTrace?.(event);
@@ -21,7 +22,7 @@ function traceAutoHook(options, event) {
         // best-effort trace callback
     }
 }
-const OPTIONAL_PRIMARY_HOOK_ORDER = ['empty_reply_continue', 'stop_message_auto', 'clock_auto'];
+const OPTIONAL_PRIMARY_HOOK_ORDER = ['empty_reply_continue', 'clock_auto', 'stop_message_auto'];
 const MANDATORY_HOOK_ORDER = [];
 let fallbackToolCallIdSeq = 0;
 function ensureToolCallId(record) {
@@ -81,6 +82,33 @@ function buildAutoHookQueues(hooks) {
     }
     return { optionalQueue, mandatoryQueue };
 }
+function normalizeFilterTokenSet(values) {
+    if (!Array.isArray(values) || values.length === 0) {
+        return null;
+    }
+    const normalized = new Set();
+    for (const raw of values) {
+        if (typeof raw !== 'string') {
+            continue;
+        }
+        const value = raw.trim().toLowerCase();
+        if (!value) {
+            continue;
+        }
+        normalized.add(value);
+    }
+    return normalized.size > 0 ? normalized : null;
+}
+function isNameIncluded(name, includeSet, excludeSet) {
+    const normalized = name.trim().toLowerCase();
+    if (includeSet && !includeSet.has(normalized)) {
+        return false;
+    }
+    if (excludeSet && excludeSet.has(normalized)) {
+        return false;
+    }
+    return true;
+}
 function extractToolCallsFromMessage(message) {
     const toolCalls = getArray(message.tool_calls);
     const out = [];
@@ -259,6 +287,10 @@ export async function runServerSideToolEngine(options) {
             providerInvoker: typeof options.providerInvoker === 'function'
         }
     };
+    const includeToolCallNames = normalizeFilterTokenSet(options.includeToolCallHandlerNames);
+    const excludeToolCallNames = normalizeFilterTokenSet(options.excludeToolCallHandlerNames);
+    const includeAutoHookIds = normalizeFilterTokenSet(options.includeAutoHookIds);
+    const excludeAutoHookIds = normalizeFilterTokenSet(options.excludeAutoHookIds);
     // 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
@@ -282,59 +314,64 @@ export async function runServerSideToolEngine(options) {
             continue;
         attemptedToolCallsByMessage.push(...extractToolCallsFromMessage(message));
     }
-    for (const { parsed: toolCall } of attemptedToolCallsByMessage) {
-        const preHookResult = runPreCommandHooks({
-            requestId: options.requestId,
-            entryEndpoint: options.entryEndpoint,
-            providerProtocol: options.providerProtocol,
-            toolName: toolCall.name,
-            toolCallId: toolCall.id,
-            toolArguments: toolCall.arguments,
-            preCommandState: runtimePreCommandState
-        });
-        for (const trace of preHookResult.traces) {
-            traceAutoHook(options, trace);
-        }
-        if (preHookResult.changed && preHookResult.toolArguments !== toolCall.arguments) {
-            toolCall.arguments = preHookResult.toolArguments;
-            patchToolCallArgumentsById(base, toolCall.id, preHookResult.toolArguments);
-            patchToolCallArgumentsById(baseForExecution, toolCall.id, preHookResult.toolArguments);
-        }
-        const entry = getServerToolHandler(toolCall.name);
-        if (!entry || entry.trigger !== 'tool_call') {
-            continue;
-        }
-        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;
+    if (options.disableToolCallHandlers !== true) {
+        for (const { parsed: toolCall } of attemptedToolCallsByMessage) {
+            if (!isNameIncluded(toolCall.name, includeToolCallNames, excludeToolCallNames)) {
+                continue;
             }
-            catch (err) {
-                lastErr = err;
+            const preHookResult = runPreCommandHooks({
+                requestId: options.requestId,
+                entryEndpoint: options.entryEndpoint,
+                providerProtocol: options.providerProtocol,
+                toolName: toolCall.name,
+                toolCallId: toolCall.id,
+                toolArguments: toolCall.arguments,
+                preCommandState: runtimePreCommandState
+            });
+            for (const trace of preHookResult.traces) {
+                traceAutoHook(options, trace);
             }
-        }
-        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());
+            if (preHookResult.changed && preHookResult.toolArguments !== toolCall.arguments) {
+                toolCall.arguments = preHookResult.toolArguments;
+                patchToolCallArgumentsById(base, toolCall.id, preHookResult.toolArguments);
+                patchToolCallArgumentsById(baseForExecution, toolCall.id, preHookResult.toolArguments);
+            }
+            const entry = getServerToolHandler(toolCall.name);
+            if (!entry || entry.trigger !== 'tool_call') {
+                continue;
+            }
+            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`);
             }
-            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) {
@@ -409,7 +446,8 @@ export async function runServerSideToolEngine(options) {
         };
     }
     const autoHookExecutionList = listAutoServerToolHooks();
-    const { optionalQueue, mandatoryQueue } = buildAutoHookQueues(autoHookExecutionList);
+    const filteredAutoHooks = autoHookExecutionList.filter((hook) => isNameIncluded(hook.id, includeAutoHookIds, excludeAutoHookIds));
+    const { optionalQueue, mandatoryQueue } = buildAutoHookQueues(filteredAutoHooks);
     const optionalResult = await runAutoHookQueue({
         queueName: 'A_optional',
         hooks: optionalQueue,

package/dist/servertool/stop-gateway-context.js

@@ -1,4 +1,4 @@
-import { ensureRuntimeMetadata, readRuntimeMetadata } from '../conversion/shared/runtime-metadata.js';
+import { ensureRuntimeMetadata, readRuntimeMetadata } from '../conversion/runtime-metadata.js';
 export function inspectStopGatewaySignal(base) {
     if (!base || typeof base !== 'object' || Array.isArray(base)) {
         return {

package/dist/servertool/stop-message-compare-context.js

@@ -1,4 +1,4 @@
-import { ensureRuntimeMetadata, readRuntimeMetadata } from '../conversion/shared/runtime-metadata.js';
+import { ensureRuntimeMetadata, readRuntimeMetadata } from '../conversion/runtime-metadata.js';
 const STOP_MESSAGE_COMPARE_KEY = 'stopMessageCompareContext';
 export function attachStopMessageCompareContext(adapterContext, context) {
     if (!adapterContext || typeof adapterContext !== 'object' || Array.isArray(adapterContext)) {

package/dist/servertool/types.d.ts

@@ -48,6 +48,11 @@ export interface ServerSideToolEngineOptions {
     entryEndpoint: string;
     requestId: string;
     providerProtocol: string;
+    disableToolCallHandlers?: boolean;
+    includeAutoHookIds?: string[];
+    excludeAutoHookIds?: string[];
+    includeToolCallHandlerNames?: string[];
+    excludeToolCallHandlerNames?: string[];
     providerInvoker?: ProviderInvoker;
     reenterPipeline?: (options: {
         entryEndpoint: string;
@@ -59,6 +64,15 @@ export interface ServerSideToolEngineOptions {
         __sse_responses?: unknown;
         format?: string;
     }>;
+    clientInjectDispatch?: (options: {
+        entryEndpoint: string;
+        requestId: string;
+        body?: JsonObject;
+        metadata?: JsonObject;
+    }) => Promise<{
+        ok: boolean;
+        reason?: string;
+    }>;
     onAutoHookTrace?: (event: ServerToolAutoHookTraceEvent) => void;
 }
 export type ServerToolFollowupInjectionOp = {
@@ -103,6 +117,9 @@ export type ServerToolFollowupPlan = {
     injection: ServerToolFollowupInjectionPlan;
     metadata?: JsonObject;
     entryEndpoint?: string;
+} | {
+    requestIdSuffix: string;
+    metadata?: JsonObject;
 };
 export type ServerToolBackendPlan = {
     kind: 'vision_analysis';

package/dist/sse/json-to-sse/event-generators/responses.d.ts

@@ -72,6 +72,10 @@ export declare function buildReasoningStartEvent(reasoning: ResponsesReasoningIt
  * 映射：reasoning.delta → response.reasoning_text.delta
  */
 export declare function buildReasoningDeltas(reasoning: ResponsesReasoningItem, context: ResponsesEventGeneratorContext, config?: ResponsesEventGeneratorConfig): Generator<ResponsesSseEvent>;
+/**
+ * 构建response.reasoning_summary_*事件流
+ */
+export declare function buildReasoningSummaryEvents(reasoning: ResponsesReasoningItem, context: ResponsesEventGeneratorContext, config?: ResponsesEventGeneratorConfig): Generator<ResponsesSseEvent>;
 /**
  * 构建reasoning.done事件
  */

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

@@ -29,6 +29,24 @@ function chunkText(text, config) {
         return [text];
     }
 }
+function normalizeReasoningSummaryEntries(summary) {
+    if (!Array.isArray(summary))
+        return [];
+    const entries = [];
+    for (const entry of summary) {
+        if (typeof entry === 'string') {
+            if (entry.length)
+                entries.push(entry);
+            continue;
+        }
+        if (entry && typeof entry === 'object') {
+            const text = typeof entry.text === 'string' ? entry.text : '';
+            if (text.length)
+                entries.push(text);
+        }
+    }
+    return entries;
+}
 function createResponsePayload(response, overrides = {}) {
     const raw = response;
     const usage = normalizeUsage(response.usage);
@@ -213,6 +231,9 @@ export function buildOutputItemStartEvent(outputItem, context, config = DEFAULT_
         if (reasoning.summary) {
             itemDescriptor.summary = reasoning.summary;
         }
+        if (typeof reasoning.encrypted_content === 'string' && reasoning.encrypted_content.length) {
+            itemDescriptor.encrypted_content = reasoning.encrypted_content;
+        }
     }
     return {
         type: 'response.output_item.added',
@@ -441,7 +462,8 @@ export function buildReasoningStartEvent(reasoning, context, config = DEFAULT_RE
  * 映射：reasoning.delta → response.reasoning_text.delta
  */
 export function* buildReasoningDeltas(reasoning, context, config = DEFAULT_RESPONSES_EVENT_GENERATOR_CONFIG) {
-    for (const content of reasoning.content) {
+    const contents = Array.isArray(reasoning.content) ? reasoning.content : [];
+    for (const content of contents) {
         if (content.type === 'reasoning_text') {
             if (!content.text)
                 continue;
@@ -491,6 +513,78 @@ export function* buildReasoningDeltas(reasoning, context, config = DEFAULT_RESPO
         }
     }
 }
+/**
+ * 构建response.reasoning_summary_*事件流
+ */
+export function* buildReasoningSummaryEvents(reasoning, context, config = DEFAULT_RESPONSES_EVENT_GENERATOR_CONFIG) {
+    const summaries = normalizeReasoningSummaryEntries(reasoning.summary);
+    for (let summaryIndex = 0; summaryIndex < summaries.length; summaryIndex++) {
+        const text = summaries[summaryIndex];
+        if (!text)
+            continue;
+        const partAddedBase = createBaseEvent(context, config);
+        yield {
+            type: 'response.reasoning_summary_part.added',
+            timestamp: partAddedBase.timestamp,
+            protocol: partAddedBase.protocol,
+            direction: partAddedBase.direction,
+            data: {
+                output_index: context.outputIndexCounter,
+                item_id: reasoning.id,
+                summary_index: summaryIndex,
+                part: { type: 'summary_text', text: '' }
+            },
+            sequenceNumber: partAddedBase.sequenceNumber
+        };
+        const chunks = chunkText(text, config);
+        for (const chunk of chunks) {
+            if (!chunk)
+                continue;
+            const deltaBase = createBaseEvent(context, config);
+            yield {
+                type: 'response.reasoning_summary_text.delta',
+                timestamp: deltaBase.timestamp,
+                protocol: deltaBase.protocol,
+                direction: deltaBase.direction,
+                data: {
+                    output_index: context.outputIndexCounter,
+                    item_id: reasoning.id,
+                    summary_index: summaryIndex,
+                    delta: chunk
+                },
+                sequenceNumber: deltaBase.sequenceNumber
+            };
+        }
+        const textDoneBase = createBaseEvent(context, config);
+        yield {
+            type: 'response.reasoning_summary_text.done',
+            timestamp: textDoneBase.timestamp,
+            protocol: textDoneBase.protocol,
+            direction: textDoneBase.direction,
+            data: {
+                output_index: context.outputIndexCounter,
+                item_id: reasoning.id,
+                summary_index: summaryIndex,
+                text
+            },
+            sequenceNumber: textDoneBase.sequenceNumber
+        };
+        const partDoneBase = createBaseEvent(context, config);
+        yield {
+            type: 'response.reasoning_summary_part.done',
+            timestamp: partDoneBase.timestamp,
+            protocol: partDoneBase.protocol,
+            direction: partDoneBase.direction,
+            data: {
+                output_index: context.outputIndexCounter,
+                item_id: reasoning.id,
+                summary_index: summaryIndex,
+                part: { type: 'summary_text', text }
+            },
+            sequenceNumber: partDoneBase.sequenceNumber
+        };
+    }
+}
 /**
  * 构建reasoning.done事件
  */

package/dist/sse/json-to-sse/sequencers/responses-sequencer.js

@@ -2,7 +2,7 @@
  * Responses协议事件编排器
  * 负责将Responses响应数据转换为有序的SSE事件流
  */
-import { buildResponseStartEvents, buildResponseDoneEvent, buildOutputItemStartEvent, buildOutputItemDoneEvent, buildContentPartStartEvent, buildContentPartDeltas, buildContentPartDoneEvent, buildOutputTextDoneEvent, buildFunctionCallArgsDeltas, buildFunctionCallDoneEvent, buildReasoningStartEvent, buildReasoningDeltas, buildReasoningDoneEvent, buildRequiredActionEvent, buildResponseCompletedEvent, buildErrorEvent, DEFAULT_RESPONSES_EVENT_GENERATOR_CONFIG, createDefaultResponsesContext } from '../event-generators/responses.js';
+import { buildResponseStartEvents, buildResponseDoneEvent, buildOutputItemStartEvent, buildOutputItemDoneEvent, buildContentPartStartEvent, buildContentPartDeltas, buildContentPartDoneEvent, buildOutputTextDoneEvent, buildFunctionCallArgsDeltas, buildFunctionCallDoneEvent, buildReasoningStartEvent, buildReasoningSummaryEvents, buildReasoningDeltas, buildReasoningDoneEvent, buildRequiredActionEvent, buildResponseCompletedEvent, buildErrorEvent, DEFAULT_RESPONSES_EVENT_GENERATOR_CONFIG, createDefaultResponsesContext } from '../event-generators/responses.js';
 import { expandResponsesMessageItem } from '../../shared/responses-output-normalizer.js';
 // 默认配置
 export const DEFAULT_RESPONSES_SEQUENCER_CONFIG = {
@@ -120,11 +120,13 @@ async function* sequenceReasoningItem(item, context, config) {
     yield buildOutputItemStartEvent(item, context, config);
     // 2. 发送reasoning.start事件
     yield buildReasoningStartEvent(item, context, config);
-    // 3. 发送reasoning.delta事件流
+    // 3. 发送reasoning_summary事件流
+    yield* withDelay(buildReasoningSummaryEvents(item, context, config), config);
+    // 4. 发送reasoning.delta事件流
     yield* withDelay(buildReasoningDeltas(item, context, config), config);
-    // 4. 发送reasoning.done事件
+    // 5. 发送reasoning.done事件
     yield buildReasoningDoneEvent(item, context, config);
-    // 5. 发送output_item.done事件
+    // 6. 发送output_item.done事件
     yield buildOutputItemDoneEvent(item, context, config);
 }
 /**

package/dist/sse/sse-to-json/builders/response-builder.d.ts

@@ -18,12 +18,15 @@ export interface OutputItemState {
     contentParts: any[];
     currentContentIndex: number;
     accumulatedContent: any[];
+    summaryByIndex: Map<number, string>;
+    currentSummaryIndex: number;
     hasContentPartAdded: boolean;
     isTextInProgress: boolean;
     callId?: string;
     name?: string;
     arguments?: string;
     role?: string;
+    encryptedContent?: string;
     startTime: number;
     lastEventTime: number;
 }
@@ -58,6 +61,7 @@ export declare class ResponsesResponseBuilder {
      */
     private handleOutputItemStart;
     private mapOutputItemAdded;
+    private mapOutputItemDone;
     /**
      * 处理content_part.start事件
      */
@@ -97,6 +101,10 @@ export declare class ResponsesResponseBuilder {
      * 处理reasoning.delta事件
      */
     private handleReasoningDelta;
+    private handleReasoningSummaryDelta;
+    private handleReasoningSummaryDone;
+    private handleReasoningSummaryPartAdded;
+    private handleReasoningSummaryPartDone;
     private mapReasoningDelta;
     private mapReasoningDone;
     /**