@jsonstudio/llms 0.6.2172 → 0.6.3214

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

@@ -1,293 +1,16 @@
-import { isJsonObject, jsonClone } from './types/json.js';
-import { cloneRuntimeMetadata } from '../shared/runtime-metadata.js';
-const HUB_CAPTURE_KEY = '__hub_capture';
+import { chatEnvelopeToStandardizedWithNative } from '../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+import { standardizedToChatEnvelopeWithNative } from '../../router/virtual-router/engine-selection/native-hub-pipeline-req-outbound-semantics.js';
 export function chatEnvelopeToStandardized(chat, options) {
-    const parameters = { ...(chat.parameters ?? {}) };
-    const model = extractModel(parameters);
-    const messages = chat.messages.map((message) => normalizeChatMessage(message));
-    const tools = normalizeTools(chat.tools);
-    const semantics = cloneSemantics(chat.semantics);
-    const metadataCaptured = {};
-    const hubState = {};
-    if (Array.isArray(chat.metadata?.missingFields) && chat.metadata?.missingFields.length) {
-        hubState.missingFields = chat.metadata.missingFields;
-    }
-    if (isJsonObject(chat.metadata?.providerMetadata)) {
-        hubState.providerMetadata = chat.metadata?.providerMetadata;
-    }
-    if (isJsonObject(chat.metadata?.protocolState)) {
-        hubState.protocolState = chat.metadata?.protocolState;
-    }
-    hubState.context = options.adapterContext;
-    if (hubStateContextPopulated(hubState)) {
-        metadataCaptured[HUB_CAPTURE_KEY] = hubState;
-    }
-    const standardized = {
-        model,
-        messages,
-        tools,
-        parameters: {
-            ...parameters
-        },
-        metadata: {
-            originalEndpoint: options.endpoint,
-            capturedContext: metadataCaptured,
-            requestId: options.requestId,
-            stream: parameters.stream === true
-        },
-        semantics
-    };
-    return standardized;
-}
-export function standardizedToChatEnvelope(request, options) {
-    const adapterContext = options.adapterContext;
-    const hubState = extractHubCapture(request);
-    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
-        };
+    return chatEnvelopeToStandardizedWithNative({
+        chatEnvelope: chat,
+        adapterContext: options.adapterContext,
+        endpoint: options.endpoint,
+        requestId: options.requestId
     });
-    const tools = mapStandardizedTools(request.tools);
-    const parameters = {
-        ...(request.parameters ?? {}),
-        model: request.model
-    };
-    const metadata = {
-        context: adapterContext
-    };
-    const sourceMeta = (request.metadata && typeof request.metadata === 'object'
-        ? request.metadata
-        : undefined);
-    // E1: internal runtime metadata must live under the __rt carrier (never as top-level metadata keys).
-    // Merge runtime hints from AdapterContext + StandardizedRequest.metadata (legacy/compat).
-    try {
-        const merged = {
-            ...(cloneRuntimeMetadata(adapterContext) ?? {}),
-            ...(cloneRuntimeMetadata(sourceMeta ?? null) ?? {})
-        };
-        if (sourceMeta && typeof sourceMeta === 'object') {
-            if (sourceMeta.webSearch && typeof sourceMeta.webSearch === 'object' && merged.webSearch === undefined) {
-                merged.webSearch = sourceMeta.webSearch;
-            }
-            if (sourceMeta.forceWebSearch === true && merged.forceWebSearch === undefined) {
-                merged.forceWebSearch = true;
-            }
-            if (sourceMeta.forceVision === true && merged.forceVision === undefined) {
-                merged.forceVision = true;
-            }
-        }
-        if (Object.keys(merged).length) {
-            metadata.__rt = merged;
-        }
-    }
-    catch {
-        // best-effort
-    }
-    if (typeof adapterContext.toolCallIdStyle === 'string' && adapterContext.toolCallIdStyle.length) {
-        metadata.toolCallIdStyle = adapterContext.toolCallIdStyle;
-    }
-    if (hubState?.missingFields) {
-        metadata.missingFields = hubState.missingFields;
-    }
-    if (hubState?.providerMetadata) {
-        metadata.providerMetadata = hubState.providerMetadata;
-    }
-    if (hubState?.protocolState) {
-        metadata.protocolState = hubState.protocolState;
-    }
-    return {
-        messages,
-        tools,
-        parameters,
-        metadata,
-        semantics: cloneSemantics(request.semantics)
-    };
-}
-function extractModel(parameters) {
-    const candidate = parameters.model;
-    if (typeof candidate === 'string' && candidate.trim()) {
-        return candidate.trim();
-    }
-    throw new Error('ChatEnvelope parameters must include model string');
-}
-function cloneSemantics(value) {
-    if (!value) {
-        return value;
-    }
-    return jsonClone(value);
 }
-function normalizeChatMessage(message) {
-    const normalized = {
-        role: message.role,
-        content: cloneMessageContent(message.content)
-    };
-    if (Array.isArray(message.tool_calls) && message.tool_calls.length) {
-        normalized.tool_calls = message.tool_calls
-            .map((tool) => normalizeToolCall(tool))
-            .filter((tool) => Boolean(tool));
-    }
-    if (typeof message.tool_call_id === 'string') {
-        normalized.tool_call_id = message.tool_call_id.trim();
-    }
-    if (typeof message.name === 'string' && message.name.trim()) {
-        normalized.name = message.name.trim();
-    }
-    return normalized;
-}
-function cloneMessageContent(content) {
-    if (content === undefined || content === null) {
-        return null;
-    }
-    if (typeof content === 'string') {
-        return content;
-    }
-    if (Array.isArray(content)) {
-        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;
+export function standardizedToChatEnvelope(request, options) {
+    return standardizedToChatEnvelopeWithNative({
+        request: request,
+        adapterContext: options.adapterContext
     });
 }
-function normalizeToolCall(toolCall) {
-    if (!toolCall || typeof toolCall !== 'object') {
-        return null;
-    }
-    const { id, type, function: fn } = toolCall;
-    if (typeof id !== 'string' || !id.trim()) {
-        return null;
-    }
-    if (type !== 'function') {
-        return null;
-    }
-    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: normalizedName.length ? normalizedName : rawName,
-            arguments: serializedArgs
-        }
-    };
-}
-function mapToolCalls(toolCalls) {
-    if (!Array.isArray(toolCalls) || !toolCalls.length) {
-        return undefined;
-    }
-    return toolCalls.map((tool) => ({
-        id: tool.id,
-        type: 'function',
-        function: {
-            name: tool.function.name,
-            arguments: tool.function.arguments
-        }
-    }));
-}
-function mapStandardizedTools(tools) {
-    if (!Array.isArray(tools) || !tools.length) {
-        return undefined;
-    }
-    return tools.map((tool) => ({
-        type: tool.type,
-        function: {
-            name: tool.function.name,
-            description: tool.function.description,
-            parameters: tool.function.parameters,
-            strict: tool.function.strict
-        }
-    }));
-}
-function normalizeTools(tools) {
-    if (!Array.isArray(tools) || !tools.length) {
-        return [];
-    }
-    const normalized = [];
-    for (const tool of tools) {
-        if (!tool || typeof tool !== 'object')
-            continue;
-        if (tool.type !== 'function')
-            continue;
-        const fn = tool.function;
-        if (!fn || typeof fn !== 'object')
-            continue;
-        const name = fn.name;
-        if (typeof name !== 'string' || !name.trim())
-            continue;
-        const parametersCast = fn.parameters;
-        normalized.push({
-            type: 'function',
-            function: {
-                name: name.trim(),
-                description: typeof fn.description === 'string'
-                    ? fn.description
-                    : undefined,
-                parameters: parametersCast ?? {
-                    type: 'object',
-                    properties: {}
-                },
-                strict: typeof fn.strict === 'boolean'
-                    ? fn.strict
-                    : undefined
-            }
-        });
-    }
-    return normalized;
-}
-function extractHubCapture(request) {
-    const captured = request.metadata?.capturedContext;
-    if (!captured || typeof captured !== 'object') {
-        return undefined;
-    }
-    const state = captured[HUB_CAPTURE_KEY];
-    if (!state || typeof state !== 'object') {
-        return undefined;
-    }
-    return state;
-}
-function safeStringify(value) {
-    if (typeof value === 'string')
-        return value;
-    try {
-        return JSON.stringify(value ?? {});
-    }
-    catch {
-        return String(value);
-    }
-}
-function hubStateContextPopulated(state) {
-    return Boolean(state.context ||
-        (state.missingFields && state.missingFields.length) ||
-        state.providerMetadata ||
-        (state.protocolState && Object.keys(state.protocolState).length));
-}

package/dist/conversion/hub/tool-governance/engine.d.ts

@@ -1,6 +1,14 @@
 import type { JsonObject } from '../types/json.js';
 import type { StandardizedRequest } from '../types/standardized.js';
 import type { GovernedChatCompletionPayload, GovernedStandardizedRequest, ToolGovernanceProtocol, ToolGovernanceRegistry } from './types.js';
+/**
+ * Hybrid governance engine:
+ * - request path: native-primary
+ * - response path: legacy TS rules (until native response-governance export is available)
+ *
+ * Legacy-only snapshot retained at:
+ * - src/conversion/hub/tool-governance/archive/engine.legacy.ts
+ */
 export declare class ToolGovernanceError extends Error {
     readonly protocol: ToolGovernanceProtocol;
     readonly direction: 'request' | 'response';

package/dist/conversion/hub/tool-governance/engine.js

@@ -1,4 +1,13 @@
 import { DEFAULT_TOOL_GOVERNANCE_RULES } from './rules.js';
+import { governRequestWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-governance-semantics.js';
+/**
+ * Hybrid governance engine:
+ * - request path: native-primary
+ * - response path: legacy TS rules (until native response-governance export is available)
+ *
+ * Legacy-only snapshot retained at:
+ * - src/conversion/hub/tool-governance/archive/engine.legacy.ts
+ */
 export class ToolGovernanceError extends Error {
     protocol;
     direction;
@@ -42,24 +51,24 @@ export class ToolGovernanceEngine {
                 summary: buildSummary(protocol, 'request', false)
             };
         }
-        const stats = createStats(protocol, 'request');
-        const sanitizedMessages = request.messages.map((msg) => sanitizeStandardizedMessage(msg, rules, stats));
-        const sanitizedTools = request.tools?.map((tool) => sanitizeStandardizedTool(tool, rules, stats));
-        const governed = {
-            ...request,
-            messages: sanitizedMessages,
-            tools: sanitizedTools,
-            metadata: {
-                ...request.metadata,
-                toolGovernance: {
-                    ...request.metadata?.toolGovernance,
-                    request: finalizeSummary(stats)
-                }
+        let governed;
+        try {
+            governed = governRequestWithNative({
+                request: request,
+                protocol,
+                registry: this.registry
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error ?? 'unknown error');
+            if (message.includes('Tool name exceeds max length')) {
+                throw new ToolGovernanceError(message, protocol, 'request', 'tool.function.name');
             }
-        };
+            throw error;
+        }
         return {
-            request: governed,
-            summary: finalizeSummary(stats)
+            request: governed.request,
+            summary: governed.summary
         };
     }
     governResponse(payload, protocol) {
@@ -90,53 +99,6 @@ export class ToolGovernanceEngine {
         return entry?.[direction];
     }
 }
-function sanitizeStandardizedMessage(message, rules, stats) {
-    let changed = false;
-    const next = { ...message };
-    if (Array.isArray(message.tool_calls) && message.tool_calls.length) {
-        next.tool_calls = message.tool_calls.map((call) => sanitizeToolCall(call, rules, stats));
-        if (next.tool_calls !== message.tool_calls) {
-            changed = true;
-        }
-    }
-    if (typeof message.name === 'string' || message.role === 'tool') {
-        const sanitizedName = sanitizeName(message.name, rules, stats, 'message.name');
-        if (sanitizedName !== message.name) {
-            next.name = sanitizedName;
-            changed = true;
-        }
-    }
-    return changed ? next : message;
-}
-function sanitizeStandardizedTool(tool, rules, stats) {
-    const sanitizedName = sanitizeName(tool.function?.name, rules, stats, 'tool.function.name');
-    if (sanitizedName === tool.function?.name) {
-        return tool;
-    }
-    return {
-        ...tool,
-        function: {
-            ...tool.function,
-            name: sanitizedName
-        }
-    };
-}
-function sanitizeToolCall(call, rules, stats) {
-    if (!call?.function) {
-        return call;
-    }
-    const sanitizedName = sanitizeName(call.function.name, rules, stats, 'tool_call.function.name');
-    if (sanitizedName === call.function.name) {
-        return call;
-    }
-    return {
-        ...call,
-        function: {
-            ...call.function,
-            name: sanitizedName
-        }
-    };
-}
 function sanitizeChatCompletionChoice(choice, rules, stats) {
     const message = choice?.message;
     if (!message || typeof message !== 'object') {

package/dist/conversion/hub/tool-governance/rules.js

@@ -1,76 +1,80 @@
+import { resolveDefaultToolGovernanceRulesWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-governance-semantics.js';
 const ALPHA_NUMERIC = /[A-Za-z0-9_-]/;
 const LOWER_SNAKE = /[a-z0-9_-]/;
 function clonePattern(pattern) {
-    if (!pattern)
-        return undefined;
     const flags = pattern.flags.replace(/g/g, '');
     return new RegExp(pattern.source, flags);
 }
-export const DEFAULT_TOOL_GOVERNANCE_RULES = {
-    'openai-chat': {
-        request: {
-            maxNameLength: 64,
-            allowedCharacters: clonePattern(ALPHA_NUMERIC),
-            defaultName: 'tool',
-            trimWhitespace: true,
-            onViolation: 'truncate'
-        },
-        response: {
-            maxNameLength: 64,
-            allowedCharacters: clonePattern(ALPHA_NUMERIC),
-            defaultName: 'tool',
-            trimWhitespace: true,
-            onViolation: 'truncate'
-        }
-    },
-    'openai-responses': {
-        request: {
-            maxNameLength: 64,
-            allowedCharacters: clonePattern(ALPHA_NUMERIC),
-            defaultName: 'tool',
-            trimWhitespace: true,
-            onViolation: 'truncate'
-        },
-        response: {
-            maxNameLength: 64,
-            allowedCharacters: clonePattern(ALPHA_NUMERIC),
-            defaultName: 'tool',
-            trimWhitespace: true,
-            onViolation: 'truncate'
-        }
-    },
-    anthropic: {
-        request: {
-            maxNameLength: 64,
-            allowedCharacters: clonePattern(LOWER_SNAKE),
-            forceCase: 'lower',
-            defaultName: 'tool',
-            trimWhitespace: true,
-            onViolation: 'truncate'
-        },
-        response: {
-            maxNameLength: 64,
-            allowedCharacters: clonePattern(LOWER_SNAKE),
-            forceCase: 'lower',
-            defaultName: 'tool',
-            trimWhitespace: true,
-            onViolation: 'truncate'
-        }
-    },
-    gemini: {
-        request: {
-            maxNameLength: 64,
-            allowedCharacters: clonePattern(ALPHA_NUMERIC),
-            defaultName: 'tool',
-            trimWhitespace: true,
-            onViolation: 'truncate'
-        },
-        response: {
-            maxNameLength: 64,
-            allowedCharacters: clonePattern(ALPHA_NUMERIC),
-            defaultName: 'tool',
-            trimWhitespace: true,
-            onViolation: 'truncate'
-        }
+function mapAllowedCharacters(token, fallback) {
+    const normalized = String(token || '').trim().toLowerCase();
+    if (normalized === 'lower_snake') {
+        return clonePattern(LOWER_SNAKE);
+    }
+    return clonePattern(fallback);
+}
+function mapNativeRules(nativeRules, fallback) {
+    if (!nativeRules || typeof nativeRules !== 'object') {
+        return undefined;
+    }
+    return {
+        maxNameLength: typeof nativeRules.maxNameLength === 'number' && Number.isFinite(nativeRules.maxNameLength)
+            ? Math.max(1, Math.floor(nativeRules.maxNameLength))
+            : fallback.maxNameLength,
+        allowedCharacters: mapAllowedCharacters(nativeRules.allowedCharacters, fallback.allowedCharacters),
+        defaultName: typeof nativeRules.defaultName === 'string' && nativeRules.defaultName.trim().length
+            ? nativeRules.defaultName.trim()
+            : fallback.defaultName,
+        trimWhitespace: nativeRules.trimWhitespace !== false,
+        ...(nativeRules.forceCase === 'lower' || nativeRules.forceCase === 'upper'
+            ? { forceCase: nativeRules.forceCase }
+            : {}),
+        onViolation: nativeRules.onViolation === 'reject' ? 'reject' : 'truncate'
+    };
+}
+function mapProtocolNode(nativeNode, options) {
+    const defaultName = 'tool';
+    const maxNameLength = 64;
+    const fallbackBase = {
+        allowedCharacters: options.allowedCharacters,
+        defaultName,
+        maxNameLength
+    };
+    const request = mapNativeRules(nativeNode?.request, fallbackBase) ?? {
+        ...fallbackBase,
+        trimWhitespace: true,
+        onViolation: 'truncate',
+        ...(options.forceCase ? { forceCase: options.forceCase } : {})
+    };
+    const response = mapNativeRules(nativeNode?.response, fallbackBase) ?? {
+        ...fallbackBase,
+        trimWhitespace: true,
+        onViolation: 'truncate',
+        ...(options.forceCase ? { forceCase: options.forceCase } : {})
+    };
+    if (options.forceCase) {
+        request.forceCase = options.forceCase;
+        response.forceCase = options.forceCase;
     }
-};
+    return {
+        request,
+        response
+    };
+}
+function mapNativeRegistry(nativeRegistry) {
+    return {
+        'openai-chat': mapProtocolNode(nativeRegistry['openai-chat'], {
+            allowedCharacters: ALPHA_NUMERIC
+        }),
+        'openai-responses': mapProtocolNode(nativeRegistry['openai-responses'], {
+            allowedCharacters: ALPHA_NUMERIC
+        }),
+        anthropic: mapProtocolNode(nativeRegistry.anthropic, {
+            allowedCharacters: LOWER_SNAKE,
+            forceCase: 'lower'
+        }),
+        gemini: mapProtocolNode(nativeRegistry.gemini, {
+            allowedCharacters: ALPHA_NUMERIC
+        })
+    };
+}
+export const DEFAULT_TOOL_GOVERNANCE_RULES = mapNativeRegistry(resolveDefaultToolGovernanceRulesWithNative());

package/dist/conversion/hub/tool-session-compat.d.ts

@@ -3,11 +3,11 @@ import type { AdapterContext } from './types/chat-envelope.js';
 type ToolHistoryStatus = 'ok' | 'error' | 'unknown';
 export interface ToolHistoryMessageRecord {
     role: 'user' | 'assistant' | 'tool';
-    tool_use?: {
+    toolUse?: {
         id: string;
         name?: string;
     };
-    tool_result?: {
+    toolResult?: {
         id: string;
         name?: string;
         status: ToolHistoryStatus;