@jsonstudio/llms 0.6.0 → 0.6.2

package/dist/conversion/hub/process/chat-process.js

@@ -29,7 +29,7 @@ async function applyRequestToolGovernance(request, context) {
     const providerProtocol = readString(metadata.providerProtocol) ?? readString(metadata.provider) ?? 'openai-chat';
     const metadataToolHints = metadata.toolFilterHints;
     const metadataStreamFlag = metadata.stream;
-    const metadataStream = typeof metadataStreamFlag === 'boolean' ? metadataStreamFlag : request.parameters?.stream === true;
+    const inboundStreamIntent = typeof metadataStreamFlag === 'boolean' ? metadataStreamFlag : request.parameters?.stream === true;
     const shaped = {
         model: request.model,
         messages: deepClone(request.messages),
@@ -43,10 +43,11 @@ async function applyRequestToolGovernance(request, context) {
         requestId: context.requestId,
         model: request.model,
         profile: providerProtocol,
-        stream: metadataStream,
+        stream: inboundStreamIntent,
         toolFilterHints: metadataToolHints
     });
     const governed = normalizeRecord(governedPayload);
+    const providerStreamIntent = typeof governed.stream === 'boolean' ? governed.stream : undefined;
     const merged = {
         ...request,
         messages: Array.isArray(governed.messages)
@@ -60,14 +61,19 @@ async function applyRequestToolGovernance(request, context) {
         metadata: {
             ...request.metadata,
             toolChoice: readToolChoice(governed.tool_choice),
-            originalStream: request.parameters?.stream === true,
-            stream: typeof governed.stream === 'boolean'
-                ? governed.stream
-                : request.parameters?.stream,
+            originalStream: inboundStreamIntent,
+            stream: inboundStreamIntent,
+            providerStream: providerStreamIntent,
             governedTools: governed.tools !== undefined,
             governanceTimestamp: Date.now()
         }
     };
+    if (typeof inboundStreamIntent === 'boolean') {
+        merged.metadata = {
+            ...merged.metadata,
+            inboundStream: inboundStreamIntent
+        };
+    }
     if (typeof governed.stream === 'boolean') {
         merged.parameters = {
             ...merged.parameters,

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

@@ -5,6 +5,7 @@ import { resolveBridgePolicy, resolvePolicyActions } from '../../shared/bridge-p
 import { encodeMetadataPassthrough, extractMetadataPassthrough } from '../../shared/metadata-passthrough.js';
 import { buildAnthropicToolAliasMap } from '../../shared/anthropic-message-utils.js';
 import { ChatSemanticMapper } from './chat-mapper.js';
+import { ensureProtocolState, getProtocolState } from '../../shared/protocol-state.js';
 const ANTHROPIC_PARAMETER_KEYS = [
     'model',
     'temperature',
@@ -53,6 +54,16 @@ function collectParameters(payload) {
     }
     return Object.keys(params).length ? params : undefined;
 }
+function cloneAnthropicSystemBlocks(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    const blocks = Array.isArray(value) ? value : [value];
+    if (!blocks.length) {
+        return undefined;
+    }
+    return blocks.map((entry) => jsonClone(entry));
+}
 export class AnthropicSemanticMapper {
     chatMapper = new ChatSemanticMapper();
     async toChat(format, ctx) {
@@ -86,6 +97,11 @@ export class AnthropicSemanticMapper {
             }
             return metadata.extraFields;
         };
+        const protocolState = ensureProtocolState(metadata, 'anthropic');
+        const systemBlocks = cloneAnthropicSystemBlocks(payload.system);
+        if (systemBlocks) {
+            protocolState.systemBlocks = systemBlocks;
+        }
         if (payload.tools && Array.isArray(payload.tools) && payload.tools.length === 0) {
             metadata.toolsFieldPresent = true;
             resolveExtraFields().toolsFieldPresent = true;
@@ -227,6 +243,10 @@ export class AnthropicSemanticMapper {
         if (chat.metadata?.toolsFieldPresent && (!Array.isArray(chat.tools) || chat.tools.length === 0)) {
             baseRequest.tools = [];
         }
+        const protocolState = getProtocolState(chat.metadata, 'anthropic');
+        if (protocolState?.systemBlocks !== undefined) {
+            baseRequest.system = jsonClone(protocolState.systemBlocks);
+        }
         if (chat.metadata &&
             typeof chat.metadata === 'object' &&
             chat.metadata.extraFields &&

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

@@ -2,6 +2,7 @@ import { isJsonObject, jsonClone } from '../types/json.js';
 import { createBridgeActionState, runBridgeActionPipeline } from '../../shared/bridge-actions.js';
 import { resolveBridgePolicy, resolvePolicyActions } from '../../shared/bridge-policies.js';
 import { normalizeChatMessageContent } from '../../shared/chat-output-normalizer.js';
+import { ensureProtocolState } from '../../shared/protocol-state.js';
 const CHAT_PARAMETER_KEYS = [
     'model',
     'temperature',
@@ -93,35 +94,12 @@ function collectSystemRawBlocks(raw) {
     if (!Array.isArray(raw))
         return undefined;
     const blocks = [];
-    const pushText = (text) => {
-        if (typeof text === 'string' && text.trim().length) {
-            blocks.push({ type: 'text', text });
-        }
-    };
     raw.forEach((entry) => {
         if (!isJsonObject(entry))
             return;
-        if (entry.role !== 'system')
-            return;
-        const content = entry.content;
-        if (typeof content === 'string') {
-            pushText(content);
-            return;
-        }
-        if (Array.isArray(content)) {
-            content.forEach((part) => {
-                if (typeof part === 'string') {
-                    pushText(part);
-                }
-                else if (isJsonObject(part) && typeof part.text === 'string') {
-                    pushText(part.text);
-                }
-            });
+        if (String(entry.role ?? '').toLowerCase() !== 'system')
             return;
-        }
-        if (isJsonObject(content) && typeof content.text === 'string') {
-            pushText(content.text);
-        }
+        blocks.push(jsonClone(entry));
     });
     return blocks.length ? blocks : undefined;
 }
@@ -274,8 +252,9 @@ export class ChatSemanticMapper {
             metadata.systemInstructions = normalized.systemSegments;
         }
         const rawSystemBlocks = collectSystemRawBlocks(payload.messages);
-        if (!metadata.rawSystem && rawSystemBlocks) {
-            metadata.rawSystem = rawSystemBlocks;
+        if (rawSystemBlocks) {
+            const protocolState = ensureProtocolState(metadata, 'openai');
+            protocolState.systemMessages = jsonClone(rawSystemBlocks);
         }
         if (normalized.missingFields.length) {
             metadata.missingFields = normalized.missingFields;

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

@@ -5,6 +5,7 @@ import { resolveBridgePolicy, resolvePolicyActions } from '../../shared/bridge-p
 import { encodeMetadataPassthrough, extractMetadataPassthrough } from '../../shared/metadata-passthrough.js';
 import { mapBridgeToolsToChat, mapChatToolsToBridge } from '../../shared/tool-mapping.js';
 import { prepareGeminiToolsForBridge, buildGeminiToolsFromBridge } from '../../shared/gemini-tool-utils.js';
+import { ensureProtocolState, getProtocolState } from '../../shared/protocol-state.js';
 const GENERATION_CONFIG_KEYS = [
     { source: 'temperature', target: 'temperature' },
     { source: 'topP', target: 'top_p' },
@@ -153,11 +154,9 @@ function buildGeminiRequestFromChat(chat, metadata) {
         model: chat.parameters?.model || 'models/gemini-pro',
         contents
     };
-    if (metadata?.rawSystem && isJsonObject(metadata.rawSystem) && String(metadata.rawSystem.role || '').toLowerCase() === 'system') {
-        request.systemInstruction = metadata.rawSystem;
-    }
-    else if (metadata?.rawSystemInstruction !== undefined) {
-        request.systemInstruction = metadata.rawSystemInstruction;
+    const geminiState = getProtocolState(metadata, 'gemini');
+    if (geminiState?.systemInstruction !== undefined) {
+        request.systemInstruction = jsonClone(geminiState.systemInstruction);
     }
     else if (metadata?.systemInstructions && Array.isArray(metadata.systemInstructions)) {
         const sysBlocks = metadata.systemInstructions
@@ -276,8 +275,7 @@ export class GeminiSemanticMapper {
         }
         if (payload.systemInstruction !== undefined) {
             const rawSystem = jsonClone(payload.systemInstruction);
-            metadata.rawSystemInstruction = rawSystem;
-            metadata.rawSystem = rawSystem;
+            ensureProtocolState(metadata, 'gemini').systemInstruction = rawSystem;
         }
         if (payload.safetySettings) {
             metadata.safetySettings = jsonClone(payload.safetySettings);
@@ -320,7 +318,6 @@ export class GeminiSemanticMapper {
         if (providerMetadataSource) {
             const providerMetadata = jsonClone(providerMetadataSource);
             let toolsFieldPresent = false;
-            let rawSystemValue;
             if (isJsonObject(providerMetadata)) {
                 delete providerMetadata.__rcc_stream;
                 if (Object.prototype.hasOwnProperty.call(providerMetadata, '__rcc_tools_field_present')) {
@@ -329,24 +326,12 @@ export class GeminiSemanticMapper {
                     delete providerMetadata.__rcc_tools_field_present;
                 }
                 if (Object.prototype.hasOwnProperty.call(providerMetadata, '__rcc_raw_system')) {
-                    const rawSystemSentinel = providerMetadata.__rcc_raw_system;
                     delete providerMetadata.__rcc_raw_system;
-                    if (typeof rawSystemSentinel === 'string') {
-                        try {
-                            rawSystemValue = JSON.parse(rawSystemSentinel);
-                        }
-                        catch {
-                            rawSystemValue = undefined;
-                        }
-                    }
                 }
             }
             if (toolsFieldPresent) {
                 metadata.toolsFieldPresent = true;
             }
-            if (rawSystemValue !== undefined) {
-                metadata.rawSystem = rawSystemValue;
-            }
             metadata.providerMetadata = providerMetadata;
         }
         return {

package/dist/conversion/hub/standardized-bridge.js

@@ -1,4 +1,4 @@
-import { jsonClone } from './types/json.js';
+import { isJsonObject, jsonClone } from './types/json.js';
 const HUB_CAPTURE_KEY = '__hub_capture';
 export function chatEnvelopeToStandardized(chat, options) {
     const parameters = { ...(chat.parameters ?? {}) };
@@ -16,8 +16,8 @@ export function chatEnvelopeToStandardized(chat, options) {
     if (isJsonObject(chat.metadata?.extraFields)) {
         hubState.extraFields = chat.metadata?.extraFields;
     }
-    if (chat.metadata?.rawSystem !== undefined) {
-        hubState.rawSystem = chat.metadata.rawSystem;
+    if (isJsonObject(chat.metadata?.protocolState)) {
+        hubState.protocolState = chat.metadata?.protocolState;
     }
     hubState.context = options.adapterContext;
     if (hubStateContextPopulated(hubState)) {
@@ -72,8 +72,8 @@ export function standardizedToChatEnvelope(request, options) {
     if (hubState?.extraFields) {
         metadata.extraFields = hubState.extraFields;
     }
-    if (hubState?.rawSystem !== undefined) {
-        metadata.rawSystem = hubState.rawSystem;
+    if (hubState?.protocolState) {
+        metadata.protocolState = hubState.protocolState;
     }
     return {
         messages,
@@ -232,9 +232,6 @@ function normalizeTools(tools) {
     }
     return normalized;
 }
-function isJsonObject(value) {
-    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
-}
 function extractHubCapture(request) {
     const captured = request.metadata?.capturedContext;
     if (!captured || typeof captured !== 'object') {
@@ -261,5 +258,5 @@ function hubStateContextPopulated(state) {
         (state.missingFields && state.missingFields.length) ||
         state.providerMetadata ||
         state.extraFields ||
-        state.rawSystem !== undefined);
+        (state.protocolState && Object.keys(state.protocolState).length));
 }

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

@@ -161,7 +161,6 @@ export function buildResponsesRequestFromChat(payload, ctx, extras) {
         'response_format',
         'user',
         'top_p',
-        'max_output_tokens',
         'logit_bias',
         'seed'
     ];
@@ -169,9 +168,6 @@ export function buildResponsesRequestFromChat(payload, ctx, extras) {
         if (chat[key] !== undefined)
             out[key] = chat[key];
     }
-    if (typeof chat.max_tokens === 'number' && chat.max_output_tokens === undefined) {
-        out.max_output_tokens = chat.max_tokens;
-    }
     let messages = Array.isArray(chat.messages) ? chat.messages : [];
     let bridgeMetadata;
     try {

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

@@ -32,6 +32,85 @@ function flattenAnthropicText(content) {
     }
     return '';
 }
+function normalizeToolResultContent(block) {
+    if (!block || typeof block !== 'object') {
+        return '';
+    }
+    const content = block.content;
+    if (typeof content === 'string') {
+        return content;
+    }
+    if (Array.isArray(content)) {
+        const segments = [];
+        for (const entry of content) {
+            const segment = extractToolResultSegment(entry);
+            if (segment) {
+                segments.push(segment);
+            }
+        }
+        if (segments.length) {
+            return segments.join('\n');
+        }
+    }
+    else if (content != null) {
+        try {
+            return JSON.stringify(content);
+        }
+        catch {
+            return String(content);
+        }
+    }
+    return '';
+}
+function extractToolResultSegment(entry) {
+    if (entry == null) {
+        return '';
+    }
+    if (typeof entry === 'string') {
+        return entry;
+    }
+    if (Array.isArray(entry)) {
+        return entry.map(extractToolResultSegment).filter(Boolean).join('');
+    }
+    if (typeof entry === 'object') {
+        const node = entry;
+        const type = typeof node.type === 'string' ? node.type.toLowerCase() : '';
+        if (type === 'input_text' || type === 'input_json' || type === 'tool_result_status' || type === 'status' || type === 'metadata') {
+            return '';
+        }
+        if (type === 'output_text' || type === 'text' || type === 'reasoning' || type === 'log') {
+            return flattenAnthropicText(entry);
+        }
+        if (type === 'output_json' || type === 'json') {
+            const payload = node.content ?? node.text ?? node.data ?? node.output;
+            if (payload === undefined) {
+                return '';
+            }
+            try {
+                return JSON.stringify(payload);
+            }
+            catch {
+                return String(payload ?? '');
+            }
+        }
+        if (typeof node.text === 'string') {
+            return node.text;
+        }
+        if ('content' in node) {
+            const nested = extractToolResultSegment(node.content);
+            if (nested) {
+                return nested;
+            }
+        }
+        try {
+            return JSON.stringify(entry);
+        }
+        catch {
+            return '';
+        }
+    }
+    return String(entry);
+}
 function requireTrimmedString(value, context) {
     if (typeof value !== 'string') {
         throw new Error(`Anthropic bridge constraint violated: ${context} must be a string`);
@@ -218,18 +297,7 @@ export function buildOpenAIChatFromAnthropic(payload) {
                     block.call_id ??
                     block.tool_use_id ??
                     block.id, 'tool_result.tool_use_id');
-                let contentStr = '';
-                const c = block.content;
-                if (typeof c === 'string')
-                    contentStr = c;
-                else if (c != null) {
-                    try {
-                        contentStr = JSON.stringify(c);
-                    }
-                    catch {
-                        contentStr = String(c);
-                    }
-                }
+                const contentStr = normalizeToolResultContent(block);
                 toolResults.push({ role: 'tool', tool_call_id: callId, content: contentStr });
             }
         }

package/dist/conversion/shared/bridge-actions.js

@@ -879,58 +879,3 @@ const metadataProviderSentinelAction = (ctx) => {
 };
 registerBridgeAction('metadata.provider-field', metadataProviderFieldAction);
 registerBridgeAction('metadata.provider-sentinel', metadataProviderSentinelAction);
-const metadataSystemSentinelAction = (ctx) => {
-    const sentinel = typeof ctx.descriptor.options?.sentinel === 'string'
-        ? ctx.descriptor.options.sentinel
-        : undefined;
-    const targetKey = typeof ctx.descriptor.options?.target === 'string'
-        ? ctx.descriptor.options.target
-        : 'rawSystem';
-    const stringifyOutbound = ctx.descriptor.options?.stringify !== false;
-    if (!sentinel)
-        return;
-    const payload = ctx.stage.startsWith('request') ? ctx.state.rawRequest :
-        ctx.stage.startsWith('response') ? ctx.state.rawResponse :
-            undefined;
-    if (!payload || typeof payload !== 'object')
-        return;
-    if (ctx.stage.endsWith('inbound')) {
-        const rawValue = payload[sentinel];
-        if (rawValue === undefined)
-            return;
-        let parsed = rawValue;
-        if (typeof rawValue === 'string') {
-            try {
-                parsed = JSON.parse(rawValue);
-            }
-            catch {
-                parsed = rawValue;
-            }
-        }
-        delete payload[sentinel];
-        const metadata = ensureMetadataRecord(ctx.state);
-        metadata[targetKey] = parsed;
-        return;
-    }
-    const metadata = ctx.state.metadata;
-    if (!metadata || typeof metadata !== 'object') {
-        delete payload[sentinel];
-        return;
-    }
-    const value = metadata[targetKey];
-    if (value === undefined) {
-        delete payload[sentinel];
-        return;
-    }
-    if (stringifyOutbound) {
-        try {
-            payload[sentinel] = JSON.stringify(value);
-        }
-        catch {
-            payload[sentinel] = value;
-        }
-        return;
-    }
-    payload[sentinel] = value;
-};
-registerBridgeAction('metadata.system-sentinel', metadataSystemSentinelAction);

package/dist/conversion/shared/bridge-policies.js

@@ -136,8 +136,7 @@ const RESPONSES_POLICY = {
             { name: 'tools.ensure-placeholders' },
             { name: 'metadata.extra-fields', options: { allowedKeys: RESPONSES_ALLOWED_FIELDS } },
             { name: 'metadata.provider-field', options: { field: 'metadata', target: 'providerMetadata' } },
-            { name: 'metadata.provider-sentinel', options: { sentinel: '__rcc_provider_metadata', target: 'providerMetadata' } },
-            { name: 'metadata.system-sentinel', options: { sentinel: '__rcc_raw_system', target: 'rawSystem' } }
+            { name: 'metadata.provider-sentinel', options: { sentinel: '__rcc_provider_metadata', target: 'providerMetadata' } }
         ],
         outbound: [
             { name: 'messages.normalize-history' },
@@ -149,8 +148,7 @@ const RESPONSES_POLICY = {
             reasoningAction('responses_reasoning'),
             { name: 'metadata.extra-fields', options: { allowedKeys: RESPONSES_ALLOWED_FIELDS } },
             { name: 'metadata.provider-field', options: { field: 'metadata', target: 'providerMetadata' } },
-            { name: 'metadata.provider-sentinel', options: { sentinel: '__rcc_provider_metadata', target: 'providerMetadata' } },
-            { name: 'metadata.system-sentinel', options: { sentinel: '__rcc_raw_system', target: 'rawSystem' } }
+            { name: 'metadata.provider-sentinel', options: { sentinel: '__rcc_provider_metadata', target: 'providerMetadata' } }
         ]
     },
     response: {
@@ -158,14 +156,12 @@ const RESPONSES_POLICY = {
             { name: 'reasoning.attach-output' },
             reasoningAction('responses_reasoning'),
             toolCallNormalizationAction('responses_tool_call'),
-            { name: 'metadata.extra-fields', options: { allowedKeys: RESPONSES_ALLOWED_FIELDS } },
-            { name: 'metadata.system-sentinel', options: { sentinel: '__rcc_raw_system', target: 'rawSystem' } }
+            { name: 'metadata.extra-fields', options: { allowedKeys: RESPONSES_ALLOWED_FIELDS } }
         ],
         outbound: [
             reasoningAction('responses_reasoning'),
             toolCallNormalizationAction('responses_tool_call'),
-            { name: 'metadata.extra-fields', options: { allowedKeys: RESPONSES_ALLOWED_FIELDS } },
-            { name: 'metadata.system-sentinel', options: { sentinel: '__rcc_raw_system', target: 'rawSystem' } }
+            { name: 'metadata.extra-fields', options: { allowedKeys: RESPONSES_ALLOWED_FIELDS } }
         ]
     }
 };
@@ -177,7 +173,6 @@ const OPENAI_CHAT_POLICY = {
             reasoningAction('openai_chat_reasoning'),
             toolCallNormalizationAction('openai_chat_tool_call'),
             { name: 'messages.ensure-system-instruction' },
-            { name: 'metadata.system-sentinel', options: { sentinel: '__rcc_raw_system', target: 'rawSystem' } },
             { name: 'metadata.extra-fields', options: { allowedKeys: OPENAI_CHAT_ALLOWED_FIELDS } },
             { name: 'metadata.provider-field', options: { field: 'metadata', target: 'providerMetadata' } },
             { name: 'metadata.provider-sentinel', options: { sentinel: '__rcc_provider_metadata', target: 'providerMetadata' } }
@@ -190,7 +185,6 @@ const OPENAI_CHAT_POLICY = {
             { name: 'messages.ensure-output-fields', options: { toolFallback: 'Tool call completed (no output).' } },
             { name: 'messages.ensure-system-instruction' },
             reasoningAction('openai_chat_reasoning'),
-            { name: 'metadata.system-sentinel', options: { sentinel: '__rcc_raw_system', target: 'rawSystem' } },
             { name: 'metadata.extra-fields', options: { allowedKeys: OPENAI_CHAT_ALLOWED_FIELDS } },
             { name: 'metadata.provider-field', options: { field: 'metadata', target: 'providerMetadata' } },
             { name: 'metadata.provider-sentinel', options: { sentinel: '__rcc_provider_metadata', target: 'providerMetadata' } }

package/dist/conversion/shared/chat-request-filters.js

@@ -1,4 +1,4 @@
-import { FilterEngine, RequestToolCallsStringifyFilter, RequestToolChoicePolicyFilter, RequestStreamingToNonStreamingFilter } from '../../filters/index.js';
+import { FilterEngine, RequestToolCallsStringifyFilter, RequestToolChoicePolicyFilter } from '../../filters/index.js';
 import { normalizeChatRequest } from '../index.js';
 import { loadFieldMapConfig } from '../../filters/utils/fieldmap-loader.js';
 import { createSnapshotWriter } from './snapshot-utils.js';
@@ -66,8 +66,6 @@ export async function runStandardChatRequestFilters(chatRequest, profile, contex
     }
     engine.registerFilter(new RequestToolCallsStringifyFilter());
     engine.registerFilter(new RequestToolChoicePolicyFilter());
-    // 统一将 Provider 请求转为非流式 Chat；流式语义由上层 SSE 合成处理
-    engine.registerFilter(new RequestStreamingToNonStreamingFilter());
     // FieldMap：保持与 Chat 入口一致，使用 openai-openai.fieldmap.json
     try {
         const cfg = await loadFieldMapConfig('openai-openai.fieldmap.json');

package/dist/conversion/shared/protocol-state.d.ts

@@ -0,0 +1,4 @@
+import type { ChatEnvelope } from '../hub/types/chat-envelope.js';
+import { type JsonObject } from '../hub/types/json.js';
+export declare function ensureProtocolState(metadata: ChatEnvelope['metadata'], protocol: string): JsonObject;
+export declare function getProtocolState(metadata: ChatEnvelope['metadata'] | undefined, protocol: string): JsonObject | undefined;

package/dist/conversion/shared/protocol-state.js

@@ -0,0 +1,23 @@
+import { isJsonObject } from '../hub/types/json.js';
+const PROTOCOL_STATE_KEY = 'protocolState';
+export function ensureProtocolState(metadata, protocol) {
+    if (!metadata[PROTOCOL_STATE_KEY] || !isJsonObject(metadata[PROTOCOL_STATE_KEY])) {
+        metadata[PROTOCOL_STATE_KEY] = {};
+    }
+    const container = metadata[PROTOCOL_STATE_KEY];
+    if (!isJsonObject(container[protocol])) {
+        container[protocol] = {};
+    }
+    return container[protocol];
+}
+export function getProtocolState(metadata, protocol) {
+    if (!metadata) {
+        return undefined;
+    }
+    const store = metadata[PROTOCOL_STATE_KEY];
+    if (!isJsonObject(store)) {
+        return undefined;
+    }
+    const node = store[protocol];
+    return isJsonObject(node) ? node : undefined;
+}

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

@@ -35,12 +35,11 @@ export async function runChatRequestToolFilters(chatRequest, options = {}) {
             /* optional */
         }
     }
-    const { RequestToolCallsStringifyFilter, RequestToolChoicePolicyFilter, RequestStreamingToNonStreamingFilter } = await import('../../filters/index.js');
+    const { RequestToolCallsStringifyFilter, RequestToolChoicePolicyFilter } = await import('../../filters/index.js');
     engine.registerFilter(new RequestToolCallsStringifyFilter());
     if (!isAnthropic) {
         engine.registerFilter(new RequestToolChoicePolicyFilter());
     }
-    engine.registerFilter(new RequestStreamingToNonStreamingFilter());
     try {
         const cfg = await loadFieldMapConfig('openai-openai.fieldmap.json');
         if (cfg)

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/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.6.0",
+  "version": "0.6.002",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",