@jsonstudio/rcc 0.89.164 → 0.89.333

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/compat/compat-types.d.ts

@@ -1,4 +1,11 @@
 import type { JsonObject, JsonValue } from '../../types/json.js';
+import type { FilterConfig as ShapeFilterConfig } from '../../../compat/actions/universal-shape-filter.js';
+import type { ResponseBlacklistConfig } from '../../../compat/actions/response-blacklist.js';
+import type { FieldMapping } from '../../../compat/actions/field-mapping.js';
+import type { RequestRulesConfig } from '../../../compat/actions/request-rules.js';
+import type { AutoThinkingConfig } from '../../../compat/actions/auto-thinking.js';
+import type { ResponseNormalizeConfig } from '../../../compat/actions/response-normalize.js';
+import type { ResponseValidateConfig } from '../../../compat/actions/response-validate.js';
 export type CompatDirection = 'request' | 'response';
 export interface CompatProfileConfig {
     id: string;
@@ -51,6 +58,46 @@ export type MappingInstruction = {
     fallback?: JsonValue;
 } | {
     action: 'convert_responses_output_to_choices';
+} | {
+    action: 'extract_glm_tool_markup';
+} | {
+    action: 'dto_unwrap';
+} | {
+    action: 'dto_rewrap';
+} | {
+    action: 'shape_filter';
+    config: ShapeFilterConfig;
+    target?: CompatDirection;
+} | {
+    action: 'field_map';
+    direction?: 'incoming' | 'outgoing';
+    config: FieldMapping[];
+} | {
+    action: 'tool_schema_sanitize';
+    mode?: 'glm_shell';
+} | {
+    action: 'apply_rules';
+    config: RequestRulesConfig;
+} | {
+    action: 'auto_thinking';
+    config: AutoThinkingConfig;
+} | {
+    action: 'snapshot';
+    phase: 'compat-pre' | 'compat-post';
+    channel?: string;
+} | {
+    action: 'resp_blacklist';
+    config: ResponseBlacklistConfig;
+} | {
+    action: 'response_normalize';
+    config?: ResponseNormalizeConfig;
+} | {
+    action: 'response_validate';
+    config?: ResponseValidateConfig;
+} | {
+    action: 'qwen_request_transform';
+} | {
+    action: 'qwen_response_transform';
 };
 export type FilterInstruction = {
     action: 'rate_limit_text';

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/hub-pipeline.d.ts

@@ -64,5 +64,7 @@ export declare class HubPipeline {
     private convertSsePayload;
     private resolveSseProtocol;
     private extractModelHint;
+    private resolveOutboundStreamIntent;
+    private applyOutboundStreamPreference;
 }
 export {};

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/hub-pipeline.js

@@ -142,6 +142,8 @@ export class HubPipeline {
         catch {
             // logging must not break routing
         }
+        const outboundStream = this.resolveOutboundStreamIntent(routing.target?.streaming);
+        this.applyOutboundStreamPreference(workingRequest, outboundStream);
         const outboundAdapterContext = this.buildAdapterContext(normalized, routing.target);
         if (routing.target?.compatibilityProfile) {
             outboundAdapterContext.compatibilityProfile = routing.target.compatibilityProfile;
@@ -226,7 +228,8 @@ export class HubPipeline {
             stream: normalized.stream,
             processMode: normalized.processMode,
             routeHint: normalized.routeHint,
-            target: routing.target
+            target: routing.target,
+            ...(typeof outboundStream === 'boolean' ? { providerStream: outboundStream } : {})
         };
         return {
             requestId: normalized.id,
@@ -508,6 +511,37 @@ export class HubPipeline {
         }
         return undefined;
     }
+    resolveOutboundStreamIntent(providerPreference) {
+        if (providerPreference === 'always') {
+            return true;
+        }
+        if (providerPreference === 'never') {
+            return false;
+        }
+        return undefined;
+    }
+    applyOutboundStreamPreference(request, stream) {
+        if (!request || typeof request !== 'object') {
+            return;
+        }
+        const parameters = request.parameters || {};
+        const nextParameters = { ...parameters };
+        if (typeof stream === 'boolean') {
+            nextParameters.stream = stream;
+        }
+        else if ('stream' in nextParameters) {
+            delete nextParameters.stream;
+        }
+        request.parameters = nextParameters;
+        if (request.metadata && typeof request.metadata === 'object') {
+            if (typeof stream === 'boolean') {
+                request.metadata.outboundStream = stream;
+            }
+            else if ('outboundStream' in request.metadata) {
+                delete request.metadata.outboundStream;
+            }
+        }
+    }
 }
 function normalizeToolCallIdStyleCandidate(value) {
     if (typeof value !== 'string') {

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage3_compat/index.js

@@ -5,7 +5,7 @@ function pickCompatProfile(adapterContext) {
 }
 export async function runReqOutboundStage3Compat(options) {
     const profile = pickCompatProfile(options.adapterContext);
-    const result = applyRequestCompat(profile, options.payload);
+    const result = applyRequestCompat(profile, options.payload, { adapterContext: options.adapterContext });
     options.stageRecorder?.record('req_outbound_stage3_compat', {
         applied: Boolean(result.appliedProfile),
         profile: result.appliedProfile || profile || 'passthrough'
@@ -14,7 +14,7 @@ export async function runReqOutboundStage3Compat(options) {
 }
 export function runRespInboundStageCompatResponse(options) {
     const profile = pickCompatProfile(options.adapterContext);
-    const result = applyResponseCompat(profile, options.payload);
+    const result = applyResponseCompat(profile, options.payload, { adapterContext: options.adapterContext });
     options.stageRecorder?.record('resp_inbound_stage_compat', {
         applied: Boolean(result.appliedProfile),
         profile: result.appliedProfile || profile || 'passthrough'

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/target-utils.js

@@ -12,6 +12,9 @@ export function applyTargetMetadata(metadata, target, routeName, originalModel)
     if (target.responsesConfig?.toolCallIdStyle) {
         metadata.toolCallIdStyle = target.responsesConfig.toolCallIdStyle;
     }
+    if (target.streaming) {
+        metadata.targetStreaming = target.streaming;
+    }
     if (originalModel && typeof originalModel === 'string' && originalModel.trim()) {
         const trimmed = originalModel.trim();
         if (typeof metadata.originalModelId !== 'string' || !metadata.originalModelId) {

package/node_modules/@jsonstudio/llms/dist/conversion/hub/response/response-runtime.js

@@ -3,7 +3,7 @@ import { deriveToolCallKey } from '../../shared/tool-call-utils.js';
 import { createBridgeActionState, runBridgeActionPipeline } from '../../shared/bridge-actions.js';
 import { resolveBridgePolicy, resolvePolicyActions } from '../../shared/bridge-policies.js';
 import { normalizeAnthropicToolName } from '../../shared/anthropic-message-utils.js';
-import { registerResponsesReasoning, consumeResponsesReasoning, registerResponsesOutputTextMeta, consumeResponsesOutputTextMeta } from '../../shared/responses-reasoning-registry.js';
+import { registerResponsesReasoning, consumeResponsesReasoning, registerResponsesOutputTextMeta, consumeResponsesOutputTextMeta, consumeResponsesPayloadSnapshot, registerResponsesPayloadSnapshot, consumeResponsesPassthrough, registerResponsesPassthrough } from '../../shared/responses-reasoning-registry.js';
 function flattenAnthropicContent(content) {
     if (typeof content === 'string')
         return content;
@@ -262,6 +262,20 @@ export function buildOpenAIChatFromAnthropicMessage(payload, options) {
     if (preservedOutputMeta) {
         chatResponse.__responses_output_text_meta = preservedOutputMeta;
     }
+    const payloadSnapshot = consumeResponsesPayloadSnapshot(chatResponse.id);
+    if (payloadSnapshot) {
+        registerResponsesPayloadSnapshot(chatResponse.id, payloadSnapshot);
+        if (typeof chatResponse.request_id !== 'string') {
+            chatResponse.request_id = chatResponse.id;
+        }
+    }
+    const passthroughPayload = consumeResponsesPassthrough(chatResponse.id);
+    if (passthroughPayload) {
+        registerResponsesPassthrough(chatResponse.id, passthroughPayload);
+        if (typeof chatResponse.request_id !== 'string') {
+            chatResponse.request_id = chatResponse.id;
+        }
+    }
     if (Object.keys(aliasCollector).length && !chatResponse.anthropicToolNameMap) {
         chatResponse.anthropicToolNameMap = aliasCollector;
     }
@@ -358,8 +372,11 @@ export function buildAnthropicResponseFromChat(chatResponse, options) {
             default: return 'end_turn';
         }
     })();
+    const canonicalId = typeof chatResponse.request_id === 'string'
+        ? chatResponse.request_id
+        : (typeof chatResponse.id === 'string' ? chatResponse.id : `resp_${Date.now()}`);
     const raw = {
-        id: typeof chatResponse.id === 'string' ? chatResponse.id : `resp_${Date.now()}`,
+        id: canonicalId,
         type: 'message',
         role: 'assistant',
         content: contentBlocks,

package/node_modules/@jsonstudio/llms/dist/conversion/responses/responses-host-policy.d.ts

@@ -0,0 +1,6 @@
+import type { ResponsesRequestContext } from './responses-openai-bridge.js';
+export interface ResponsesHostPolicyResult {
+    shouldStripHostManagedFields: boolean;
+    targetProtocol: string;
+}
+export declare function evaluateResponsesHostPolicy(context?: ResponsesRequestContext, targetProtocol?: string): ResponsesHostPolicyResult;

package/node_modules/@jsonstudio/llms/dist/conversion/responses/responses-host-policy.js

@@ -0,0 +1,14 @@
+export function evaluateResponsesHostPolicy(context, targetProtocol) {
+    const protocol = typeof targetProtocol === 'string' && targetProtocol.trim()
+        ? targetProtocol
+        : (typeof context?.targetProtocol === 'string' && context.targetProtocol.trim()
+            ? context.targetProtocol
+            : 'responses');
+    const normalized = protocol.toLowerCase();
+    const shouldStrip = normalized !== 'openai-responses' &&
+        normalized !== 'responses';
+    return {
+        shouldStripHostManagedFields: shouldStrip,
+        targetProtocol: normalized
+    };
+}

package/node_modules/@jsonstudio/llms/dist/conversion/responses/responses-openai-bridge.js

@@ -1,4 +1,5 @@
 import { ensureBridgeInstructions } from '../shared/bridge-instructions.js';
+import { evaluateResponsesHostPolicy } from './responses-host-policy.js';
 import { convertMessagesToBridgeInput, convertBridgeInputToChatMessages } from '../shared/bridge-message-utils.js';
 import { createToolCallIdTransformer, enforceToolCallIdStyle, resolveToolCallIdStyle, stripInternalToolingMetadata, sanitizeResponsesFunctionName } from '../shared/responses-tool-utils.js';
 import { mapBridgeToolsToChat, mapChatToolsToBridge } from '../shared/tool-mapping.js';
@@ -8,6 +9,7 @@ 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);
 }
@@ -257,12 +259,20 @@ export function buildResponsesRequestFromChat(payload, ctx, extras) {
     else if (metadataExtraFields?.include !== undefined && out.include === undefined) {
         out.include = metadataExtraFields.include;
     }
-    if (ctx?.store !== undefined && out.store === undefined) {
+    const stripHostFields = shouldStripHostManagedFields(ctx);
+    if (stripHostFields) {
+        delete out.store;
+    }
+    else if (ctx?.store !== undefined && out.store === undefined) {
         out.store = ctx.store;
     }
     else if (metadataExtraFields?.store !== undefined && out.store === undefined) {
         out.store = metadataExtraFields.store;
     }
+    else if (out.store === undefined) {
+        // Chat 入口无 store 概念，但 Responses provider 仍要求显式声明。
+        out.store = false;
+    }
     if (ctx?.toolChoice !== undefined && out.tool_choice === undefined) {
         out.tool_choice = ctx.toolChoice;
     }
@@ -433,6 +443,17 @@ 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;
     }
@@ -499,10 +520,22 @@ export function buildResponsesPayloadFromChat(payload, context) {
         out.required_action = outputBuild.requiredAction;
     // Do not inject captured tool results here; keep Chat back-half behavior standard.
     if (context) {
-        for (const k of ['metadata', 'parallel_tool_calls', 'tool_choice', 'include', 'store']) {
+        for (const k of ['metadata', 'parallel_tool_calls', 'tool_choice', 'include']) {
             if (context[k] !== undefined)
                 out[k] = context[k];
         }
+        if (!shouldStripHostManagedFields(context) && context.store !== undefined) {
+            out.store = context.store;
+        }
+    }
+    if (typeof response.request_id === 'string') {
+        out.request_id = response.request_id;
+    }
+    else if (typeof response.id === 'string') {
+        out.request_id = response.id;
+    }
+    else if (typeof context?.requestId === 'string') {
+        out.request_id = context.requestId;
     }
     if (out.metadata) {
         stripInternalToolingMetadata(out.metadata);
@@ -524,6 +557,22 @@ function unwrapData(value) {
     }
     return current;
 }
+function resolveSnapshotLookupKey(response, context) {
+    if (typeof response?.request_id === 'string') {
+        return response.request_id;
+    }
+    if (typeof context?.requestId === 'string') {
+        return context.requestId;
+    }
+    if (typeof response?.id === 'string') {
+        return response.id;
+    }
+    return undefined;
+}
+function shouldStripHostManagedFields(context) {
+    const result = evaluateResponsesHostPolicy(context, typeof context?.targetProtocol === 'string' ? context?.targetProtocol : undefined);
+    return result.shouldStripHostManagedFields;
+}
 export function extractRequestIdFromResponse(response) {
     if (response && typeof response === 'object' && 'metadata' in response && response.metadata && typeof response.metadata === 'object') {
         const meta = response.metadata;

package/node_modules/@jsonstudio/llms/dist/conversion/shared/anthropic-message-utils.js

@@ -336,6 +336,12 @@ export function buildOpenAIChatFromAnthropic(payload) {
         request.top_p = body.top_p;
     if (typeof body.stream === 'boolean')
         request.stream = body.stream;
+    if (typeof body.id === 'string') {
+        request.request_id = body.id;
+    }
+    else if (typeof body.request_id === 'string') {
+        request.request_id = body.request_id;
+    }
     if ('tool_choice' in body)
         request.tool_choice = body.tool_choice;
     const normalizedTools = mapAnthropicToolsToChat(body.tools);

package/node_modules/@jsonstudio/llms/dist/conversion/shared/responses-reasoning-registry.d.ts

@@ -6,3 +6,7 @@ export declare function registerResponsesReasoning(id: unknown, segments: string
 export declare function consumeResponsesReasoning(id: unknown): string[] | undefined;
 export declare function registerResponsesOutputTextMeta(id: unknown, meta: ResponsesOutputTextMeta | undefined): void;
 export declare function consumeResponsesOutputTextMeta(id: unknown): ResponsesOutputTextMeta | undefined;
+export declare function registerResponsesPayloadSnapshot(id: unknown, snapshot: Record<string, unknown> | undefined): void;
+export declare function consumeResponsesPayloadSnapshot(id: unknown): Record<string, unknown> | undefined;
+export declare function registerResponsesPassthrough(id: unknown, payload: Record<string, unknown> | undefined): void;
+export declare function consumeResponsesPassthrough(id: unknown): Record<string, unknown> | undefined;

package/node_modules/@jsonstudio/llms/dist/conversion/shared/responses-reasoning-registry.js

@@ -11,10 +11,27 @@ function pruneEntry(id) {
     const entry = registry.get(id);
     if (!entry)
         return;
-    if (!entry.reasoning && !entry.outputText) {
+    if (!entry.reasoning && !entry.outputText && !entry.payloadSnapshot && !entry.passthroughPayload) {
         registry.delete(id);
     }
 }
+function cloneSnapshot(snapshot) {
+    try {
+        const structuredCloneImpl = globalThis.structuredClone;
+        if (typeof structuredCloneImpl === 'function') {
+            return structuredCloneImpl(snapshot);
+        }
+    }
+    catch {
+        /* ignore structuredClone failures */
+    }
+    try {
+        return JSON.parse(JSON.stringify(snapshot));
+    }
+    catch {
+        return undefined;
+    }
+}
 export function registerResponsesReasoning(id, segments) {
     if (typeof id !== 'string')
         return;
@@ -59,3 +76,47 @@ export function consumeResponsesOutputTextMeta(id) {
     pruneEntry(id);
     return value;
 }
+export function registerResponsesPayloadSnapshot(id, snapshot) {
+    if (typeof id !== 'string')
+        return;
+    if (!snapshot || typeof snapshot !== 'object')
+        return;
+    const clone = cloneSnapshot(snapshot);
+    if (!clone)
+        return;
+    const entry = ensureEntry(id);
+    entry.payloadSnapshot = clone;
+}
+export function consumeResponsesPayloadSnapshot(id) {
+    if (typeof id !== 'string')
+        return undefined;
+    const entry = registry.get(id);
+    if (!entry?.payloadSnapshot)
+        return undefined;
+    const clone = cloneSnapshot(entry.payloadSnapshot) ?? entry.payloadSnapshot;
+    entry.payloadSnapshot = undefined;
+    pruneEntry(id);
+    return clone;
+}
+export function registerResponsesPassthrough(id, payload) {
+    if (typeof id !== 'string')
+        return;
+    if (!payload || typeof payload !== 'object')
+        return;
+    const clone = cloneSnapshot(payload);
+    if (!clone)
+        return;
+    const entry = ensureEntry(id);
+    entry.passthroughPayload = clone;
+}
+export function consumeResponsesPassthrough(id) {
+    if (typeof id !== 'string')
+        return undefined;
+    const entry = registry.get(id);
+    if (!entry?.passthroughPayload)
+        return undefined;
+    const clone = cloneSnapshot(entry.passthroughPayload) ?? entry.passthroughPayload;
+    entry.passthroughPayload = undefined;
+    pruneEntry(id);
+    return clone;
+}

package/node_modules/@jsonstudio/llms/dist/conversion/shared/responses-response-utils.js

@@ -4,6 +4,7 @@ import { extractOutputSegments } from './output-content-normalizer.js';
 import { sanitizeReasoningTaggedText } from './reasoning-utils.js';
 import { createBridgeActionState, runBridgeActionPipeline } from './bridge-actions.js';
 import { resolveBridgePolicy, resolvePolicyActions } from './bridge-policies.js';
+import { registerResponsesPayloadSnapshot, registerResponsesPassthrough } from './responses-reasoning-registry.js';
 function selectCallId(entry) {
     const candidates = [
         entry?.call_id,
@@ -153,13 +154,27 @@ function collectRawReasoningSegments(response) {
     }
     return segments;
 }
+function registerPassthroughSnapshot(payload) {
+    const ids = new Set();
+    const requestId = typeof payload?.request_id === 'string' ? payload.request_id.trim() : '';
+    const id = typeof payload?.id === 'string' ? payload.id.trim() : '';
+    if (requestId.length)
+        ids.add(requestId);
+    if (id.length)
+        ids.add(id);
+    for (const candidate of ids) {
+        registerResponsesPassthrough(candidate, payload);
+    }
+}
 export function buildChatResponseFromResponses(payload) {
     if (!payload || typeof payload !== 'object')
         return payload;
     const response = unwrapResponsesResponse(payload);
     if (!response) {
-        if (Array.isArray(payload.choices))
+        if (Array.isArray(payload.choices)) {
+            registerPassthroughSnapshot(payload);
             return payload;
+        }
         return payload;
     }
     const id = typeof response.id === 'string' ? response.id : `resp_${Date.now()}`;
@@ -235,5 +250,12 @@ export function buildChatResponseFromResponses(payload) {
     if (usage !== undefined) {
         chat.usage = usage;
     }
+    const requestId = typeof response.request_id === 'string'
+        ? response.request_id
+        : (typeof response.id === 'string' ? response.id : undefined);
+    if (requestId) {
+        chat.request_id = requestId;
+    }
+    registerResponsesPayloadSnapshot(id, response);
     return chat;
 }

package/node_modules/@jsonstudio/llms/dist/conversion/shared/tool-canonicalizer.d.ts

@@ -0,0 +1,2 @@
+export declare function canonicalizeChatResponseTools(payload: unknown): unknown;
+export default canonicalizeChatResponseTools;

package/node_modules/@jsonstudio/llms/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 { normalizeChatResponseReasoningTools } from './reasoning-tool-normalizer.js';
 import { createSnapshotWriter } from './snapshot-utils.js';
 const REQUEST_FILTER_STAGES = [
     'request_pre',
@@ -191,6 +192,16 @@ export async function runChatResponseToolFilters(chatJson, options = {}) {
         snapshot(stage, payload);
     };
     recordStage('resp_process_tool_filters_input', chatJson);
+    try {
+        if (chatJson && typeof chatJson === 'object') {
+            normalizeChatResponseReasoningTools(chatJson, {
+                idPrefixBase: 'reasoning_choice'
+            });
+        }
+    }
+    catch {
+        // best-effort; do not block response flow on reasoning parsing issues
+    }
     const engine = new FilterEngine();
     const registeredStages = new Set();
     const register = (filter) => {