@jsonstudio/llms 0.4.5 → 0.6.0

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

@@ -184,22 +184,78 @@ function mapToolResults(state) {
     }
     return toolResults;
 }
-function hasToolResponse(messages, startIndex, callId) {
+function findFirstNonToolIndex(messages, startIndex) {
+    let index = startIndex;
+    while (index < messages.length) {
+        const msg = messages[index];
+        if (!msg || typeof msg !== 'object') {
+            break;
+        }
+        const role = String(msg.role || '').toLowerCase();
+        if (role !== 'tool') {
+            break;
+        }
+        index++;
+    }
+    return index;
+}
+function extractToolCallIdentifier(message) {
+    const id = message.tool_call_id ||
+        message.call_id ||
+        message.tool_use_id ||
+        message.id;
+    return typeof id === 'string' && id.trim().length ? id.trim() : undefined;
+}
+function findToolResponseIndex(messages, startIndex, endIndex, callId) {
+    const limit = Math.min(endIndex, messages.length);
+    for (let i = startIndex; i < limit; i++) {
+        const msg = messages[i];
+        if (!msg || typeof msg !== 'object') {
+            continue;
+        }
+        const role = String(msg.role || '').toLowerCase();
+        if (role !== 'tool') {
+            break;
+        }
+        const id = extractToolCallIdentifier(msg);
+        if (id === callId) {
+            return i;
+        }
+    }
+    return -1;
+}
+function extractToolResponse(messages, startIndex, callId) {
     for (let i = startIndex; i < messages.length; i++) {
         const msg = messages[i];
-        if (!msg || typeof msg !== 'object')
+        if (!msg || typeof msg !== 'object') {
             continue;
+        }
         const role = String(msg.role || '').toLowerCase();
-        if (role !== 'tool')
+        if (role !== 'tool') {
             continue;
-        const id = msg.tool_call_id ||
-            msg.call_id ||
-            msg.tool_use_id;
-        if (typeof id === 'string' && id.trim() === callId) {
-            return true;
         }
+        const id = extractToolCallIdentifier(msg);
+        if (id === callId) {
+            const [removed] = messages.splice(i, 1);
+            return removed;
+        }
+    }
+    return undefined;
+}
+function buildToolPlaceholder(callId, call, toolResults) {
+    const content = toolResults.get(callId) ?? '';
+    const inferredName = toolResults.get(`${callId}::name`) ||
+        normalizeToolName(call.name) ||
+        normalizeToolName(call?.function?.name);
+    const toolMessage = {
+        role: 'tool',
+        tool_call_id: callId,
+        content
+    };
+    if (inferredName) {
+        toolMessage.name = inferredName;
     }
-    return false;
+    return toolMessage;
 }
 function normalizeToolName(value) {
     if (typeof value === 'string' && value.trim().length) {
@@ -211,18 +267,25 @@ const ensureToolResponsePlaceholders = (ctx) => {
     const messages = ensureMessagesArray(ctx.state);
     if (!messages.length)
         return;
-    const inserts = [];
     const toolResults = mapToolResults(ctx.state);
-    for (let i = 0; i < messages.length; i++) {
-        const message = messages[i];
-        if (!message || typeof message !== 'object')
+    let index = 0;
+    while (index < messages.length) {
+        const message = messages[index];
+        if (!message || typeof message !== 'object') {
+            index++;
             continue;
+        }
         const role = String(message.role || '').toLowerCase();
-        if (role !== 'assistant')
+        if (role !== 'assistant') {
+            index++;
             continue;
+        }
         const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : undefined;
-        if (!toolCalls?.length)
+        if (!toolCalls?.length) {
+            index++;
             continue;
+        }
+        let insertionIndex = index + 1;
         for (const call of toolCalls) {
             if (!call || typeof call !== 'object')
                 continue;
@@ -231,30 +294,24 @@ const ensureToolResponsePlaceholders = (ctx) => {
                 call.tool_call_id;
             if (typeof callId !== 'string' || !callId.trim())
                 continue;
-            if (hasToolResponse(messages, i + 1, callId))
+            const normalizedId = callId.trim();
+            const windowEnd = findFirstNonToolIndex(messages, insertionIndex);
+            const existingIndex = findToolResponseIndex(messages, insertionIndex, windowEnd, normalizedId);
+            if (existingIndex >= 0) {
+                insertionIndex = existingIndex + 1;
                 continue;
-            const content = toolResults.get(callId) ?? '';
-            const inferredName = toolResults.get(`${callId}::name`) ||
-                normalizeToolName(call.name) ||
-                normalizeToolName(call?.function?.name);
-            const toolMessage = {
-                role: 'tool',
-                tool_call_id: callId,
-                content
-            };
-            if (inferredName) {
-                toolMessage.name = inferredName;
             }
-            inserts.push({ index: i + 1, message: toolMessage });
+            const relocated = extractToolResponse(messages, windowEnd, normalizedId);
+            if (relocated) {
+                messages.splice(insertionIndex, 0, relocated);
+                insertionIndex++;
+                continue;
+            }
+            const placeholder = buildToolPlaceholder(normalizedId, call, toolResults);
+            messages.splice(insertionIndex, 0, placeholder);
+            insertionIndex++;
         }
-    }
-    if (!inserts.length)
-        return;
-    let offset = 0;
-    for (const entry of inserts) {
-        const targetIndex = Math.min(messages.length, entry.index + offset);
-        messages.splice(targetIndex, 0, entry.message);
-        offset++;
+        index = Math.max(index + 1, insertionIndex);
     }
 };
 function assignReasoning(message, parts) {
@@ -434,13 +491,34 @@ const ensureOutputFieldsAction = (ctx) => {
             continue;
         }
         if (role === 'assistant') {
+            const toolCalls = Array.isArray(message.tool_calls)
+                ? message.tool_calls
+                : undefined;
+            const hasToolCalls = Boolean(toolCalls && toolCalls.length);
             const text = flattenContentToString(message.content);
-            if (text === undefined) {
-                message.content = '';
-            }
-            else if (typeof message.content !== 'string') {
+            const hasText = typeof text === 'string' && text.trim().length > 0;
+            if (text !== undefined && typeof message.content !== 'string') {
                 message.content = text;
+                continue;
+            }
+            if (hasText) {
+                continue;
+            }
+            const reasoningText = typeof message.reasoning_content === 'string' && message.reasoning_content.trim().length
+                ? message.reasoning_content.trim()
+                : undefined;
+            if (reasoningText) {
+                message.content = reasoningText;
+                continue;
+            }
+            if (hasToolCalls) {
+                // Assistant-only tool call is valid; leave content empty to avoid fabricated summaries.
+                continue;
             }
+            const assistantFallback = typeof ctx.descriptor.options?.assistantFallback === 'string' && ctx.descriptor.options.assistantFallback.trim().length
+                ? ctx.descriptor.options.assistantFallback.trim()
+                : 'Assistant response unavailable.';
+            message.content = assistantFallback;
         }
     }
 };
@@ -478,6 +556,151 @@ registerBridgeAction('messages.ensure-output-fields', ensureOutputFieldsAction);
 registerBridgeAction('tools.ensure-placeholders', ensureToolPlaceholdersAction);
 registerBridgeAction('tools.capture-results', captureToolResultsAction);
 registerBridgeAction('reasoning.attach-output', attachReasoningOutputAction);
+function deriveToolIdPrefix(ctx) {
+    if (typeof ctx.descriptor.options?.idPrefix === 'string' && ctx.descriptor.options.idPrefix.trim().length) {
+        return ctx.descriptor.options.idPrefix.trim();
+    }
+    if (typeof ctx.requestId === 'string' && ctx.requestId.trim().length) {
+        const safe = ctx.requestId.trim().replace(/[^A-Za-z0-9]/g, '');
+        if (safe.length) {
+            return `${safe.slice(-24)}_tool`;
+        }
+    }
+    const base = ctx.protocol || 'bridge';
+    return `${base}_tool`;
+}
+const normalizeToolIdentifiersAction = (ctx) => {
+    const messages = ensureMessagesArray(ctx.state);
+    const idPrefix = deriveToolIdPrefix(ctx);
+    let counter = 0;
+    const aliasMap = new Map();
+    const knownIds = new Set();
+    const pendingQueue = [];
+    const registerAlias = (raw, normalized) => {
+        if (typeof raw === 'string' && raw.trim().length) {
+            aliasMap.set(raw.trim(), normalized);
+        }
+        aliasMap.set(normalized, normalized);
+    };
+    const consumePending = (id) => {
+        const index = pendingQueue.indexOf(id);
+        if (index >= 0) {
+            pendingQueue.splice(index, 1);
+        }
+    };
+    const nextId = () => {
+        counter += 1;
+        return `${idPrefix}_${counter}`;
+    };
+    const normalizeIdValue = (raw, consumeQueue) => {
+        if (typeof raw === 'string' && raw.trim().length) {
+            const existing = raw.trim();
+            if (aliasMap.has(existing)) {
+                const normalized = aliasMap.get(existing);
+                knownIds.add(normalized);
+                return normalized;
+            }
+            if (consumeQueue && pendingQueue.length) {
+                const queued = pendingQueue.shift();
+                knownIds.add(queued);
+                aliasMap.set(existing, queued);
+                aliasMap.set(queued, queued);
+                return queued;
+            }
+            knownIds.add(existing);
+            aliasMap.set(existing, existing);
+            return existing;
+        }
+        if (consumeQueue && pendingQueue.length) {
+            const queued = pendingQueue.shift();
+            knownIds.add(queued);
+            aliasMap.set(queued, queued);
+            return queued;
+        }
+        const generated = nextId();
+        knownIds.add(generated);
+        aliasMap.set(generated, generated);
+        return generated;
+    };
+    const normalizeToolCall = (call, consumeQueue) => {
+        if (!call || typeof call !== 'object') {
+            return undefined;
+        }
+        const normalized = normalizeIdValue(call.id || call.tool_call_id || call.call_id, consumeQueue);
+        registerAlias(call.id, normalized);
+        registerAlias(call.tool_call_id, normalized);
+        registerAlias(call.call_id, normalized);
+        call.id = normalized;
+        call.tool_call_id = normalized;
+        call.call_id = normalized;
+        return normalized;
+    };
+    const normalizeToolOutputs = (outputs) => {
+        if (!Array.isArray(outputs)) {
+            return;
+        }
+        outputs.forEach((entry) => {
+            if (!entry || typeof entry !== 'object') {
+                return;
+            }
+            const normalized = normalizeIdValue(entry.tool_call_id || entry.call_id || entry.id, true);
+            registerAlias(entry.tool_call_id, normalized);
+            registerAlias(entry.call_id, normalized);
+            consumePending(normalized);
+            entry.tool_call_id = normalized;
+            entry.call_id = normalized;
+        });
+    };
+    for (const message of messages) {
+        if (!message || typeof message !== 'object')
+            continue;
+        const role = String(message.role || '').toLowerCase();
+        if (role === 'assistant') {
+            const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : undefined;
+            if (!toolCalls?.length)
+                continue;
+            for (const call of toolCalls) {
+                const normalized = normalizeToolCall(call, false);
+                if (normalized) {
+                    pendingQueue.push(normalized);
+                }
+            }
+        }
+        else if (role === 'tool') {
+            const normalized = normalizeIdValue(message.tool_call_id || message.call_id || message.id, true);
+            registerAlias(message.tool_call_id, normalized);
+            registerAlias(message.call_id, normalized);
+            consumePending(normalized);
+            message.tool_call_id = normalized;
+            message.call_id = normalized;
+            if (!message.id) {
+                message.id = normalized;
+            }
+        }
+    }
+    if (ctx.state.rawRequest && typeof ctx.state.rawRequest === 'object') {
+        normalizeToolOutputs(ctx.state.rawRequest.tool_outputs);
+        const required = ctx.state.rawRequest.required_action;
+        if (required && typeof required === 'object') {
+            const submit = required.submit_tool_outputs;
+            if (submit && typeof submit === 'object' && Array.isArray(submit.tool_calls)) {
+                const submitCalls = submit.tool_calls;
+                submitCalls.forEach((call) => normalizeToolCall(call, false));
+            }
+        }
+    }
+    if (ctx.state.capturedToolResults && Array.isArray(ctx.state.capturedToolResults)) {
+        ctx.state.capturedToolResults.forEach((entry) => {
+            const normalized = normalizeIdValue(entry?.tool_call_id ?? entry?.call_id, true);
+            registerAlias(entry?.tool_call_id, normalized);
+            registerAlias(entry?.call_id, normalized);
+            consumePending(normalized);
+            entry.tool_call_id = normalized;
+            entry.call_id = normalized;
+        });
+    }
+};
+registerBridgeAction('tools.normalize-call-ids', normalizeToolIdentifiersAction);
 const responsesOutputReasoningAction = (ctx) => {
     if (ctx.stage !== 'response_inbound')
         return;
@@ -633,6 +856,10 @@ const metadataProviderSentinelAction = (ctx) => {
         metadata[targetKey] = provider;
         return;
     }
+    if (ctx.stage === 'request_outbound') {
+        delete payload[sentinel];
+        return;
+    }
     const metadata = ctx.state.metadata;
     if (!metadata || typeof metadata !== 'object') {
         delete payload[sentinel];

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

@@ -1,5 +1,19 @@
 import { normalizeFunctionCallId, normalizeFunctionCallOutputId } from './bridge-id-utils.js';
 import { normalizeChatMessageContent } from './chat-output-normalizer.js';
+function ensureAssistantToolCallIdentity(call, fallbackId) {
+    const resolved = (typeof call.id === 'string' && call.id.trim().length ? call.id.trim() : undefined) ??
+        (typeof call.tool_call_id === 'string' && call.tool_call_id.trim().length
+            ? call.tool_call_id.trim()
+            : undefined) ??
+        (typeof call.call_id === 'string' && call.call_id.trim().length
+            ? call.call_id.trim()
+            : undefined) ??
+        fallbackId;
+    call.id = resolved;
+    call.tool_call_id = resolved;
+    call.call_id = resolved;
+    return resolved;
+}
 export function coerceBridgeRole(role) {
     if (typeof role === 'string') {
         const normalized = role.toLowerCase();
@@ -159,7 +173,6 @@ export function convertMessagesToBridgeInput(options) {
         if (typeof text === 'string') {
             const tRole = role === 'assistant' ? 'output_text' : 'input_text';
             const entry = {
-                type: 'message',
                 role,
                 content: [{ type: tRole, text }]
             };
@@ -385,7 +398,18 @@ export function convertBridgeInputToChatMessages(options) {
             }
             const serialized = serializeToolArguments(parsedArgs, name, tools).trim();
             toolNameById.set(callId, name);
-            messages.push({ role: 'assistant', tool_calls: [{ id: callId, type: 'function', function: { name, arguments: serialized } }] });
+            const toolCall = {
+                id: callId,
+                call_id: callId,
+                tool_call_id: callId,
+                type: 'function',
+                function: { name, arguments: serialized }
+            };
+            messages.push({
+                role: 'assistant',
+                content: '',
+                tool_calls: [toolCall]
+            });
             lastToolCallId = callId;
             continue;
         }
@@ -404,7 +428,12 @@ export function convertBridgeInputToChatMessages(options) {
                         contentStr = fallbackText;
                     }
                     const nm = toolNameById.get(String(toolCallId));
-                    const toolMsg = { role: 'tool', tool_call_id: String(toolCallId), content: contentStr };
+                    const toolMsg = {
+                        role: 'tool',
+                        tool_call_id: String(toolCallId),
+                        id: String(toolCallId),
+                        content: contentStr
+                    };
                     if (typeof nm === 'string' && nm.trim().length)
                         toolMsg.name = nm;
                     messages.push(toolMsg);
@@ -412,7 +441,12 @@ export function convertBridgeInputToChatMessages(options) {
                 catch {
                     const fallback = (output ?? fallbackText);
                     const nm = toolNameById.get(String(toolCallId));
-                    const toolMsg = { role: 'tool', tool_call_id: String(toolCallId), content: String(fallback) };
+                    const toolMsg = {
+                        role: 'tool',
+                        tool_call_id: String(toolCallId),
+                        id: String(toolCallId),
+                        content: String(fallback)
+                    };
                     if (typeof nm === 'string' && nm.trim().length)
                         toolMsg.name = nm;
                     messages.push(toolMsg);
@@ -425,8 +459,14 @@ export function convertBridgeInputToChatMessages(options) {
         if (entry && typeof entry.message === 'object' && Array.isArray(entry.message?.content)) {
             const explicit = entry.message;
             const nested = processMessageBlocks(Array.isArray(explicit.content) ? explicit.content : [], resolveFunctionName, tools, toolNameById, lastToolCallId, fallbackText);
-            if (nested.toolCalls.length)
-                messages.push({ role: 'assistant', tool_calls: nested.toolCalls });
+            if (nested.toolCalls.length) {
+                nested.toolCalls.forEach((call, idx) => ensureAssistantToolCallIdentity(call, `fc_call_${messages.length + idx + 1}`));
+                messages.push({
+                    role: 'assistant',
+                    content: '',
+                    tool_calls: nested.toolCalls
+                });
+            }
             for (const msg of nested.toolMessages)
                 messages.push(msg);
             const normalizedRole = coerceBridgeRole((explicit.role ?? entry.role) || 'user');
@@ -440,8 +480,14 @@ export function convertBridgeInputToChatMessages(options) {
         }
         if (!handledViaExplicitMessage) {
             const nested = processMessageBlocks(Array.isArray(entry.content) ? entry.content : [], resolveFunctionName, tools, toolNameById, lastToolCallId, fallbackText);
-            if (nested.toolCalls.length)
-                messages.push({ role: 'assistant', tool_calls: nested.toolCalls });
+            if (nested.toolCalls.length) {
+                nested.toolCalls.forEach((call, idx) => ensureAssistantToolCallIdentity(call, `fc_call_${messages.length + idx + 1}`));
+                messages.push({
+                    role: 'assistant',
+                    content: '',
+                    tool_calls: nested.toolCalls
+                });
+            }
             for (const msg of nested.toolMessages)
                 messages.push(msg);
             const normalizedRole = coerceBridgeRole(entry.role || 'user');

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

@@ -109,6 +109,15 @@ function reasoningAction(idPrefix) {
         }
     };
 }
+function toolCallNormalizationAction(idPrefix) {
+    if (idPrefix && idPrefix.trim().length) {
+        return {
+            name: 'tools.normalize-call-ids',
+            options: { idPrefix: idPrefix.trim() }
+        };
+    }
+    return { name: 'tools.normalize-call-ids' };
+}
 const RESPONSES_POLICY = {
     id: 'openai-responses-default',
     protocol: 'openai-responses',
@@ -123,32 +132,40 @@ const RESPONSES_POLICY = {
             },
             { name: 'messages.ensure-system-instruction' },
             reasoningAction('responses_reasoning'),
+            toolCallNormalizationAction('responses_tool_call'),
             { 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.provider-sentinel', options: { sentinel: '__rcc_provider_metadata', target: 'providerMetadata' } },
+            { name: 'metadata.system-sentinel', options: { sentinel: '__rcc_raw_system', target: 'rawSystem' } }
         ],
         outbound: [
             { name: 'messages.normalize-history' },
             { name: 'tools.capture-results' },
+            toolCallNormalizationAction('responses_tool_call'),
             { name: 'tools.ensure-placeholders' },
             { name: 'messages.ensure-output-fields', options: { toolFallback: 'Tool call completed (no output).' } },
             { name: 'messages.ensure-system-instruction' },
             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.provider-sentinel', options: { sentinel: '__rcc_provider_metadata', target: 'providerMetadata' } },
+            { name: 'metadata.system-sentinel', options: { sentinel: '__rcc_raw_system', target: 'rawSystem' } }
         ]
     },
     response: {
         inbound: [
             { name: 'reasoning.attach-output' },
             reasoningAction('responses_reasoning'),
-            { name: 'metadata.extra-fields', options: { allowedKeys: RESPONSES_ALLOWED_FIELDS } }
+            toolCallNormalizationAction('responses_tool_call'),
+            { name: 'metadata.extra-fields', options: { allowedKeys: RESPONSES_ALLOWED_FIELDS } },
+            { name: 'metadata.system-sentinel', options: { sentinel: '__rcc_raw_system', target: 'rawSystem' } }
         ],
         outbound: [
             reasoningAction('responses_reasoning'),
-            { name: 'metadata.extra-fields', options: { allowedKeys: RESPONSES_ALLOWED_FIELDS } }
+            toolCallNormalizationAction('responses_tool_call'),
+            { name: 'metadata.extra-fields', options: { allowedKeys: RESPONSES_ALLOWED_FIELDS } },
+            { name: 'metadata.system-sentinel', options: { sentinel: '__rcc_raw_system', target: 'rawSystem' } }
         ]
     }
 };
@@ -158,6 +175,7 @@ const OPENAI_CHAT_POLICY = {
     request: {
         inbound: [
             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 } },
@@ -167,6 +185,7 @@ const OPENAI_CHAT_POLICY = {
         outbound: [
             { name: 'messages.normalize-history' },
             { name: 'tools.capture-results' },
+            toolCallNormalizationAction('openai_chat_tool_call'),
             { name: 'tools.ensure-placeholders' },
             { name: 'messages.ensure-output-fields', options: { toolFallback: 'Tool call completed (no output).' } },
             { name: 'messages.ensure-system-instruction' },
@@ -180,10 +199,12 @@ const OPENAI_CHAT_POLICY = {
     response: {
         inbound: [
             reasoningAction('openai_chat_reasoning'),
+            toolCallNormalizationAction('openai_chat_tool_call'),
             { name: 'metadata.extra-fields', options: { allowedKeys: OPENAI_CHAT_ALLOWED_FIELDS } }
         ],
         outbound: [
             reasoningAction('openai_chat_reasoning'),
+            toolCallNormalizationAction('openai_chat_tool_call'),
             { name: 'metadata.extra-fields', options: { allowedKeys: OPENAI_CHAT_ALLOWED_FIELDS } }
         ]
     }
@@ -194,12 +215,14 @@ const ANTHROPIC_POLICY = {
     request: {
         inbound: [
             reasoningAction('anthropic_reasoning'),
+            toolCallNormalizationAction('anthropic_tool_call'),
             { name: 'messages.ensure-system-instruction' },
             { name: 'metadata.extra-fields', options: { allowedKeys: ANTHROPIC_ALLOWED_FIELDS } }
         ],
         outbound: [
             { name: 'messages.normalize-history' },
             { name: 'tools.capture-results' },
+            toolCallNormalizationAction('anthropic_tool_call'),
             { name: 'tools.ensure-placeholders' },
             { name: 'messages.ensure-output-fields', options: { toolFallback: 'Tool call completed (no output).' } },
             { name: 'messages.ensure-system-instruction' },
@@ -210,10 +233,12 @@ const ANTHROPIC_POLICY = {
     response: {
         inbound: [
             reasoningAction('anthropic_reasoning'),
+            toolCallNormalizationAction('anthropic_tool_call'),
             { name: 'metadata.extra-fields', options: { allowedKeys: ANTHROPIC_ALLOWED_FIELDS } }
         ],
         outbound: [
             reasoningAction('anthropic_reasoning'),
+            toolCallNormalizationAction('anthropic_tool_call'),
             { name: 'metadata.extra-fields', options: { allowedKeys: ANTHROPIC_ALLOWED_FIELDS } }
         ]
     }

package/dist/conversion/shared/chat-envelope-validator.d.ts

@@ -0,0 +1,8 @@
+import type { ChatEnvelope } from '../hub/types/chat-envelope.js';
+export type ChatValidationStage = 'req_inbound' | 'req_outbound' | 'resp_inbound' | 'resp_outbound';
+export interface ChatEnvelopeValidationOptions {
+    stage: ChatValidationStage;
+    direction: 'request' | 'response';
+    source?: string;
+}
+export declare function validateChatEnvelope(chat: ChatEnvelope, options: ChatEnvelopeValidationOptions): void;