@jsonstudio/llms 0.4.6 → 0.6.2

package/dist/conversion/shared/tool-filter-pipeline.js

@@ -1,5 +1,6 @@
 import { FilterEngine } from '../../filters/index.js';
 import { loadFieldMapConfig } from '../../filters/utils/fieldmap-loader.js';
+import { createSnapshotWriter } from './snapshot-utils.js';
 export async function runChatRequestToolFilters(chatRequest, options = {}) {
     const reqCtxBase = {
         requestId: options.requestId ?? `req_${Date.now()}`,
@@ -10,16 +11,35 @@ export async function runChatRequestToolFilters(chatRequest, options = {}) {
         toolFilterHints: options.toolFilterHints,
         debug: { emit: () => { } }
     };
+    const snapshot = createSnapshotWriter({
+        requestId: reqCtxBase.requestId,
+        endpoint: reqCtxBase.endpoint,
+        folderHint: 'openai-chat'
+    });
+    const recordStage = (stage, payload) => {
+        if (!snapshot)
+            return;
+        snapshot(stage, payload);
+    };
+    recordStage('req_process_tool_filters_input', chatRequest);
     const engine = new FilterEngine();
-    try {
-        const { RequestToolListFilter } = await import('../../filters/index.js');
-        engine.registerFilter(new RequestToolListFilter());
+    const profile = (reqCtxBase.profile || '').toLowerCase();
+    const endpoint = (reqCtxBase.endpoint || '').toLowerCase();
+    const isAnthropic = profile === 'anthropic-messages' || endpoint.includes('/v1/messages');
+    if (!isAnthropic) {
+        try {
+            const { RequestToolListFilter } = await import('../../filters/index.js');
+            engine.registerFilter(new RequestToolListFilter());
+        }
+        catch {
+            /* optional */
+        }
     }
-    catch { /* optional */ }
-    const { RequestToolCallsStringifyFilter, RequestToolChoicePolicyFilter, RequestStreamingToNonStreamingFilter } = await import('../../filters/index.js');
+    const { RequestToolCallsStringifyFilter, RequestToolChoicePolicyFilter } = await import('../../filters/index.js');
     engine.registerFilter(new RequestToolCallsStringifyFilter());
-    engine.registerFilter(new RequestToolChoicePolicyFilter());
-    engine.registerFilter(new RequestStreamingToNonStreamingFilter());
+    if (!isAnthropic) {
+        engine.registerFilter(new RequestToolChoicePolicyFilter());
+    }
     try {
         const cfg = await loadFieldMapConfig('openai-openai.fieldmap.json');
         if (cfg)
@@ -33,8 +53,12 @@ export async function runChatRequestToolFilters(chatRequest, options = {}) {
     }
     catch { /* ignore */ }
     let staged = await engine.run('request_pre', chatRequest, reqCtxBase);
+    recordStage('req_process_tool_filters_request_pre', staged);
     staged = await engine.run('request_map', staged, reqCtxBase);
+    recordStage('req_process_tool_filters_request_map', staged);
     staged = await engine.run('request_post', staged, reqCtxBase);
+    recordStage('req_process_tool_filters_request_post', staged);
+    recordStage('req_process_tool_filters_output', staged);
     return staged;
 }
 export async function runChatResponseToolFilters(chatJson, options = {}) {
@@ -45,6 +69,17 @@ export async function runChatResponseToolFilters(chatJson, options = {}) {
         profile: options.profile || 'openai-chat',
         debug: { emit: () => { } }
     };
+    const snapshot = createSnapshotWriter({
+        requestId: resCtxBase.requestId,
+        endpoint: resCtxBase.endpoint,
+        folderHint: 'openai-chat'
+    });
+    const recordStage = (stage, payload) => {
+        if (!snapshot)
+            return;
+        snapshot(stage, payload);
+    };
+    recordStage('resp_process_tool_filters_input', chatJson);
     const engine = new FilterEngine();
     const { ResponseToolTextCanonicalizeFilter, ResponseToolArgumentsStringifyFilter, ResponseFinishInvariantsFilter } = await import('../../filters/index.js');
     engine.registerFilter(new ResponseToolTextCanonicalizeFilter());
@@ -73,7 +108,11 @@ export async function runChatResponseToolFilters(chatJson, options = {}) {
     }
     catch { /* ignore */ }
     let staged = await engine.run('response_pre', chatJson, resCtxBase);
+    recordStage('resp_process_tool_filters_response_pre', staged);
     staged = await engine.run('response_map', staged, resCtxBase);
+    recordStage('resp_process_tool_filters_response_map', staged);
     staged = await engine.run('response_post', staged, resCtxBase);
+    recordStage('resp_process_tool_filters_response_post', staged);
+    recordStage('resp_process_tool_filters_output', staged);
     return staged;
 }

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

@@ -32,8 +32,8 @@ function pickToolName(candidates, options) {
     return undefined;
 }
 function resolveToolDescription(candidate) {
-    if (typeof candidate === 'string' && candidate.trim().length) {
-        return candidate.trim();
+    if (typeof candidate === 'string') {
+        return candidate;
     }
     return undefined;
 }
@@ -121,6 +121,17 @@ export function chatToolToBridgeDefinition(rawTool, options) {
     if (strict !== undefined) {
         responseShape.strict = strict;
     }
+    const fnOut = { name };
+    if (description !== undefined) {
+        fnOut.description = description;
+    }
+    if (parameters !== undefined) {
+        fnOut.parameters = parameters;
+    }
+    if (strict !== undefined) {
+        fnOut.strict = strict;
+    }
+    responseShape.function = fnOut;
     return responseShape;
 }
 export function mapChatToolsToBridge(rawTools, options) {

package/dist/filters/index.d.ts

@@ -0,0 +1,18 @@
+export * from './types.js';
+export * from './engine.js';
+export * from './builtin/whitelist-filter.js';
+export * from './builtin/blacklist-filter.js';
+export * from './builtin/add-fields-filter.js';
+export * from './special/request-toolcalls-stringify.js';
+export * from './special/request-tool-choice-policy.js';
+export * from './special/request-tool-list-filter.js';
+export * from './special/tool-filter-hooks.js';
+export * from './special/response-tool-text-canonicalize.js';
+export * from './special/response-tool-arguments-stringify.js';
+export * from './special/response-finish-invariants.js';
+export * from './special/request-tools-normalize.js';
+export * from './special/response-tool-arguments-toon-decode.js';
+export * from './special/response-tool-arguments-blacklist.js';
+export * from './special/response-tool-arguments-schema-converge.js';
+export * from './special/response-tool-arguments-whitelist.js';
+export * from './special/tool-post-constraints.js';

package/dist/filters/index.js

@@ -9,7 +9,6 @@ export * from './special/request-toolcalls-stringify.js';
 export * from './special/request-tool-choice-policy.js';
 export * from './special/request-tool-list-filter.js';
 export * from './special/tool-filter-hooks.js';
-export * from './special/request-streaming-to-nonstreaming.js';
 export * from './special/response-tool-text-canonicalize.js';
 export * from './special/response-tool-arguments-stringify.js';
 export * from './special/response-finish-invariants.js';

package/dist/filters/special/request-streaming-to-nonstreaming.d.ts

@@ -0,0 +1,13 @@
+import type { Filter, FilterContext, FilterResult, JsonObject } from '../types.js';
+/**
+ * RequestStreamingToNonStreamingFilter (request_post)
+ * - Unifies provider requests to non-streaming regardless of inbound stream flag.
+ * - Preserves original intent via `originalStream` and `_originalStreamOptions`,
+ *   but ensures `stream: false` is sent to providers.
+ */
+export declare class RequestStreamingToNonStreamingFilter implements Filter<JsonObject> {
+    readonly name = "request_streaming_to_nonstreaming";
+    readonly stage: FilterContext['stage'];
+    apply(input: JsonObject, ctx: FilterContext): FilterResult<JsonObject>;
+    private shouldPreserveStream;
+}

package/dist/filters/special/request-streaming-to-nonstreaming.js

@@ -7,9 +7,12 @@
 export class RequestStreamingToNonStreamingFilter {
     name = 'request_streaming_to_nonstreaming';
     stage = 'request_post';
-    apply(input) {
+    apply(input, ctx) {
         try {
             const out = JSON.parse(JSON.stringify(input || {}));
+            if (this.shouldPreserveStream(out, ctx)) {
+                return { ok: true, data: out };
+            }
             if (out.stream === true) {
                 out.originalStream = true;
                 out.stream = false;
@@ -24,4 +27,13 @@ export class RequestStreamingToNonStreamingFilter {
             return { ok: true, data: input };
         }
     }
+    shouldPreserveStream(payload, ctx) {
+        if (ctx.stream === true) {
+            return true;
+        }
+        if (payload.stream === true) {
+            return true;
+        }
+        return false;
+    }
 }

package/dist/filters/special/request-tool-choice-policy.js

@@ -11,8 +11,10 @@ export class RequestToolChoicePolicyFilter {
             const out = JSON.parse(JSON.stringify(input || {}));
             const tools = Array.isArray(out.tools) ? out.tools : [];
             if (tools.length > 0) {
-                if (out.tool_choice == null)
+                const hasOwn = Object.prototype.hasOwnProperty.call(out, 'tool_choice');
+                if (!hasOwn || out.tool_choice === undefined) {
                     out.tool_choice = 'auto';
+                }
             }
             else {
                 if (Object.prototype.hasOwnProperty.call(out, 'tool_choice'))

package/dist/filters/special/request-tool-list-filter.d.ts

@@ -0,0 +1,11 @@
+import type { Filter, FilterContext, FilterResult, JsonObject } from '../types.js';
+/**
+ * RequestToolListFilter (request_pre)
+ * - Generic tool-list filter/augment hook
+ * - Currently only handles MCP tools with phase-based exposure
+ */
+export declare class RequestToolListFilter implements Filter<JsonObject> {
+    readonly name = "request_tool_list_filter";
+    readonly stage: FilterContext['stage'];
+    apply(input: JsonObject, ctx: FilterContext): FilterResult<JsonObject>;
+}

package/dist/filters/special/request-tool-list-filter.js

@@ -94,15 +94,21 @@ function removeToolByName(tools, name) {
 export class RequestToolListFilter {
     name = 'request_tool_list_filter';
     stage = 'request_pre';
-    apply(input) {
+    apply(input, ctx) {
         try {
             const out = JSON.parse(JSON.stringify(input || {}));
-            const tools = Array.isArray(out.tools) ? out.tools : [];
-            if (!tools.length)
-                return { ok: true, data: out };
+            const hadIncomingTools = Array.isArray(out.tools);
+            const tools = hadIncomingTools ? out.tools : [];
+            if (!hadIncomingTools) {
+                out.tools = tools;
+            }
             const mode = envMode();
-            if (mode === 'off')
+            if (mode === 'off') {
+                if (!hadIncomingTools && tools.length === 0) {
+                    delete out.tools;
+                }
                 return { ok: true, data: out };
+            }
             const messages = Array.isArray(out.messages) ? out.messages : [];
             const servers = new Set();
             for (const s of getEnvServers())
@@ -137,14 +143,21 @@ export class RequestToolListFilter {
                 required: ['server', 'uri'],
                 additionalProperties: false
             };
+            const profileKey = String(ctx?.profile || '').toLowerCase();
+            const endpointKey = String(ctx?.endpoint || '').toLowerCase();
+            const prefersLegacyListDescription = profileKey.includes('anthropic') ||
+                endpointKey.includes('/v1/messages');
+            const listDescription = prefersLegacyListDescription
+                ? 'List resources from an MCP server.'
+                : 'List resources from a given MCP server (arguments.server = server label).';
             if (mode === 'all') {
-                ensureFunctionTool(tools, 'list_mcp_resources', 'List resources from an MCP server.', listResParams);
+                ensureFunctionTool(tools, 'list_mcp_resources', listDescription, listResParams);
                 ensureFunctionTool(tools, 'list_mcp_resource_templates', 'List resource templates from MCP servers.', listTplParams);
                 ensureFunctionTool(tools, 'read_mcp_resource', 'Read a specific MCP resource.', readResParamsBase);
             }
             else {
                 // phase
-                ensureFunctionTool(tools, 'list_mcp_resources', 'List resources from an MCP server.', listResParams);
+                ensureFunctionTool(tools, 'list_mcp_resources', listDescription, listResParams);
                 ensureFunctionTool(tools, 'list_mcp_resource_templates', 'List resource templates from MCP servers.', listTplParams);
                 // read is only exposed when we have known servers
                 if (knownServers.length > 0) {

package/dist/sse/shared/responses-output-normalizer.js

@@ -13,9 +13,8 @@ export function normalizeResponsesMessageItem(item, options) {
         const extras = Array.isArray(additionalReasoning) ? additionalReasoning : [additionalReasoning];
         for (const entry of extras) {
             if (typeof entry === 'string') {
-                const trimmed = entry.trim();
-                if (trimmed.length) {
-                    reasoningChunks.push(trimmed);
+                if (entry.length) {
+                    reasoningChunks.push(entry);
                 }
             }
         }
@@ -41,5 +40,7 @@ export function normalizeResponsesMessageItem(item, options) {
 }
 export function expandResponsesMessageItem(item, options) {
     const { message, reasoning } = normalizeResponsesMessageItem(item, options);
-    return reasoning ? [message, reasoning] : [message];
+    // Responses upstream (legacy + CCR) emitted reasoning segments before the final assistant message.
+    // Preserve that ordering so roundtrip comparisons against provider snapshots remain identical.
+    return reasoning ? [reasoning, message] : [message];
 }

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

@@ -574,7 +574,30 @@ export class ResponsesResponseBuilder {
      * 处理required_action事件
      */
     handleRequiredAction(event) {
-        // TODO: 实现required_action处理
+        const payload = event.data ?? {};
+        const responsePayload = payload.response ?? payload;
+        const requiredAction = responsePayload.required_action ??
+            payload.required_action ??
+            undefined;
+        const usage = responsePayload.usage ??
+            payload.usage ??
+            this.response.usage;
+        const nextResponse = {
+            ...this.response,
+            object: 'response',
+            id: responsePayload.id ?? this.response.id,
+            status: responsePayload.status ?? 'requires_action',
+            output: Array.isArray(responsePayload.output) && responsePayload.output.length
+                ? responsePayload.output
+                : this.buildOutputItems(),
+            required_action: requiredAction ?? this.response.required_action,
+            usage
+        };
+        if (responsePayload.metadata) {
+            nextResponse.metadata = responsePayload.metadata;
+        }
+        this.response = nextResponse;
+        this.state = 'completed';
     }
     /**
      * 处理response.done事件

package/dist/sse/types/responses-types.d.ts

@@ -3,6 +3,7 @@
  * 支持OpenAI Responses API的JSON↔SSE双向转换
  */
 import { BaseSseEvent, StreamDirection, type JsonObject, type JsonValue } from './core-interfaces.js';
+import type { RequiredAction } from './sse-events.js';
 export * from './sse-events.js';
 export type ResponsesSseEventType = 'response.created' | 'response.in_progress' | 'response.completed' | 'response.required_action' | 'response.done' | 'response.output_item.added' | 'response.output_item.done' | 'response.content_part.added' | 'response.content_part.done' | 'response.output_text.delta' | 'response.output_text.done' | 'response.reasoning_text.delta' | 'response.reasoning_text.done' | 'response.reasoning_signature.delta' | 'response.reasoning_image.delta' | 'response.reasoning_summary_part.added' | 'response.reasoning_summary_part.done' | 'response.reasoning_summary_text.delta' | 'response.reasoning_summary_text.done' | 'response.function_call_arguments.delta' | 'response.function_call_arguments.done' | 'response.error' | 'response.cancelled' | 'response.start' | 'content_part.delta' | 'reasoning.delta' | 'function_call.start' | 'function_call.delta' | 'function_call.done' | 'output_item.start' | 'content_part.start' | 'content_part.done' | 'output_item.done' | 'reasoning.start' | 'reasoning.done' | 'required_action' | 'error';
 export interface ResponsesSseEvent extends BaseSseEvent {
@@ -118,6 +119,7 @@ export interface ResponsesResponse {
     output: ResponsesOutputItem[];
     previous_response_id?: string;
     usage?: ResponsesUsage;
+    required_action?: RequiredAction;
     temperature?: number;
     top_p?: number;
     max_output_tokens?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsonstudio/llms",
-  "version": "0.4.6",
+  "version": "0.6.002",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",