@jsonstudio/llms 0.6.567 → 0.6.586

package/dist/conversion/hub/semantic-mappers/responses-mapper.js

@@ -19,6 +19,7 @@ const RESPONSES_PARAMETER_KEYS = [
     'stop_sequences',
     'modalities'
 ];
+const RESPONSES_SUBMIT_ENDPOINT = '/v1/responses.submit_tool_outputs';
 function mapToolOutputs(entries, missing) {
     if (!entries || !entries.length)
         return undefined;
@@ -53,6 +54,41 @@ function mapToolOutputs(entries, missing) {
     });
     return outputs.length ? outputs : undefined;
 }
+function deriveResumeToolOutputs(ctx) {
+    if (!ctx || typeof ctx !== 'object') {
+        return undefined;
+    }
+    const resume = ctx.responsesResume;
+    if (!resume || typeof resume !== 'object') {
+        return undefined;
+    }
+    const detailed = Array.isArray(resume.toolOutputsDetailed)
+        ? resume.toolOutputsDetailed
+        : undefined;
+    if (!detailed || detailed.length === 0) {
+        return undefined;
+    }
+    const outputs = [];
+    detailed.forEach((entry, index) => {
+        if (!entry || typeof entry !== 'object') {
+            return;
+        }
+        const callIdRaw = typeof entry.callId === 'string' && entry.callId.trim().length
+            ? entry.callId.trim()
+            : typeof entry.originalId === 'string' && entry.originalId.trim().length
+                ? entry.originalId.trim()
+                : `resume_tool_${index}`;
+        if (!callIdRaw) {
+            return;
+        }
+        const outputText = typeof entry.outputText === 'string' ? entry.outputText : '';
+        outputs.push({
+            tool_call_id: callIdRaw,
+            content: outputText
+        });
+    });
+    return outputs.length ? outputs : undefined;
+}
 function collectParameters(payload, streamHint) {
     const params = {};
     for (const key of RESPONSES_PARAMETER_KEYS) {
@@ -162,6 +198,198 @@ function mergeMetadata(a, b) {
     const right = jsonClone(b);
     return { ...left, ...right };
 }
+function isSubmitToolOutputsEndpoint(ctx) {
+    if (!ctx || typeof ctx !== 'object') {
+        return false;
+    }
+    const entry = typeof ctx.entryEndpoint === 'string' ? ctx.entryEndpoint.trim().toLowerCase() : '';
+    return entry === RESPONSES_SUBMIT_ENDPOINT;
+}
+function resolveSubmitResponseId(ctx, responsesContext) {
+    const resumeMeta = ctx.responsesResume && typeof ctx.responsesResume === 'object'
+        ? ctx.responsesResume
+        : undefined;
+    const resumeId = typeof resumeMeta?.restoredFromResponseId === 'string'
+        ? resumeMeta.restoredFromResponseId.trim()
+        : undefined;
+    if (resumeId) {
+        return resumeId;
+    }
+    const contextRecord = responsesContext && typeof responsesContext === 'object'
+        ? responsesContext
+        : undefined;
+    const previousId = typeof contextRecord?.previous_response_id === 'string'
+        ? contextRecord.previous_response_id.trim()
+        : undefined;
+    if (previousId) {
+        return previousId;
+    }
+    return undefined;
+}
+function extractSubmitMetadata(responsesContext, resumeMeta) {
+    if (responsesContext && responsesContext.metadata && isJsonObject(responsesContext.metadata)) {
+        return jsonClone(responsesContext.metadata);
+    }
+    if (resumeMeta && resumeMeta.metadata && isJsonObject(resumeMeta.metadata)) {
+        return jsonClone(resumeMeta.metadata);
+    }
+    return undefined;
+}
+function coerceOutputText(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (value === undefined || value === null) {
+        return '';
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function extractCapturedToolOutputs(responsesContext) {
+    if (!responsesContext || typeof responsesContext !== 'object') {
+        return [];
+    }
+    const snapshot = responsesContext.__captured_tool_results;
+    if (!Array.isArray(snapshot) || !snapshot.length) {
+        return [];
+    }
+    const entries = [];
+    snapshot.forEach((entry) => {
+        if (!entry || typeof entry !== 'object') {
+            return;
+        }
+        const record = entry;
+        const toolId = typeof record.tool_call_id === 'string' && record.tool_call_id.trim().length
+            ? record.tool_call_id.trim()
+            : typeof record.call_id === 'string' && record.call_id.trim().length
+                ? record.call_id.trim()
+                : undefined;
+        if (!toolId) {
+            return;
+        }
+        entries.push({
+            tool_call_id: toolId,
+            id: toolId,
+            output: typeof record.output === 'string' ? record.output : coerceOutputText(record.output),
+            name: typeof record.name === 'string' ? record.name : undefined
+        });
+    });
+    return entries;
+}
+function collectSubmitToolOutputs(chat, ctx, responsesContext) {
+    const outputs = [];
+    const seen = new Set();
+    const append = (idSeed, outputSeed, name) => {
+        const trimmed = typeof idSeed === 'string' && idSeed.trim().length ? idSeed.trim() : '';
+        const fallbackId = trimmed || `submit_tool_${outputs.length + 1}`;
+        if (seen.has(fallbackId)) {
+            return;
+        }
+        seen.add(fallbackId);
+        outputs.push({
+            tool_call_id: fallbackId,
+            id: fallbackId,
+            output: coerceOutputText(outputSeed),
+            name
+        });
+    };
+    if (Array.isArray(chat.toolOutputs) && chat.toolOutputs.length) {
+        chat.toolOutputs.forEach((entry) => {
+            append(entry.tool_call_id ?? entry.call_id, entry.content, entry.name);
+        });
+    }
+    if (!outputs.length) {
+        const captured = extractCapturedToolOutputs(responsesContext);
+        captured.forEach((entry) => append(entry.tool_call_id ?? entry.id, entry.output, entry.name));
+    }
+    if (!outputs.length) {
+        const resume = ctx.responsesResume && typeof ctx.responsesResume === 'object'
+            ? ctx.responsesResume
+            : undefined;
+        const detailed = Array.isArray(resume?.toolOutputsDetailed)
+            ? resume?.toolOutputsDetailed
+            : undefined;
+        if (detailed) {
+            detailed.forEach((entry, index) => {
+                if (!entry || typeof entry !== 'object') {
+                    return;
+                }
+                const callId = typeof entry.callId === 'string' && entry.callId.trim().length
+                    ? entry.callId.trim()
+                    : typeof entry.originalId === 'string' && entry.originalId.trim().length
+                        ? entry.originalId.trim()
+                        : `resume_tool_${index + 1}`;
+                append(callId, typeof entry.outputText === 'string' ? entry.outputText : entry.outputText ?? '');
+            });
+        }
+    }
+    return outputs;
+}
+function resolveSubmitStreamFlag(chat, ctx, responsesContext) {
+    if (chat.parameters && typeof chat.parameters.stream === 'boolean') {
+        return chat.parameters.stream;
+    }
+    if (responsesContext && typeof responsesContext.stream === 'boolean') {
+        return responsesContext.stream;
+    }
+    if (ctx.streamingHint === 'force') {
+        return true;
+    }
+    if (ctx.streamingHint === 'disable') {
+        return false;
+    }
+    return undefined;
+}
+function resolveSubmitModel(chat, responsesContext) {
+    const direct = chat.parameters && typeof chat.parameters.model === 'string'
+        ? chat.parameters.model.trim()
+        : undefined;
+    if (direct) {
+        return direct;
+    }
+    if (responsesContext && typeof responsesContext.parameters === 'object') {
+        const params = responsesContext.parameters;
+        const model = typeof params.model === 'string' ? params.model.trim() : undefined;
+        if (model) {
+            return model;
+        }
+    }
+    return undefined;
+}
+function buildSubmitToolOutputsPayload(chat, ctx, responsesContext) {
+    const responseId = resolveSubmitResponseId(ctx, responsesContext);
+    if (!responseId) {
+        throw new Error('Submit tool outputs requires response_id from Responses resume context');
+    }
+    const toolOutputs = collectSubmitToolOutputs(chat, ctx, responsesContext);
+    if (!toolOutputs.length) {
+        throw new Error('Submit tool outputs requires at least one tool output entry');
+    }
+    const resumeMeta = ctx.responsesResume && typeof ctx.responsesResume === 'object'
+        ? ctx.responsesResume
+        : undefined;
+    const payload = {
+        response_id: responseId,
+        tool_outputs: toolOutputs
+    };
+    const modelValue = resolveSubmitModel(chat, responsesContext);
+    if (modelValue) {
+        payload.model = modelValue;
+    }
+    const streamValue = resolveSubmitStreamFlag(chat, ctx, responsesContext);
+    if (typeof streamValue === 'boolean') {
+        payload.stream = streamValue;
+    }
+    const metadata = extractSubmitMetadata(responsesContext, resumeMeta);
+    if (metadata) {
+        payload.metadata = metadata;
+    }
+    return payload;
+}
 export class ResponsesSemanticMapper {
     async toChat(format, ctx) {
         const payload = format.payload || {};
@@ -169,16 +397,30 @@ export class ResponsesSemanticMapper {
         const { request, toolsNormalized } = buildChatRequestFromResponses(payload, responsesContext);
         const missingFields = [];
         const messages = normalizeMessages(request.messages, missingFields);
-        const toolOutputs = mapToolOutputs(payload.tool_outputs, missingFields);
+        let toolOutputs = mapToolOutputs(payload.tool_outputs, missingFields);
+        if (!toolOutputs || toolOutputs.length === 0) {
+            const resumeToolOutputs = deriveResumeToolOutputs(ctx);
+            if (resumeToolOutputs && resumeToolOutputs.length) {
+                toolOutputs = resumeToolOutputs;
+            }
+        }
         const parameters = collectParameters(payload, responsesContext.stream);
         const metadata = { context: ctx };
         try {
             const bridgePolicy = resolveBridgePolicy({ protocol: 'openai-responses', moduleType: 'openai-responses' });
             const actions = resolvePolicyActions(bridgePolicy, 'request_inbound');
             if (actions?.length) {
+                const capturedToolResults = Array.isArray(toolOutputs)
+                    ? toolOutputs.map((entry) => ({
+                        tool_call_id: entry.tool_call_id,
+                        output: entry.content,
+                        name: entry.name
+                    }))
+                    : undefined;
                 const actionState = createBridgeActionState({
                     rawRequest: payload,
-                    metadata: metadata
+                    metadata: metadata,
+                    capturedToolResults
                 });
                 runBridgeActionPipeline({
                     stage: 'request_inbound',
@@ -208,6 +450,28 @@ export class ResponsesSemanticMapper {
         };
     }
     async fromChat(chat, ctx) {
+        const capturedContext = chat.metadata?.responsesContext;
+        const envelopeMetadata = chat.metadata && isJsonObject(chat.metadata) ? chat.metadata : undefined;
+        const responsesContext = isJsonObject(capturedContext)
+            ? {
+                ...capturedContext,
+                metadata: mergeMetadata(capturedContext.metadata, envelopeMetadata)
+            }
+            : {
+                metadata: envelopeMetadata
+            };
+        if (isSubmitToolOutputsEndpoint(ctx)) {
+            const submitPayload = buildSubmitToolOutputsPayload(chat, ctx, responsesContext);
+            return {
+                protocol: 'openai-responses',
+                direction: 'response',
+                payload: submitPayload,
+                meta: {
+                    context: ctx,
+                    submitToolOutputs: true
+                }
+            };
+        }
         const modelValue = chat.parameters?.model;
         if (typeof modelValue !== 'string' || !modelValue.trim()) {
             throw new Error('ChatEnvelope.parameters.model is required for openai-responses outbound conversion');
@@ -222,18 +486,7 @@ export class ResponsesSemanticMapper {
             .filter((message) => Boolean(message && typeof message === 'object' && message.role === 'system'))
             .map(message => serializeSystemContent(message))
             .filter((content) => typeof content === 'string' && content.length > 0);
-        const capturedContext = chat.metadata?.responsesContext;
-        const envelopeMetadata = chat.metadata && isJsonObject(chat.metadata) ? chat.metadata : undefined;
-        const responsesContext = isJsonObject(capturedContext)
-            ? {
-                ...capturedContext,
-                metadata: mergeMetadata(capturedContext.metadata, envelopeMetadata),
-                originalSystemMessages
-            }
-            : {
-                metadata: envelopeMetadata,
-                originalSystemMessages
-            };
+        responsesContext.originalSystemMessages = originalSystemMessages;
         const responsesResult = buildResponsesRequestFromChat(requestShape, responsesContext);
         const responses = responsesResult.request;
         if (chat.parameters && chat.parameters.stream !== undefined) {

package/dist/conversion/hub/types/chat-envelope.d.ts

@@ -53,6 +53,7 @@ export interface AdapterContext {
     originalModelId?: string;
     clientModelId?: string;
     toolCallIdStyle?: 'fc' | 'preserve';
+    responsesResume?: JsonObject;
     [key: string]: JsonValue;
 }
 export interface ChatEnvelope {

package/dist/conversion/responses/responses-openai-bridge.d.ts

@@ -1,5 +1,6 @@
 import type { BridgeInputItem, BridgeToolDefinition } from '../shared/bridge-message-types.js';
 import type { ChatToolDefinition } from '../hub/types/chat-envelope.js';
+import type { JsonObject, JsonValue } from '../hub/types/json.js';
 import type { BridgeInputBuildResult } from '../shared/bridge-message-utils.js';
 import type { ToolCallIdStyle } from '../shared/responses-tool-utils.js';
 type Unknown = Record<string, unknown>;
@@ -11,8 +12,8 @@ export interface ResponsesRequestContext extends Unknown {
     store?: unknown;
     toolChoice?: unknown;
     parallelToolCalls?: boolean;
-    metadata?: Record<string, unknown> | undefined;
-    responseFormat?: unknown;
+    metadata?: JsonObject;
+    responseFormat?: JsonValue;
     stream?: boolean;
     isChatPayload?: boolean;
     isResponsesPayload?: boolean;

package/dist/conversion/responses/responses-openai-bridge.js

@@ -10,7 +10,6 @@ import { normalizeMessageReasoningTools } from '../shared/reasoning-tool-normali
 import { createBridgeActionState, runBridgeActionPipeline } from '../shared/bridge-actions.js';
 import { resolveBridgePolicy, resolvePolicyActions } from '../shared/bridge-policies.js';
 import { buildResponsesOutputFromChat } from '../shared/responses-output-builder.js';
-import { consumeResponsesPayloadSnapshot, consumeResponsesPassthrough } from '../shared/responses-reasoning-registry.js';
 function isObject(v) {
     return !!v && typeof v === 'object' && !Array.isArray(v);
 }
@@ -29,7 +28,7 @@ export function captureResponsesContext(payload, dto) {
         store: payload.store,
         toolChoice: payload.tool_choice,
         parallelToolCalls: typeof payload.parallel_tool_calls === 'boolean' ? payload.parallel_tool_calls : undefined,
-        metadata: (payload.metadata && typeof payload.metadata === 'object') ? { ...payload.metadata } : undefined,
+        metadata: (payload.metadata && typeof payload.metadata === 'object') ? payload.metadata : undefined,
         responseFormat: payload.response_format,
         stream: typeof payload.stream === 'boolean' ? payload.stream : undefined,
         isChatPayload: Array.isArray(payload.messages)
@@ -461,17 +460,6 @@ export function buildResponsesPayloadFromChat(payload, context) {
     const response = unwrapData(payload);
     if (!response || typeof response !== 'object')
         return payload;
-    const snapshotKey = resolveSnapshotLookupKey(response, context);
-    if (snapshotKey) {
-        const passthrough = consumeResponsesPassthrough(snapshotKey);
-        if (passthrough) {
-            return passthrough;
-        }
-        const snapshot = consumeResponsesPayloadSnapshot(snapshotKey);
-        if (snapshot) {
-            return snapshot;
-        }
-    }
     if (response.object === 'response' && Array.isArray(response.output)) {
         return response;
     }

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

@@ -647,6 +647,56 @@ function createAnthropicToolNameResolver(source) {
         return lookup.get(trimmed) ?? lookup.get(trimmed.toLowerCase()) ?? trimmed;
     };
 }
+function normalizeAnthropicToolChoice(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (isPlainRecord(value)) {
+        // Already an object – best-effort clone while trimming type, and also support
+        // Chat-style { type: 'function', function: { name } } by mapping to Anthropic's
+        // { type: 'tool', name } shape.
+        const cloned = cloneAnthropicSchema(value);
+        const rawType = typeof cloned.type === 'string' ? String(cloned.type).trim() : '';
+        if (rawType) {
+            cloned.type = rawType;
+            return cloned;
+        }
+        const selectorType = typeof cloned.type === 'string' ? String(cloned.type).trim() : '';
+        const fn = cloned.function;
+        if (selectorType === 'function' &&
+            fn &&
+            typeof fn === 'object' &&
+            typeof fn.name === 'string' &&
+            String(fn.name).trim().length) {
+            return { type: 'tool', name: String(fn.name).trim() };
+        }
+        return cloned;
+    }
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (!trimmed.length) {
+            return undefined;
+        }
+        const lower = trimmed.toLowerCase();
+        if (lower === 'auto') {
+            return { type: 'auto' };
+        }
+        if (lower === 'none') {
+            return { type: 'none' };
+        }
+        if (lower === 'any') {
+            return { type: 'any' };
+        }
+        if (lower === 'required') {
+            // "required" in canonical Chat roughly maps to Anthropic's "any" semantics:
+            // the model must choose some tool if available.
+            return { type: 'any' };
+        }
+        // Fallback: preserve custom mode as-is in type field.
+        return { type: trimmed };
+    }
+    return undefined;
+}
 export function buildAnthropicRequestFromOpenAIChat(chatReq) {
     const requestBody = isObject(chatReq) ? chatReq : {};
     const model = String(requestBody?.model || 'unknown');
@@ -882,6 +932,10 @@ export function buildAnthropicRequestFromOpenAIChat(chatReq) {
     if (anthropicTools !== undefined) {
         out.tools = anthropicTools;
     }
+    const normalizedToolChoice = normalizeAnthropicToolChoice(requestBody.tool_choice);
+    if (normalizedToolChoice !== undefined) {
+        out.tool_choice = normalizedToolChoice;
+    }
     try {
         if (requestBody.metadata && typeof requestBody.metadata === 'object') {
             out.metadata = JSON.parse(JSON.stringify(requestBody.metadata));

package/dist/conversion/shared/args-mapping.js

@@ -1,4 +1,4 @@
-// Shared tool + argument mapping helpers (schema-driven)
+import { buildShellDescription, hasApplyPatchToolDeclared, isShellToolName } from '../../tools/tool-description-utils.js';
 function isObject(v) {
     return !!v && typeof v === 'object' && !Array.isArray(v);
 }
@@ -155,6 +155,7 @@ export function normalizeTools(tools) {
     if (!Array.isArray(tools))
         return [];
     const out = [];
+    const applyPatchAvailable = hasApplyPatchToolDeclared(tools);
     for (const t of tools) {
         if (!t || typeof t !== 'object')
             continue;
@@ -175,7 +176,7 @@ export function normalizeTools(tools) {
         }
         // Enforce schema for known tools with minimal, compatible constraints
         let finalParams;
-        if (typeof name === 'string' && name.trim().toLowerCase() === 'shell') {
+        if (isShellToolName(name)) {
             // Do NOT downgrade an existing schema; prefer string command, allow argv array as fallback
             const base = isObject(params) ? params : {};
             const props = isObject(base.properties) ? base.properties : {};
@@ -205,7 +206,14 @@ export function normalizeTools(tools) {
         else {
             finalParams = { type: 'object', properties: {}, additionalProperties: true };
         }
-        const norm = { type: 'function', function: { name, ...(desc ? { description: desc } : {}), parameters: finalParams } };
+        const functionNode = { name, ...(desc ? { description: desc } : {}), parameters: finalParams };
+        if (isShellToolName(name)) {
+            const display = (typeof name === 'string' && name.trim().length > 0)
+                ? name.trim()
+                : ((typeof topName === 'string' && topName.trim().length > 0) ? topName.trim() : 'shell');
+            functionNode.description = buildShellDescription(display, applyPatchAvailable);
+        }
+        const norm = { type: 'function', function: functionNode };
         if (norm.function?.name)
             out.push(norm);
     }

package/dist/conversion/shared/responses-output-builder.js

@@ -153,29 +153,50 @@ export function buildResponsesOutputFromChat(options) {
     };
 }
 function normalizeUsage(usageRaw) {
-    if (usageRaw && typeof usageRaw === 'object') {
-        const usage = { ...usageRaw };
-        if (usage.input_tokens != null && usage.prompt_tokens == null) {
-            usage.prompt_tokens = usage.input_tokens;
-        }
-        if (usage.output_tokens != null && usage.completion_tokens == null) {
-            usage.completion_tokens = usage.output_tokens;
-        }
-        if (usage.prompt_tokens != null && usage.completion_tokens != null && usage.total_tokens == null) {
-            const total = Number(usage.prompt_tokens) + Number(usage.completion_tokens);
-            if (!Number.isNaN(total))
-                usage.total_tokens = total;
-        }
-        try {
-            delete usage.input_tokens;
-            delete usage.output_tokens;
-        }
-        catch {
-            /* ignore */
+    if (!usageRaw || typeof usageRaw !== 'object') {
+        return usageRaw;
+    }
+    const usage = { ...usageRaw };
+    // 统一 Responses 与 Chat 两种 usage 形态：
+    // - Responses: input_tokens / output_tokens / total_tokens
+    // - Chat: prompt_tokens / completion_tokens / total_tokens
+    const inputTokens = typeof usage.input_tokens === 'number'
+        ? usage.input_tokens
+        : typeof usage.prompt_tokens === 'number'
+            ? usage.prompt_tokens
+            : undefined;
+    const outputTokens = typeof usage.output_tokens === 'number'
+        ? usage.output_tokens
+        : typeof usage.completion_tokens === 'number'
+            ? usage.completion_tokens
+            : undefined;
+    let totalTokens = typeof usage.total_tokens === 'number'
+        ? usage.total_tokens
+        : undefined;
+    if (totalTokens === undefined && inputTokens !== undefined && outputTokens !== undefined) {
+        const total = Number(inputTokens) + Number(outputTokens);
+        if (!Number.isNaN(total)) {
+            totalTokens = total;
         }
-        return usage;
     }
-    return usageRaw;
+    // Responses 规范字段：input_tokens / output_tokens / total_tokens
+    if (inputTokens !== undefined) {
+        usage.input_tokens = inputTokens;
+    }
+    if (outputTokens !== undefined) {
+        usage.output_tokens = outputTokens;
+    }
+    if (totalTokens !== undefined) {
+        usage.total_tokens = totalTokens;
+    }
+    // 为了兼容内部统计逻辑，保留 prompt_tokens / completion_tokens 映射（如果原本没有）
+    if (usage.prompt_tokens == null && inputTokens !== undefined) {
+        usage.prompt_tokens = inputTokens;
+    }
+    if (usage.completion_tokens == null && outputTokens !== undefined) {
+        usage.completion_tokens = outputTokens;
+    }
+    return usage;
 }
 function buildFunctionCallOutput(call, allocateOutputId, sanitizeFunctionName, baseCount, offset) {
     try {

package/dist/conversion/shared/streaming-text-extractor.d.ts

@@ -0,0 +1,25 @@
+export interface StreamingToolCall {
+    id?: string;
+    type: 'function';
+    function: {
+        name?: string;
+        arguments?: string;
+    };
+}
+export interface StreamingToolExtractorOptions {
+    idPrefix?: string;
+}
+export declare class StreamingTextToolExtractor {
+    private opts;
+    private buffer;
+    private idCounter;
+    constructor(opts?: StreamingToolExtractorOptions);
+    reset(): void;
+    feedText(text: string): StreamingToolCall[];
+    private genId;
+    private toToolCall;
+    private tryExtractStructuredBlocks;
+    private tryExtractFunctionExecuteBlocks;
+    private splitCommand;
+}
+export declare function createStreamingToolExtractor(opts?: StreamingToolExtractorOptions): StreamingTextToolExtractor;