@jsonstudio/llms 0.4.6 → 0.6.2

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',
@@ -25,7 +26,9 @@ const KNOWN_TOP_LEVEL_FIELDS = new Set([
     'messages',
     'tools',
     'tool_outputs',
-    ...CHAT_PARAMETER_KEYS
+    ...CHAT_PARAMETER_KEYS,
+    'stageExpectations',
+    'stages'
 ]);
 function flattenSystemContent(content) {
     if (typeof content === 'string')
@@ -56,39 +59,47 @@ function normalizeToolContent(content) {
         return String(content ?? '');
     }
 }
+function recordToolCallIssues(message, messageIndex, missing) {
+    const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : undefined;
+    if (!toolCalls?.length)
+        return;
+    toolCalls.forEach((entry, callIndex) => {
+        if (!isJsonObject(entry)) {
+            missing.push({
+                path: `messages[${messageIndex}].tool_calls[${callIndex}]`,
+                reason: 'invalid_tool_call_entry',
+                originalValue: jsonClone(entry)
+            });
+            return;
+        }
+        const fnBlock = entry.function;
+        if (!isJsonObject(fnBlock)) {
+            missing.push({
+                path: `messages[${messageIndex}].tool_calls[${callIndex}].function`,
+                reason: 'missing_tool_function',
+                originalValue: jsonClone(fnBlock)
+            });
+            return;
+        }
+        const fnName = fnBlock.name;
+        if (typeof fnName !== 'string' || !fnName.trim().length) {
+            missing.push({
+                path: `messages[${messageIndex}].tool_calls[${callIndex}].function.name`,
+                reason: 'missing_tool_name'
+            });
+        }
+    });
+}
 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;
 }
@@ -120,7 +131,8 @@ function normalizeChatMessages(raw) {
         const chatMessage = value;
         if (roleValue !== 'system' && roleValue !== 'tool') {
             const normalizedContent = normalizeChatMessageContent(chatMessage.content);
-            if (normalizedContent.contentText !== undefined) {
+            const shouldOverwriteContent = !Array.isArray(chatMessage.content);
+            if (shouldOverwriteContent && normalizedContent.contentText !== undefined) {
                 chatMessage.content = normalizedContent.contentText;
             }
             if (typeof normalizedContent.reasoningText === 'string' && normalizedContent.reasoningText.trim().length) {
@@ -128,6 +140,10 @@ function normalizeChatMessages(raw) {
             }
         }
         norm.messages.push(chatMessage);
+        const toolCallCandidate = value.tool_calls;
+        if (Array.isArray(toolCallCandidate) && toolCallCandidate.length) {
+            recordToolCallIssues(value, index, norm.missingFields);
+        }
         if (roleValue === 'system') {
             const segment = flattenSystemContent(chatMessage.content);
             if (segment.trim().length) {
@@ -197,6 +213,29 @@ function extractParameters(body) {
     }
     return Object.keys(params).length ? params : undefined;
 }
+function collectExtraFields(body) {
+    const extras = {};
+    for (const [key, value] of Object.entries(body)) {
+        if (KNOWN_TOP_LEVEL_FIELDS.has(key)) {
+            continue;
+        }
+        if (value !== undefined) {
+            extras[key] = jsonClone(value);
+        }
+    }
+    return Object.keys(extras).length ? extras : undefined;
+}
+function applyExtraFields(body, metadata) {
+    if (!metadata || !metadata.extraFields || !isJsonObject(metadata.extraFields)) {
+        return;
+    }
+    for (const [key, value] of Object.entries(metadata.extraFields)) {
+        if (body[key] !== undefined) {
+            continue;
+        }
+        body[key] = jsonClone(value);
+    }
+}
 export class ChatSemanticMapper {
     async toChat(format, ctx) {
         const payload = (format.payload ?? {});
@@ -213,12 +252,17 @@ 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;
         }
+        const extraFields = collectExtraFields(payload);
+        if (extraFields) {
+            metadata.extraFields = extraFields;
+        }
         try {
             const bridgePolicy = resolveBridgePolicy({ protocol: 'openai-chat' });
             const actions = resolvePolicyActions(bridgePolicy, 'request_inbound');
@@ -258,6 +302,7 @@ export class ChatSemanticMapper {
             tools: chat.tools ?? (chat.metadata?.toolsFieldPresent ? [] : undefined),
             ...(chat.parameters || {})
         };
+        applyExtraFields(payload, chat.metadata);
         try {
             const bridgePolicy = resolveBridgePolicy({ protocol: 'openai-chat' });
             const actions = resolvePolicyActions(bridgePolicy, 'request_outbound');
@@ -288,17 +333,12 @@ export class ChatSemanticMapper {
         catch {
             // ignore policy failures
         }
-        if (chat.metadata?.rawSystem !== undefined) {
-            try {
-                payload.__rcc_raw_system = JSON.stringify(chat.metadata.rawSystem);
-            }
-            catch {
-                // ignore serialization errors
-            }
-        }
-        if (chat.toolOutputs?.length) {
-            payload.tool_outputs = chat.toolOutputs;
-        }
+        // Do not forward tool_outputs to provider wire formats. OpenAI Chat
+        // endpoints expect tool results to appear as tool role messages, and
+        // sending the legacy top-level field causes upstream HTTP 400 responses.
+        // Concrete translation happens earlier when responses input is unfolded
+        // into ChatEnvelope.messages, so the provider request only needs the
+        // canonical message list.
         if (payload.max_tokens === undefined && typeof payload.max_output_tokens === 'number') {
             payload.max_tokens = payload.max_output_tokens;
             delete payload.max_output_tokens;

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
@@ -192,15 +191,6 @@ function buildGeminiRequestFromChat(chat, metadata) {
         request.metadata = request.metadata ?? {};
         request.metadata.__rcc_stream = chat.parameters.stream;
     }
-    if (metadata?.rawSystem !== undefined) {
-        request.metadata = request.metadata ?? {};
-        try {
-            request.metadata.__rcc_raw_system = JSON.stringify(metadata.rawSystem);
-        }
-        catch {
-            // ignore serialization errors
-        }
-    }
     if (chat.metadata?.toolsFieldPresent && (!Array.isArray(chat.tools) || chat.tools.length === 0)) {
         request.metadata = request.metadata ?? {};
         request.metadata.__rcc_tools_field_present = '1';
@@ -285,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);
@@ -329,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')) {
@@ -338,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/semantic-mappers/responses-mapper.js

@@ -12,10 +12,7 @@ const RESPONSES_PARAMETER_KEYS = [
     'response_format',
     'tool_choice',
     'parallel_tool_calls',
-    'metadata',
-    'store',
     'user',
-    'include',
     'logit_bias',
     'seed',
     'stop',
@@ -211,21 +208,27 @@ export class ResponsesSemanticMapper {
             .filter((message) => Boolean(message && typeof message === 'object' && message.role === 'system'))
             .map(message => serializeSystemContent(message))
             .filter((content) => typeof content === 'string' && content.length > 0);
-        const responsesContext = chat.metadata
-            ? { metadata: chat.metadata, originalSystemMessages }
-            : { originalSystemMessages };
+        const capturedContext = chat.metadata?.responsesContext;
+        const responsesContext = isJsonObject(capturedContext)
+            ? {
+                ...capturedContext,
+                originalSystemMessages
+            }
+            : {
+                metadata: (chat.metadata && isJsonObject(chat.metadata) ? chat.metadata : undefined),
+                originalSystemMessages
+            };
         const responsesResult = buildResponsesRequestFromChat(requestShape, responsesContext);
         const responses = responsesResult.request;
         if (chat.parameters && chat.parameters.stream !== undefined) {
             responses.stream = chat.parameters.stream;
         }
-        if (chat.toolOutputs && chat.toolOutputs.length) {
-            responses.tool_outputs = chat.toolOutputs.map(entry => ({
-                tool_call_id: entry.tool_call_id,
-                output: entry.content,
-                name: entry.name
-            }));
-        }
+        // Do not forward ChatEnvelope.toolOutputs to OpenAI Responses create requests.
+        // Upstream expects historical tool results to remain inside input[] as
+        // tool role messages; sending the legacy top-level `tool_outputs` field
+        // causes providers like FAI to reject the request (HTTP 400). Any actual
+        // submit_tool_outputs call should be issued via the dedicated endpoint
+        // upstream, not through this mapper.
         try {
             const bridgePolicy = resolveBridgePolicy({ protocol: 'openai-responses', moduleType: 'openai-responses' });
             const actions = resolvePolicyActions(bridgePolicy, 'request_outbound');

package/dist/conversion/hub/snapshot-recorder.d.ts

@@ -0,0 +1,13 @@
+import type { StageRecorder } from './format-adapters/index.js';
+import type { AdapterContext } from './types/chat-envelope.js';
+export interface SnapshotStageRecorderOptions {
+    context: AdapterContext;
+    endpoint: string;
+}
+export declare class SnapshotStageRecorder implements StageRecorder {
+    private readonly options;
+    private readonly writer?;
+    constructor(options: SnapshotStageRecorderOptions);
+    record(stage: string, payload: object): void;
+}
+export declare function createSnapshotRecorder(context: AdapterContext, endpoint: string): StageRecorder;

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

@@ -1,69 +1,109 @@
-import { writeSnapshotViaHooks } from '../shared/snapshot-hooks.js';
-import os from 'node:os';
-import path from 'node:path';
-import fs from 'node:fs/promises';
+import { createSnapshotWriter } from '../shared/snapshot-utils.js';
+import { jsonClone } from './types/json.js';
 export class SnapshotStageRecorder {
     options;
+    writer;
     constructor(options) {
         this.options = options;
+        this.writer = createSnapshotWriter({
+            requestId: options.context.requestId,
+            endpoint: options.endpoint
+        });
     }
     record(stage, payload) {
-        void writeSnapshotFile({
-            endpoint: this.options.endpoint,
-            stage,
-            requestId: this.options.context.requestId,
-            data: payload
-        });
-        void writeSnapshotViaHooks({
-            endpoint: this.options.endpoint,
-            stage,
-            requestId: this.options.context.requestId,
-            data: payload,
-            verbosity: 'verbose'
-        }).catch(() => {
-            /* ignore hook errors */
-        });
+        if (!this.writer) {
+            return;
+        }
+        const normalized = normalizeStagePayload(stage, payload);
+        if (!normalized) {
+            return;
+        }
+        try {
+            this.writer(stage, normalized);
+        }
+        catch {
+            // ignore snapshot write errors
+        }
     }
 }
 export function createSnapshotRecorder(context, endpoint) {
     return new SnapshotStageRecorder({ context, endpoint });
 }
-const SNAPSHOT_BASE = path.join(os.homedir(), '.routecodex', 'codex-samples');
-function mapEndpointToFolder(endpoint) {
-    const ep = String(endpoint || '').toLowerCase();
-    if (ep.includes('/responses'))
-        return 'openai-responses';
-    if (ep.includes('/messages'))
-        return 'anthropic-messages';
-    return 'openai-chat';
+const STAGE_KIND_MAP = {
+    req_inbound_stage2_semantic_map: 'request_inbound',
+    req_outbound_stage1_semantic_map: 'request_outbound',
+    resp_inbound_stage3_semantic_map: 'response_inbound',
+    resp_outbound_stage1_client_remap: 'response_outbound'
+};
+function normalizeStagePayload(stage, payload) {
+    const kind = STAGE_KIND_MAP[stage];
+    if (!kind) {
+        return payload;
+    }
+    if ((kind === 'request_inbound' || kind === 'request_outbound') && isChatEnvelope(payload)) {
+        return buildOpenAIChatSnapshot(payload);
+    }
+    if (kind === 'response_inbound' || kind === 'response_outbound') {
+        return cloneJson(payload);
+    }
+    return payload;
 }
-async function ensureDir(dir) {
-    try {
-        await fs.mkdir(dir, { recursive: true });
+function isChatEnvelope(value) {
+    return Boolean(value &&
+        typeof value === 'object' &&
+        Array.isArray(value.messages) &&
+        value.metadata &&
+        typeof value.metadata === 'object');
+}
+function buildOpenAIChatSnapshot(envelope) {
+    const snapshot = {};
+    if (envelope.parameters && Object.keys(envelope.parameters).length) {
+        Object.assign(snapshot, jsonClone(envelope.parameters));
     }
-    catch {
-        // ignore
+    snapshot.messages = jsonClone(envelope.messages);
+    if (envelope.tools && envelope.tools.length) {
+        snapshot.tools = jsonClone(envelope.tools);
     }
+    if (envelope.toolOutputs && envelope.toolOutputs.length) {
+        snapshot.tool_outputs = jsonClone(envelope.toolOutputs);
+    }
+    const meta = buildMetaSnapshot(envelope.metadata);
+    if (meta) {
+        snapshot.meta = meta;
+    }
+    return snapshot;
+}
+function buildMetaSnapshot(metadata) {
+    if (!metadata || typeof metadata !== 'object') {
+        return undefined;
+    }
+    const meta = {};
+    if (metadata.context) {
+        meta.context = jsonClone(metadata.context);
+    }
+    if (Array.isArray(metadata.missingFields) && metadata.missingFields.length) {
+        meta.missing_fields = jsonClone(metadata.missingFields);
+    }
+    const extraKeys = Object.keys(metadata).filter((key) => key !== 'context' && key !== 'missingFields');
+    if (extraKeys.length) {
+        const extras = {};
+        for (const key of extraKeys) {
+            const value = metadata[key];
+            if (value !== undefined) {
+                extras[key] = jsonClone(value);
+            }
+        }
+        if (Object.keys(extras).length) {
+            meta.extra = extras;
+        }
+    }
+    return Object.keys(meta).length ? meta : undefined;
 }
-async function writeSnapshotFile(options) {
+function cloneJson(payload) {
     try {
-        const folder = mapEndpointToFolder(options.endpoint);
-        const dir = path.join(SNAPSHOT_BASE, folder);
-        await ensureDir(dir);
-        const safeStage = options.stage.replace(/[^\w.-]/g, '_');
-        const safeRequestId = options.requestId.replace(/[^\w.-]/g, '_');
-        const file = path.join(dir, `${safeRequestId}_${safeStage}.json`);
-        const payload = {
-            meta: {
-                stage: options.stage,
-                timestamp: Date.now(),
-                endpoint: options.endpoint
-            },
-            body: options.data
-        };
-        await fs.writeFile(file, JSON.stringify(payload, null, 2), 'utf-8');
+        return JSON.parse(JSON.stringify(payload));
     }
-    catch (error) {
-        console.warn('[hub-snapshot] failed to write local snapshot', error);
+    catch {
+        return payload;
     }
 }

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

@@ -1,3 +1,4 @@
+import { isJsonObject, jsonClone } from './types/json.js';
 const HUB_CAPTURE_KEY = '__hub_capture';
 export function chatEnvelopeToStandardized(chat, options) {
     const parameters = { ...(chat.parameters ?? {}) };
@@ -15,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)) {
@@ -41,13 +42,16 @@ export function chatEnvelopeToStandardized(chat, options) {
 export function standardizedToChatEnvelope(request, options) {
     const adapterContext = options.adapterContext;
     const hubState = extractHubCapture(request);
-    const messages = request.messages.map((message) => ({
-        role: message.role,
-        content: message.content ?? '',
-        tool_calls: mapToolCalls(message.tool_calls),
-        tool_call_id: message.tool_call_id,
-        name: message.name
-    }));
+    const messages = request.messages.map((message) => {
+        const restoredContent = restoreMessageContent(message.content);
+        return {
+            role: message.role,
+            content: restoredContent,
+            tool_calls: mapToolCalls(message.tool_calls),
+            tool_call_id: message.tool_call_id,
+            name: message.name
+        };
+    });
     const tools = mapStandardizedTools(request.tools);
     const parameters = {
         ...(request.parameters ?? {}),
@@ -68,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,
@@ -88,7 +92,7 @@ function extractModel(parameters) {
 function normalizeChatMessage(message) {
     const normalized = {
         role: message.role,
-        content: normalizeContent(message.content)
+        content: cloneMessageContent(message.content)
     };
     if (Array.isArray(message.tool_calls) && message.tool_calls.length) {
         normalized.tool_calls = message.tool_calls
@@ -103,7 +107,7 @@ function normalizeChatMessage(message) {
     }
     return normalized;
 }
-function normalizeContent(content) {
+function cloneMessageContent(content) {
     if (content === undefined || content === null) {
         return null;
     }
@@ -111,21 +115,35 @@ function normalizeContent(content) {
         return content;
     }
     if (Array.isArray(content)) {
-        const parts = content
-            .map((part) => {
-            if (part && typeof part === 'object') {
-                if (typeof part.text === 'string') {
-                    return String(part.text);
-                }
-                return JSON.stringify(part);
-            }
-            return '';
-        })
-            .filter(Boolean);
-        return parts.join('\n');
+        return cloneContentArray(content);
     }
     return String(content);
 }
+function restoreMessageContent(content) {
+    if (content === undefined) {
+        return undefined;
+    }
+    if (content === null) {
+        return null;
+    }
+    if (typeof content === 'string') {
+        return content;
+    }
+    return cloneContentArray(content);
+}
+function cloneContentArray(parts) {
+    return parts.map((part) => {
+        if (part && typeof part === 'object') {
+            return jsonClone(part);
+        }
+        const text = typeof part === 'string' ? part : String(part ?? '');
+        const fallback = {
+            type: 'text',
+            text
+        };
+        return fallback;
+    });
+}
 function normalizeToolCall(toolCall) {
     if (!toolCall || typeof toolCall !== 'object') {
         return null;
@@ -137,20 +155,16 @@ function normalizeToolCall(toolCall) {
     if (type !== 'function') {
         return null;
     }
-    if (!fn || typeof fn !== 'object') {
-        return null;
-    }
-    const fnName = fn.name;
-    if (typeof fnName !== 'string' || !fnName.trim()) {
-        return null;
-    }
-    const args = fn.arguments;
+    const fnRecord = fn && typeof fn === 'object' ? fn : undefined;
+    const rawName = typeof fnRecord?.name === 'string' ? fnRecord.name : '';
+    const normalizedName = rawName.trim();
+    const args = fnRecord?.arguments;
     const serializedArgs = typeof args === 'string' ? args : safeStringify(args ?? {});
     return {
         id: id.trim(),
         type: 'function',
         function: {
-            name: fnName.trim(),
+            name: normalizedName.length ? normalizedName : rawName,
             arguments: serializedArgs
         }
     };
@@ -218,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') {
@@ -247,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));
 }