@jsonstudio/llms 0.6.1164 → 0.6.1354

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

@@ -55,11 +55,7 @@ function mapToolOutputs(entries, missing) {
     });
     return outputs.length ? outputs : undefined;
 }
-function deriveResumeToolOutputs(ctx) {
-    if (!ctx || typeof ctx !== 'object') {
-        return undefined;
-    }
-    const resume = ctx.responsesResume;
+function deriveResumeToolOutputsFromResume(resume) {
     if (!resume || typeof resume !== 'object') {
         return undefined;
     }
@@ -252,12 +248,7 @@ function readResponsesResumeFromSemantics(chat) {
 }
 function selectResponsesContextSnapshot(chat, envelopeMetadata) {
     const semanticsContext = readResponsesContextFromSemantics(chat);
-    const metadataContextCandidate = chat.metadata?.responsesContext;
-    const metadataContext = metadataContextCandidate && isJsonObject(metadataContextCandidate)
-        ? jsonClone(metadataContextCandidate)
-        : undefined;
     const context = semanticsContext ??
-        metadataContext ??
         {
             metadata: envelopeMetadata
         };
@@ -267,10 +258,7 @@ function selectResponsesContextSnapshot(chat, envelopeMetadata) {
     }
     return context;
 }
-function resolveSubmitResponseId(ctx, responsesContext) {
-    const resumeMeta = ctx.responsesResume && typeof ctx.responsesResume === 'object'
-        ? ctx.responsesResume
-        : undefined;
+function resolveSubmitResponseId(resumeMeta, responsesContext) {
     const resumeId = typeof resumeMeta?.restoredFromResponseId === 'string'
         ? resumeMeta.restoredFromResponseId.trim()
         : undefined;
@@ -342,7 +330,7 @@ function extractCapturedToolOutputs(responsesContext) {
     });
     return entries;
 }
-function collectSubmitToolOutputs(chat, ctx, responsesContext) {
+function collectSubmitToolOutputs(chat, responsesContext) {
     const outputs = [];
     const seen = new Set();
     const append = (idSeed, outputSeed, name) => {
@@ -369,11 +357,9 @@ function collectSubmitToolOutputs(chat, ctx, 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 resume = readResponsesResumeFromSemantics(chat);
         const detailed = Array.isArray(resume?.toolOutputsDetailed)
-            ? resume?.toolOutputsDetailed
+            ? (resume.toolOutputsDetailed ?? undefined)
             : undefined;
         if (detailed) {
             detailed.forEach((entry, index) => {
@@ -417,17 +403,23 @@ function resolveSubmitModel(chat, responsesContext) {
     return undefined;
 }
 function buildSubmitToolOutputsPayload(chat, ctx, responsesContext) {
-    const responseId = resolveSubmitResponseId(ctx, responsesContext);
+    const resumeMeta = (() => {
+        try {
+            const resume = readResponsesResumeFromSemantics(chat);
+            return resume && typeof resume === 'object' && !Array.isArray(resume) ? resume : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    })();
+    const responseId = resolveSubmitResponseId(resumeMeta, responsesContext);
     if (!responseId) {
         throw new Error('Submit tool outputs requires response_id from Responses resume context');
     }
-    const toolOutputs = collectSubmitToolOutputs(chat, ctx, responsesContext);
+    const toolOutputs = collectSubmitToolOutputs(chat, 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
@@ -454,25 +446,13 @@ export class ResponsesSemanticMapper {
         const missingFields = [];
         const messages = normalizeMessages(request.messages, 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 };
         if (missingFields.length) {
             metadata.missingFields = missingFields;
         }
-        if (responsesContext.responseFormat) {
-            metadata.responseFormat = jsonClone(responsesContext.responseFormat);
-        }
-        metadata.responsesContext = jsonClone(responsesContext);
-        const resumeNode = ctx.responsesResume && isJsonObject(ctx.responsesResume)
-            ? ctx.responsesResume
-            : undefined;
-        const semantics = attachResponsesSemantics(undefined, responsesContext, resumeNode);
+        // Keep responses protocol semantics in chat.semantics (not metadata).
+        const semantics = attachResponsesSemantics(undefined, responsesContext, undefined);
         return {
             messages,
             tools: normalizeTools(toolsNormalized, missingFields),

package/dist/conversion/hub/pipeline/compat/compat-pipeline-executor.js

@@ -13,6 +13,7 @@ import { extractGlmToolMarkup } from '../../../compat/actions/glm-tool-extractio
 import { applyGlmWebSearchRequestTransform } from '../../../compat/actions/glm-web-search.js';
 import { applyGeminiWebSearchCompat } from '../../../compat/actions/gemini-web-search.js';
 import { applyIflowWebSearchRequestTransform } from '../../../compat/actions/iflow-web-search.js';
+import { applyIflowToolTextFallback } from '../../../compat/actions/iflow-tool-text-fallback.js';
 import { applyGlmImageContentTransform } from '../../../compat/actions/glm-image-content.js';
 import { applyGlmVisionPromptTransform } from '../../../compat/actions/glm-vision-prompt.js';
 import { applyClaudeThinkingToolSchemaCompat } from '../../../compat/actions/claude-thinking-tools.js';
@@ -189,6 +190,11 @@ function applyMapping(root, mapping, state) {
                 replaceRoot(root, applyIflowWebSearchRequestTransform(root, state.adapterContext));
             }
             break;
+        case 'iflow_tool_text_fallback':
+            if (state.direction === 'request') {
+                replaceRoot(root, applyIflowToolTextFallback(root, { models: mapping.models }));
+            }
+            break;
         case 'claude_thinking_tool_schema':
             if (state.direction === 'request') {
                 replaceRoot(root, applyClaudeThinkingToolSchemaCompat(root, state.adapterContext));

package/dist/conversion/hub/pipeline/compat/compat-types.d.ts

@@ -111,6 +111,9 @@ export type MappingInstruction = {
     action: 'gemini_web_search_request';
 } | {
     action: 'iflow_web_search_request';
+} | {
+    action: 'iflow_tool_text_fallback';
+    models?: string[];
 } | {
     action: 'claude_thinking_tool_schema';
 };

package/dist/conversion/hub/pipeline/hub-pipeline/adapter-context.d.ts

@@ -0,0 +1,10 @@
+import type { StandardizedRequest, ProcessedRequest } from '../../types/standardized.js';
+import type { AdapterContext } from '../../types/chat-envelope.js';
+import type { StageRecorder } from '../../format-adapters/index.js';
+import type { NormalizedRequest, TargetMetadata } from './types.js';
+export declare function buildAdapterContext(normalized: NormalizedRequest, target?: TargetMetadata): AdapterContext;
+export declare function maybeCreateStageRecorder(context: AdapterContext, endpoint?: string, options?: {
+    disableSnapshots?: boolean;
+}): StageRecorder | undefined;
+export declare function resolveOutboundStreamIntent(providerPreference?: TargetMetadata['streaming']): boolean | undefined;
+export declare function applyOutboundStreamPreference(request: StandardizedRequest | ProcessedRequest, stream: boolean | undefined): StandardizedRequest | ProcessedRequest;

package/dist/conversion/hub/pipeline/hub-pipeline/adapter-context.js

@@ -0,0 +1,134 @@
+import { jsonClone } from '../../types/json.js';
+import { applyHubOperations } from '../../ops/operations.js';
+import { createSnapshotRecorder } from '../../snapshot-recorder.js';
+import { shouldRecordSnapshots } from '../../../shared/snapshot-utils.js';
+import { cloneRuntimeMetadata } from '../../../shared/runtime-metadata.js';
+function normalizeToolCallIdStyleCandidate(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'fc') {
+        return 'fc';
+    }
+    if (normalized === 'preserve') {
+        return 'preserve';
+    }
+    return undefined;
+}
+export function buildAdapterContext(normalized, target) {
+    const metadata = normalized.metadata || {};
+    const providerProtocol = target?.outboundProfile || normalized.providerProtocol;
+    const providerId = (target?.providerKey || metadata.providerKey);
+    const routeId = metadata.routeName;
+    const profileId = (target?.providerKey || metadata.pipelineId);
+    const streamingHint = normalized.stream === true ? 'force' : normalized.stream === false ? 'disable' : 'auto';
+    const toolCallIdStyle = normalizeToolCallIdStyleCandidate(metadata.toolCallIdStyle);
+    const adapterContext = {
+        requestId: normalized.id,
+        entryEndpoint: normalized.entryEndpoint || '/v1/chat/completions',
+        providerProtocol,
+        providerId,
+        routeId,
+        profileId,
+        streamingHint,
+        toolCallIdStyle
+    };
+    const runtime = metadata.runtime;
+    if (runtime && typeof runtime === 'object' && !Array.isArray(runtime)) {
+        adapterContext.runtime = jsonClone(runtime);
+    }
+    const clientRequestId = typeof metadata.clientRequestId === 'string'
+        ? metadata.clientRequestId.trim()
+        : '';
+    if (clientRequestId) {
+        adapterContext.clientRequestId = clientRequestId;
+    }
+    const groupRequestId = typeof metadata.groupRequestId === 'string'
+        ? metadata.groupRequestId.trim()
+        : '';
+    if (groupRequestId) {
+        adapterContext.groupRequestId = groupRequestId;
+    }
+    if (typeof metadata.originalModelId === 'string') {
+        adapterContext.originalModelId = metadata.originalModelId;
+    }
+    if (typeof metadata.clientModelId === 'string') {
+        adapterContext.clientModelId = metadata.clientModelId;
+    }
+    if (typeof metadata.assignedModelId === 'string') {
+        adapterContext.modelId = metadata.assignedModelId;
+    }
+    const rt = cloneRuntimeMetadata(metadata);
+    if (rt) {
+        adapterContext.__rt = rt;
+    }
+    const sessionId = typeof metadata.sessionId === 'string'
+        ? metadata.sessionId.trim()
+        : '';
+    if (sessionId) {
+        adapterContext.sessionId = sessionId;
+    }
+    const conversationId = typeof metadata.conversationId === 'string'
+        ? metadata.conversationId.trim()
+        : '';
+    if (conversationId) {
+        adapterContext.conversationId = conversationId;
+    }
+    const clientConnectionState = metadata.clientConnectionState;
+    if (clientConnectionState && typeof clientConnectionState === 'object' && !Array.isArray(clientConnectionState)) {
+        const stateRecord = clientConnectionState;
+        adapterContext.clientConnectionState = clientConnectionState;
+        if (typeof stateRecord.disconnected === 'boolean') {
+            adapterContext.clientDisconnected = stateRecord.disconnected;
+        }
+    }
+    const clientDisconnectedRaw = metadata.clientDisconnected;
+    if (clientDisconnectedRaw === true ||
+        (typeof clientDisconnectedRaw === 'string' && clientDisconnectedRaw.trim().toLowerCase() === 'true')) {
+        adapterContext.clientDisconnected = true;
+    }
+    if (target?.compatibilityProfile && typeof target.compatibilityProfile === 'string') {
+        adapterContext.compatibilityProfile = target.compatibilityProfile;
+    }
+    return adapterContext;
+}
+export function maybeCreateStageRecorder(context, endpoint, options) {
+    if (options?.disableSnapshots === true) {
+        return undefined;
+    }
+    if (!shouldRecordSnapshots()) {
+        return undefined;
+    }
+    const effectiveEndpoint = endpoint || context.entryEndpoint || '/v1/chat/completions';
+    try {
+        return createSnapshotRecorder(context, effectiveEndpoint);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function resolveOutboundStreamIntent(providerPreference) {
+    if (providerPreference === 'always') {
+        return true;
+    }
+    if (providerPreference === 'never') {
+        return false;
+    }
+    return undefined;
+}
+export function applyOutboundStreamPreference(request, stream) {
+    if (!request || typeof request !== 'object') {
+        return request;
+    }
+    const ops = [];
+    if (typeof stream === 'boolean') {
+        ops.push({ op: 'set_request_parameter_fields', fields: { stream } });
+        ops.push({ op: 'set_request_metadata_fields', fields: { outboundStream: stream } });
+    }
+    else {
+        ops.push({ op: 'unset_request_parameter_keys', keys: ['stream'] });
+        ops.push({ op: 'unset_request_metadata_keys', keys: ['outboundStream'] });
+    }
+    return applyHubOperations(request, ops);
+}

package/dist/conversion/hub/pipeline/hub-pipeline/anthropic-alias-map.d.ts

@@ -0,0 +1,6 @@
+import type { AdapterContext, ChatEnvelope } from '../../types/chat-envelope.js';
+export declare function captureAnthropicToolNameAliasMap(options: {
+    entryEndpoint: string;
+    adapterContext: AdapterContext;
+    chatEnvelope: ChatEnvelope;
+}): void;

package/dist/conversion/hub/pipeline/hub-pipeline/anthropic-alias-map.js

@@ -0,0 +1,79 @@
+import { isJsonObject, jsonClone } from '../../types/json.js';
+function coerceAliasMap(candidate) {
+    if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) {
+        return undefined;
+    }
+    const normalized = {};
+    for (const [key, value] of Object.entries(candidate)) {
+        if (typeof key !== 'string' || typeof value !== 'string') {
+            continue;
+        }
+        const trimmedKey = key.trim();
+        const trimmedValue = value.trim();
+        if (!trimmedKey.length || !trimmedValue.length) {
+            continue;
+        }
+        normalized[trimmedKey] = trimmedValue;
+    }
+    return Object.keys(normalized).length ? normalized : undefined;
+}
+function readAliasMapFromSemantics(chatEnvelope) {
+    if (!chatEnvelope?.semantics || typeof chatEnvelope.semantics !== 'object') {
+        return undefined;
+    }
+    const node = chatEnvelope.semantics.tools;
+    if (!node || !isJsonObject(node)) {
+        return undefined;
+    }
+    const candidate = node.toolNameAliasMap ?? node.toolAliasMap;
+    return coerceAliasMap(candidate);
+}
+function shouldCapture(entryEndpoint) {
+    return typeof entryEndpoint === 'string' && entryEndpoint.toLowerCase().includes('/v1/messages');
+}
+function resolveAliasMapFromSources(adapterContext, chatEnvelope) {
+    const fromContext = coerceAliasMap(adapterContext.anthropicToolNameMap);
+    if (fromContext) {
+        return fromContext;
+    }
+    const metadataNode = chatEnvelope.metadata;
+    const direct = metadataNode ? coerceAliasMap(metadataNode.anthropicToolNameMap) : undefined;
+    if (direct) {
+        return direct;
+    }
+    const contextNode = metadataNode && metadataNode.context && typeof metadataNode.context === 'object'
+        ? metadataNode.context
+        : undefined;
+    const fromContextNode = coerceAliasMap(contextNode?.anthropicToolNameMap);
+    if (fromContextNode) {
+        return fromContextNode;
+    }
+    return readAliasMapFromSemantics(chatEnvelope);
+}
+export function captureAnthropicToolNameAliasMap(options) {
+    if (!shouldCapture(options.entryEndpoint)) {
+        return;
+    }
+    const aliasMap = resolveAliasMapFromSources(options.adapterContext, options.chatEnvelope);
+    if (!aliasMap) {
+        return;
+    }
+    // Tool name alias map is mappable semantics and must live in chat.semantics (never metadata).
+    try {
+        const chatEnvelope = options.chatEnvelope;
+        if (!chatEnvelope.semantics || typeof chatEnvelope.semantics !== 'object' || Array.isArray(chatEnvelope.semantics)) {
+            chatEnvelope.semantics = {};
+        }
+        const semantics = chatEnvelope.semantics;
+        if (!semantics.tools || !isJsonObject(semantics.tools)) {
+            semantics.tools = {};
+        }
+        const toolsNode = semantics.tools;
+        if (!isJsonObject(toolsNode.toolNameAliasMap) && !isJsonObject(toolsNode.toolAliasMap)) {
+            toolsNode.toolNameAliasMap = jsonClone(aliasMap);
+        }
+    }
+    catch {
+        // best-effort: never block request handling due to alias map propagation failures
+    }
+}

package/dist/conversion/hub/pipeline/hub-pipeline/apply-patch-tool-mode.d.ts

@@ -0,0 +1,3 @@
+import type { ApplyPatchToolMode } from './types.js';
+export declare function resolveApplyPatchToolModeFromEnv(): ApplyPatchToolMode | undefined;
+export declare function resolveApplyPatchToolModeFromTools(toolsRaw: unknown): ApplyPatchToolMode | undefined;

package/dist/conversion/hub/pipeline/hub-pipeline/apply-patch-tool-mode.js

@@ -0,0 +1,46 @@
+function isTruthyEnv(value) {
+    const v = typeof value === 'string' ? value.trim().toLowerCase() : '';
+    return v === '1' || v === 'true' || v === 'yes' || v === 'on';
+}
+export function resolveApplyPatchToolModeFromEnv() {
+    const rawMode = String(process.env.RCC_APPLY_PATCH_TOOL_MODE || process.env.ROUTECODEX_APPLY_PATCH_TOOL_MODE || '')
+        .trim()
+        .toLowerCase();
+    if (rawMode === 'freeform')
+        return 'freeform';
+    if (rawMode === 'schema' || rawMode === 'json_schema')
+        return 'schema';
+    const freeformFlag = process.env.RCC_APPLY_PATCH_FREEFORM || process.env.ROUTECODEX_APPLY_PATCH_FREEFORM;
+    if (isTruthyEnv(freeformFlag))
+        return 'freeform';
+    return undefined;
+}
+export function resolveApplyPatchToolModeFromTools(toolsRaw) {
+    if (!Array.isArray(toolsRaw) || toolsRaw.length === 0) {
+        return undefined;
+    }
+    for (const entry of toolsRaw) {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry))
+            continue;
+        const record = entry;
+        const type = typeof record.type === 'string' ? record.type.trim().toLowerCase() : '';
+        if (type && type !== 'function')
+            continue;
+        const fn = record.function && typeof record.function === 'object' && !Array.isArray(record.function)
+            ? record.function
+            : undefined;
+        const name = typeof fn?.name === 'string' ? fn.name.trim().toLowerCase() : '';
+        if (name !== 'apply_patch')
+            continue;
+        const format = typeof record.format === 'string'
+            ? record.format.trim().toLowerCase()
+            : typeof fn?.format === 'string'
+                ? String(fn.format).trim().toLowerCase()
+                : '';
+        if (format === 'freeform')
+            return 'freeform';
+        // If apply_patch is present without explicit freeform marker, default to schema mode.
+        return 'schema';
+    }
+    return undefined;
+}

package/dist/conversion/hub/pipeline/hub-pipeline/execute-chat-process-entry.d.ts

@@ -0,0 +1,8 @@
+import type { VirtualRouterEngine } from '../../../../router/virtual-router/engine.js';
+import type { HubPipelineConfig, HubPipelineResult, NormalizedRequest, ProviderProtocol, RequestStageHooks } from './types.js';
+export declare function executeChatProcessEntryPipeline(options: {
+    config: HubPipelineConfig;
+    routerEngine: VirtualRouterEngine;
+    normalized: NormalizedRequest;
+    resolveProtocolHooks: (protocol: ProviderProtocol) => RequestStageHooks<Record<string, unknown>> | undefined;
+}): Promise<HubPipelineResult>;