@jsonstudio/llms 0.6.2172 → 0.6.2979

package/dist/conversion/hub/process/client-inject-readiness.d.ts

@@ -0,0 +1 @@
+export declare function isClientInjectReady(metadata: Record<string, unknown>): boolean;

package/dist/conversion/hub/process/client-inject-readiness.js

@@ -0,0 +1,4 @@
+import { resolveClientInjectReadyWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+export function isClientInjectReady(metadata) {
+    return resolveClientInjectReadyWithNative(metadata);
+}

package/dist/conversion/hub/registry.js

@@ -6,6 +6,7 @@ import { AnthropicSemanticMapper } from './semantic-mappers/anthropic-mapper.js'
 import { ResponsesSemanticMapper } from './semantic-mappers/responses-mapper.js';
 import { GeminiSemanticMapper } from './semantic-mappers/gemini-mapper.js';
 import { GeminiFormatAdapter } from './format-adapters/gemini-format-adapter.js';
+import { normalizeProviderProtocolTokenWithNative } from '../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
 export const HUB_PROTOCOL_REGISTRY = {
     'openai-chat': {
         protocol: 'openai-chat',
@@ -87,9 +88,11 @@ function instantiateOutbound(factory) {
     };
 }
 export function createProtocolPlans(protocol) {
-    const definition = HUB_PROTOCOL_REGISTRY[protocol];
+    const normalizedProtocol = normalizeProviderProtocolTokenWithNative(protocol);
+    const protocolKey = normalizedProtocol ?? protocol;
+    const definition = HUB_PROTOCOL_REGISTRY[protocolKey];
     if (!definition) {
-        throw new Error(`Unknown hub protocol: ${protocol}`);
+        throw new Error(`Unknown hub protocol: ${protocolKey}`);
     }
     return {
         inbound: instantiateInbound(definition.inbound),

package/dist/conversion/hub/response/chat-response-utils.js

@@ -1,89 +1,8 @@
-function extractMessageContent(message) {
-    const content = (message && typeof message === 'object') ? message.content : undefined;
-    if (Array.isArray(content)) {
-        return content
-            .map((part) => {
-            if (!part)
-                return '';
-            if (typeof part === 'string')
-                return part;
-            if (typeof part.text === 'string')
-                return part.text;
-            if (typeof part.content === 'string')
-                return part.content;
-            return '';
-        })
-            .filter(Boolean)
-            .join('\n');
-    }
-    if (typeof content === 'string')
-        return content;
-    return '';
-}
-function mapToolCalls(toolCalls) {
-    if (!Array.isArray(toolCalls))
-        return undefined;
-    return toolCalls
-        .map((tc) => {
-        if (!tc || typeof tc !== 'object')
-            return null;
-        const fn = tc.function || {};
-        if (typeof fn?.name !== 'string')
-            return null;
-        const args = typeof fn?.arguments === 'string' ? fn.arguments : (() => {
-            try {
-                return JSON.stringify(fn?.arguments ?? {});
-            }
-            catch {
-                return '{}';
-            }
-        })();
-        return {
-            id: typeof tc.id === 'string' ? tc.id : `call_${Math.random().toString(36).slice(2, 10)}`,
-            type: 'function',
-            function: {
-                name: fn.name,
-                arguments: args
-            }
-        };
-    })
-        .filter(Boolean);
-}
+import { buildProcessedRequestFromChatResponseWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-node-result-semantics.js';
 export function buildProcessedRequestFromChatResponse(chatResponse, options) {
     const streamingEnabled = options?.stream === true;
-    const firstChoice = Array.isArray(chatResponse?.choices) ? chatResponse.choices[0] : null;
-    const msg = firstChoice?.message || {};
-    const content = extractMessageContent(msg);
-    const toolCalls = mapToolCalls(msg?.tool_calls);
-    const assistantMessage = {
-        role: 'assistant',
-        content,
-        tool_calls: toolCalls
-    };
-    const processedRequest = {
-        model: typeof chatResponse?.model === 'string' ? chatResponse.model : 'unknown',
-        messages: [assistantMessage],
-        tools: undefined,
-        parameters: {},
-        metadata: {
-            originalEndpoint: 'openai-chat',
-            ...(streamingEnabled ? { stream: true } : {})
-        },
-        processed: {
-            timestamp: Date.now(),
-            appliedRules: ['response-pipeline'],
-            status: 'success'
-        },
-        processingMetadata: {
-            streaming: {
-                enabled: streamingEnabled,
-                chunkCount: 0,
-                totalTokens: typeof chatResponse?.usage?.completion_tokens === 'number'
-                    ? chatResponse.usage.completion_tokens
-                    : 0
-            },
-            context: {}
-        }
-    };
-    return processedRequest;
+    const payload = chatResponse && typeof chatResponse === 'object' && !Array.isArray(chatResponse)
+        ? chatResponse
+        : { choices: [] };
+    return buildProcessedRequestFromChatResponseWithNative(payload, streamingEnabled);
 }

package/dist/conversion/hub/response/provider-response.d.ts

@@ -32,6 +32,15 @@ export interface ProviderResponseConversionOptions {
         body: JsonObject;
         metadata?: JsonObject;
     }) => Promise<ProviderResponseConversionResult>;
+    clientInjectDispatch?: (options: {
+        entryEndpoint: string;
+        requestId: string;
+        body?: JsonObject;
+        metadata?: JsonObject;
+    }) => Promise<{
+        ok: boolean;
+        reason?: string;
+    }>;
 }
 export interface ProviderResponseConversionResult {
     body?: JsonObject;

package/dist/conversion/hub/response/provider-response.js

@@ -18,6 +18,7 @@ import { recordResponsesResponse } from '../../shared/responses-conversation-sto
 import { ProviderProtocolError } from '../../shared/errors.js';
 import { readRuntimeMetadata } from '../../shared/runtime-metadata.js';
 import { commitClockReservation, resolveClockConfig } from '../../../servertool/clock/task-store.js';
+import { detectProviderResponseShapeWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-servertool-orchestration-semantics.js';
 const PROVIDER_RESPONSE_REGISTRY = {
     'openai-chat': {
         createFormatAdapter: () => new ChatFormatAdapter(),
@@ -103,21 +104,6 @@ async function maybeCommitClockReservationFromContext(context) {
         // best-effort: never break response conversion due to clock persistence errors
     }
 }
-function detectProviderResponseShape(payload) {
-    if (!isJsonRecord(payload))
-        return 'unknown';
-    const obj = payload;
-    if (Array.isArray(obj.choices))
-        return 'openai-chat';
-    if (Array.isArray(obj.output) || obj.object === 'response')
-        return 'openai-responses';
-    if (typeof obj.type === 'string' && String(obj.type).toLowerCase() === 'message' && Array.isArray(obj.content)) {
-        return 'anthropic-messages';
-    }
-    if (Array.isArray(obj.candidates))
-        return 'gemini-chat';
-    return 'unknown';
-}
 function inferProviderTypeFromProtocol(protocol) {
     const p = typeof protocol === 'string' ? protocol.trim().toLowerCase() : '';
     if (!p)
@@ -150,7 +136,7 @@ async function coerceClientPayloadToCanonicalChatCompletionOrThrow(options) {
     if (isCanonicalChatCompletion(options.payload)) {
         return options.payload;
     }
-    const detected = detectProviderResponseShape(options.payload);
+    const detected = detectProviderResponseShapeWithNative(options.payload);
     if (detected === 'unknown') {
         const protocol = options.adapterContext?.providerProtocol;
         throw new ProviderProtocolError(`[hub_response] Non-canonical response payload at ${options.scope}`, {
@@ -309,19 +295,17 @@ export async function convertProviderResponse(options) {
         stageRecorder: options.stageRecorder
     });
     stripInternalPolicyDebugFields(compatPayload);
-    const formatAdapter = plan.createFormatAdapter();
     const mapper = plan.createMapper();
     const formatEnvelope = await runRespInboundStage2FormatParse({
         adapterContext: options.context,
         payload: compatPayload,
-        formatAdapter,
         stageRecorder: options.stageRecorder
     });
     // Phase 2 (shadow): response tool surface mismatch detection (provider inbound).
     // Only records diffs; does not rewrite payload.
     try {
         if (options.stageRecorder && isToolSurfaceShadowEnabled()) {
-            const detected = detectProviderResponseShape(formatEnvelope.payload);
+            const detected = detectProviderResponseShapeWithNative(formatEnvelope.payload);
             if (detected !== 'unknown' && detected !== options.providerProtocol) {
                 const summary = summarizeToolCallsFromProviderResponse(formatEnvelope.payload);
                 options.stageRecorder.record('hub_toolsurface.shadow.provider_inbound', {
@@ -371,7 +355,8 @@ export async function convertProviderResponse(options) {
         providerProtocol: options.providerProtocol,
         stageRecorder: options.stageRecorder,
         providerInvoker: options.providerInvoker,
-        reenterPipeline: options.reenterPipeline
+        reenterPipeline: options.reenterPipeline,
+        clientInjectDispatch: options.clientInjectDispatch
     });
     let effectiveChatResponse = orchestration.payload;
     // Hard gate: response-side chat_process requires an OpenAI-chat-like surface (choices[].message).
@@ -423,7 +408,7 @@ export async function convertProviderResponse(options) {
     // Phase 2 (shadow): response tool surface mismatch detection (client outbound).
     try {
         if (options.stageRecorder && isToolSurfaceShadowEnabled()) {
-            const detected = detectProviderResponseShape(clientPayload);
+            const detected = detectProviderResponseShapeWithNative(clientPayload);
             if (detected !== 'unknown' && detected !== clientProtocol) {
                 const summary = summarizeToolCallsFromProviderResponse(clientPayload);
                 options.stageRecorder.record('hub_toolsurface.shadow.client_outbound', {

package/dist/conversion/hub/response/response-mappers.js

@@ -1,6 +1,7 @@
 import { buildOpenAIChatFromGeminiResponse } from '../../codecs/gemini-openai-codec.js';
 import { buildChatResponseFromResponses } from '../../shared/responses-response-utils.js';
 import { buildOpenAIChatFromAnthropicMessage } from './response-runtime.js';
+import { resolveAliasMapFromRespSemanticsWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
 export class OpenAIChatResponseMapper {
     toChatCompletion(format, _ctx) {
         return (format.payload ?? {});
@@ -13,7 +14,7 @@ export class ResponsesResponseMapper {
 }
 export class AnthropicResponseMapper {
     toChatCompletion(format, _ctx, options) {
-        const aliasMap = extractToolNameAliasMapFromSemantics(options?.requestSemantics);
+        const aliasMap = resolveAliasMapFromRespSemanticsWithNative(options?.requestSemantics);
         return buildOpenAIChatFromAnthropicMessage(format.payload ?? {}, { aliasMap });
     }
 }
@@ -22,28 +23,3 @@ export class GeminiResponseMapper {
         return buildOpenAIChatFromGeminiResponse(format.payload ?? {});
     }
 }
-function extractToolNameAliasMapFromSemantics(semantics) {
-    if (!semantics || typeof semantics !== 'object' || Array.isArray(semantics)) {
-        return undefined;
-    }
-    const toolsNode = semantics.tools;
-    const candidate = toolsNode && typeof toolsNode === 'object' && !Array.isArray(toolsNode)
-        ? toolsNode.toolNameAliasMap
-        : undefined;
-    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;
-}

package/dist/conversion/hub/response/response-runtime.js

@@ -3,6 +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 { buildAnthropicResponseFromChatWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
 import { registerResponsesReasoning, consumeResponsesReasoning, registerResponsesOutputTextMeta, consumeResponsesOutputTextMeta, consumeResponsesPayloadSnapshot, registerResponsesPayloadSnapshot, consumeResponsesPassthrough, registerResponsesPassthrough } from '../../shared/responses-reasoning-registry.js';
 function flattenAnthropicContent(content) {
     if (typeof content === 'string')
@@ -348,7 +349,6 @@ export function buildAnthropicResponseFromChat(chatResponse, options) {
     const choice = Array.isArray(chatResponse?.choices) ? chatResponse.choices[0] : undefined;
     const message = choice && typeof choice === 'object' ? choice.message : undefined;
     const aliasMap = options?.aliasMap;
-    const outboundAliasSerializer = createToolAliasSerializer(aliasMap);
     if (message) {
         try {
             const bridgePolicy = resolveBridgePolicy({ protocol: 'anthropic-messages' });
@@ -371,98 +371,7 @@ export function buildAnthropicResponseFromChat(chatResponse, options) {
             // ignore policy failures
         }
     }
-    const text = flattenAnthropicContent(message?.content);
-    const toolCalls = Array.isArray(message?.tool_calls) ? message.tool_calls : [];
-    const contentBlocks = [];
-    const reasoningRaw = message?.reasoning_content ?? message?.reasoning;
-    const reasoningText = typeof reasoningRaw === 'string'
-        ? reasoningRaw.trim()
-        : flattenAnthropicContent(reasoningRaw).trim();
-    if (reasoningText) {
-        contentBlocks.push({ type: 'thinking', text: reasoningText });
-    }
-    if (text && text.trim().length) {
-        contentBlocks.push({ type: 'text', text });
-    }
-    for (const call of toolCalls) {
-        if (!call || typeof call !== 'object')
-            continue;
-        const fn = call.function || {};
-        if (typeof fn?.name !== 'string')
-            continue;
-        const canonicalName = normalizeAnthropicToolName(fn.name) ?? fn.name;
-        const serializedName = outboundAliasSerializer(canonicalName || fn.name);
-        let parsedArgs = {};
-        const args = fn.arguments;
-        if (typeof args === 'string') {
-            try {
-                parsedArgs = JSON.parse(args);
-            }
-            catch {
-                parsedArgs = { _raw: args };
-            }
-        }
-        else {
-            parsedArgs = args ?? {};
-        }
-        if ((canonicalName || '').trim() === 'shell_command') {
-            parsedArgs = mapShellCommandArgsForAnthropic(parsedArgs);
-        }
-        contentBlocks.push({
-            type: 'tool_use',
-            id: sanitizeAnthropicToolUseId(call.id),
-            name: serializedName,
-            input: parsedArgs
-        });
-    }
-    const toolResults = extractToolResultBlocks(chatResponse);
-    for (const block of toolResults) {
-        const sanitized = {
-            type: 'tool_result',
-            tool_use_id: block.tool_use_id,
-            content: block.content ?? ''
-        };
-        if (typeof block.is_error === 'boolean') {
-            sanitized.is_error = block.is_error;
-        }
-        contentBlocks.push(sanitized);
-    }
-    const usage = chatResponse?.usage;
-    const usageInputTokens = usage && typeof usage === 'object'
-        ? coerceNonNegativeNumber(usage.input_tokens, usage.prompt_tokens)
-        : undefined;
-    const usageOutputTokens = usage && typeof usage === 'object'
-        ? coerceNonNegativeNumber(usage.output_tokens, usage.completion_tokens)
-        : undefined;
-    const stopReason = typeof choice?.finish_reason === 'string'
-        ? choice.finish_reason
-        : undefined;
-    const stopReasonMapped = (() => {
-        switch (stopReason) {
-            case 'tool_calls': return 'tool_use';
-            case 'length': return 'max_tokens';
-            case 'content_filter': return 'stop_sequence';
-            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: canonicalId,
-        type: 'message',
-        role: 'assistant',
-        content: contentBlocks,
-        model: typeof chatResponse.model === 'string' ? chatResponse.model : 'unknown',
-        stop_reason: stopReasonMapped,
-        usage: usage && typeof usage === 'object'
-            ? {
-                input_tokens: usageInputTokens ?? 0,
-                output_tokens: usageOutputTokens ?? 0
-            }
-            : undefined
-    };
-    const sanitized = sanitizeAnthropicMessage(raw);
+    const sanitized = buildAnthropicResponseFromChatWithNative(chatResponse, aliasMap);
     if (Array.isArray(chatResponse?.__responses_reasoning)) {
         registerResponsesReasoning(sanitized.id, chatResponse.__responses_reasoning);
     }

package/dist/conversion/hub/semantic-mappers/anthropic-mapper.d.ts

@@ -1 +1,2 @@
 export { AnthropicSemanticMapper } from '../operation-table/semantic-mappers/anthropic-mapper.js';
+export { buildAnthropicToolAliasMapWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-governance-semantics.js';

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

@@ -1 +1,2 @@
 export { AnthropicSemanticMapper } from '../operation-table/semantic-mappers/anthropic-mapper.js';
+export { buildAnthropicToolAliasMapWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-governance-semantics.js';

package/dist/conversion/hub/semantic-mappers/chat-mapper.d.ts

@@ -1 +1,2 @@
 export { ChatSemanticMapper, maybeAugmentApplyPatchErrorContent } from '../operation-table/semantic-mappers/chat-mapper.js';
+export { mapReqInboundBridgeToolsToChatWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';

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

@@ -1 +1,2 @@
 export { ChatSemanticMapper, maybeAugmentApplyPatchErrorContent } from '../operation-table/semantic-mappers/chat-mapper.js';
+export { mapReqInboundBridgeToolsToChatWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';

package/dist/conversion/hub/semantic-mappers/gemini-mapper.d.ts

@@ -1 +1,2 @@
 export { GeminiSemanticMapper } from '../operation-table/semantic-mappers/gemini-mapper.js';
+export { applyClaudeThinkingToolSchemaCompatWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-outbound-semantics.js';

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

@@ -1 +1,2 @@
 export { GeminiSemanticMapper } from '../operation-table/semantic-mappers/gemini-mapper.js';
+export { applyClaudeThinkingToolSchemaCompatWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-outbound-semantics.js';

package/dist/conversion/hub/semantic-mappers/responses-mapper.d.ts

@@ -1 +1,2 @@
 export { ResponsesSemanticMapper } from '../operation-table/semantic-mappers/responses-mapper.js';
+export { normalizeProviderProtocolTokenWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';

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

@@ -1 +1,2 @@
 export { ResponsesSemanticMapper } from '../operation-table/semantic-mappers/responses-mapper.js';
+export { normalizeProviderProtocolTokenWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';

package/dist/conversion/hub/snapshot-recorder.js

@@ -1,5 +1,6 @@
 import { createSnapshotWriter } from '../shared/snapshot-utils.js';
 import { jsonClone } from './types/json.js';
+import { parseLenientJsonishWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 export class SnapshotStageRecorder {
     options;
     writer;
@@ -85,9 +86,6 @@ function buildOpenAIChatSnapshot(envelope) {
     return snapshot;
 }
 function buildMetaSnapshot(metadata) {
-    if (!metadata || typeof metadata !== 'object') {
-        return undefined;
-    }
     const meta = {};
     if (metadata.context) {
         meta.context = jsonClone(metadata.context);
@@ -111,6 +109,15 @@ function buildMetaSnapshot(metadata) {
     return Object.keys(meta).length ? meta : undefined;
 }
 function cloneJson(payload) {
+    try {
+        const nativeCloned = parseLenientJsonishWithNative(payload);
+        if (nativeCloned && typeof nativeCloned === 'object' && !Array.isArray(nativeCloned)) {
+            return nativeCloned;
+        }
+    }
+    catch {
+        // native clone is best-effort
+    }
     try {
         return JSON.parse(JSON.stringify(payload));
     }