@jsonstudio/llms 0.4.3 → 0.4.5

package/dist/conversion/hub/process/chat-process.js

@@ -1,50 +1,267 @@
-import { ChatProcessNode } from '../../conversion-v3/nodes/process/chat-process-node.js';
-import { NodeType } from '../../conversion-v3/types/index.js';
-const CHAT_PROCESS_CONFIG = {
-    id: 'hub-chat-process',
-    type: NodeType.PROCESS,
-    name: 'Hub Chat Process Node',
-    inputFormat: 'standardized-request',
-    outputFormat: 'processed-request',
-    rules: [],
-    validation: {
-        strict: false,
-        required: [],
-        optional: []
-    },
-    timeout: 30_000,
-    options: {}
-};
-const chatProcessNode = new ChatProcessNode(CHAT_PROCESS_CONFIG);
+import { runChatRequestToolFilters } from '../../shared/tool-filter-pipeline.js';
+import { ToolGovernanceEngine } from '../tool-governance/index.js';
+const toolGovernanceEngine = new ToolGovernanceEngine();
 export async function runHubChatProcess(options) {
-    const nodeContext = buildProcessNodeContext(options);
-    const result = await chatProcessNode.execute(nodeContext);
+    const startTime = Date.now();
+    try {
+        const governed = await applyRequestToolGovernance(options.request, {
+            entryEndpoint: options.entryEndpoint,
+            requestId: options.requestId,
+            metadata: options.metadata
+        });
+        const processedRequest = buildProcessedRequest(governed);
+        return {
+            processedRequest,
+            nodeResult: buildSuccessResult(startTime, processedRequest)
+        };
+    }
+    catch (error) {
+        return {
+            nodeResult: buildErrorResult(startTime, error)
+        };
+    }
+}
+async function applyRequestToolGovernance(request, context) {
+    const entryEndpoint = context.entryEndpoint && context.entryEndpoint.trim()
+        ? context.entryEndpoint
+        : '/v1/chat/completions';
+    const metadata = normalizeRecord(context.metadata);
+    const providerProtocol = readString(metadata.providerProtocol) ?? readString(metadata.provider) ?? 'openai-chat';
+    const metadataToolHints = metadata.toolFilterHints;
+    const metadataStreamFlag = metadata.stream;
+    const metadataStream = typeof metadataStreamFlag === 'boolean' ? metadataStreamFlag : request.parameters?.stream === true;
+    const shaped = {
+        model: request.model,
+        messages: deepClone(request.messages),
+        tools: request.tools ? deepClone(request.tools) : undefined,
+        tool_choice: request.parameters?.tool_choice,
+        stream: request.parameters?.stream === true,
+        parameters: { ...request.parameters }
+    };
+    const governedPayload = await runChatRequestToolFilters(shaped, {
+        entryEndpoint,
+        requestId: context.requestId,
+        model: request.model,
+        profile: providerProtocol,
+        stream: metadataStream,
+        toolFilterHints: metadataToolHints
+    });
+    const governed = normalizeRecord(governedPayload);
+    const merged = {
+        ...request,
+        messages: Array.isArray(governed.messages)
+            ? governed.messages
+            : request.messages,
+        tools: governed.tools !== undefined ? castGovernedTools(governed.tools) : request.tools,
+        parameters: {
+            ...request.parameters,
+            ...(isRecord(governed.parameters) ? governed.parameters : {})
+        },
+        metadata: {
+            ...request.metadata,
+            toolChoice: readToolChoice(governed.tool_choice),
+            originalStream: request.parameters?.stream === true,
+            stream: typeof governed.stream === 'boolean'
+                ? governed.stream
+                : request.parameters?.stream,
+            governedTools: governed.tools !== undefined,
+            governanceTimestamp: Date.now()
+        }
+    };
+    if (typeof governed.stream === 'boolean') {
+        merged.parameters = {
+            ...merged.parameters,
+            stream: governed.stream
+        };
+    }
+    if (governed.tool_choice !== undefined) {
+        merged.parameters = {
+            ...merged.parameters,
+            tool_choice: governed.tool_choice
+        };
+    }
+    if (typeof governed.model === 'string' && governed.model.trim()) {
+        merged.model = governed.model.trim();
+    }
+    const { request: sanitized, summary } = toolGovernanceEngine.governRequest(merged, providerProtocol);
+    if (summary.applied) {
+        sanitized.metadata = {
+            ...sanitized.metadata,
+            toolGovernance: {
+                ...sanitized.metadata?.toolGovernance,
+                request: summary
+            }
+        };
+    }
+    return sanitized;
+}
+function buildProcessedRequest(request) {
+    const timestamp = Date.now();
+    const streamingEnabled = request.parameters?.stream === true;
     return {
-        processedRequest: result.success ? result.data?.processedRequest : undefined,
-        nodeResult: result
+        ...request,
+        processed: {
+            timestamp,
+            appliedRules: ['tool-governance'],
+            status: 'success'
+        },
+        processingMetadata: {
+            streaming: {
+                enabled: streamingEnabled,
+                chunkCount: 0
+            },
+            context: buildContextMetadata(request.metadata)
+        }
     };
 }
-function buildProcessNodeContext(options) {
+function buildContextMetadata(metadata) {
+    if (!metadata?.capturedContext || typeof metadata.capturedContext !== 'object') {
+        return undefined;
+    }
+    return { ...metadata.capturedContext };
+}
+function buildSuccessResult(startTime, processedRequest) {
+    const endTime = Date.now();
     return {
-        request: {
-            id: options.requestId,
-            timestamp: Date.now(),
-            endpoint: options.entryEndpoint,
-            payload: options.rawPayload,
-            context: {
-                metadata: options.metadata
+        success: true,
+        metadata: {
+            node: 'hub-chat-process',
+            executionTime: endTime - startTime,
+            startTime,
+            endTime,
+            dataProcessed: {
+                messages: processedRequest.messages.length,
+                tools: processedRequest.tools?.length ?? 0
             }
+        }
+    };
+}
+function buildErrorResult(startTime, error) {
+    const endTime = Date.now();
+    return {
+        success: false,
+        metadata: {
+            node: 'hub-chat-process',
+            executionTime: endTime - startTime,
+            startTime,
+            endTime
         },
-        data: {
-            standardizedRequest: options.request
-        },
-        pipeline: {
-            currentNode: CHAT_PROCESS_CONFIG.id,
-            previousResults: [],
-            isPassthrough: false,
-            startTime: Date.now()
-        },
-        nodeConfig: CHAT_PROCESS_CONFIG,
-        callbacks: null
+        error: {
+            message: error instanceof Error ? error.message : String(error)
+        }
+    };
+}
+function castGovernedTools(tools) {
+    if (!Array.isArray(tools)) {
+        return undefined;
+    }
+    const normalized = [];
+    for (const tool of tools) {
+        const converted = castSingleTool(tool) ?? castCustomTool(tool);
+        if (converted) {
+            normalized.push(converted);
+        }
+    }
+    return normalized.length ? normalized : [];
+}
+function castSingleTool(tool) {
+    if (!isRecord(tool)) {
+        return null;
+    }
+    const fn = tool.function;
+    if (!isRecord(fn) || typeof fn.name !== 'string') {
+        return null;
+    }
+    const parameters = castToolParameters(fn.parameters);
+    const description = typeof fn.description === 'string' ? fn.description : undefined;
+    const strictFlag = fn.strict === true || tool.strict === true;
+    return {
+        type: 'function',
+        function: {
+            name: fn.name,
+            description,
+            parameters,
+            strict: strictFlag ? true : undefined
+        }
+    };
+}
+function castCustomTool(tool) {
+    if (!isRecord(tool)) {
+        return null;
+    }
+    const type = typeof tool.type === 'string' ? tool.type.toLowerCase() : '';
+    const name = typeof tool.name === 'string' ? tool.name : '';
+    if (type !== 'custom' || !name) {
+        return null;
+    }
+    if (name.trim() !== 'apply_patch') {
+        return null;
+    }
+    const description = typeof tool.description === 'string' ? tool.description : undefined;
+    return {
+        type: 'function',
+        function: {
+            name: 'apply_patch',
+            description,
+            parameters: {
+                type: 'object',
+                properties: {
+                    patch: {
+                        type: 'string',
+                        description: 'Unified diff patch content (FREEFORM, not JSON)'
+                    }
+                },
+                required: ['patch'],
+                additionalProperties: false
+            },
+            strict: true
+        }
+    };
+}
+function castToolParameters(value) {
+    if (isRecord(value)) {
+        const properties = value.properties && typeof value.properties === 'object'
+            ? value.properties
+            : {};
+        const required = Array.isArray(value.required) ? value.required : undefined;
+        const additionalProperties = typeof value.additionalProperties === 'boolean' ? value.additionalProperties : undefined;
+        return {
+            type: 'object',
+            properties,
+            required,
+            additionalProperties
+        };
+    }
+    return {
+        type: 'object',
+        properties: {},
+        additionalProperties: true
     };
 }
+function normalizeRecord(value) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        return value;
+    }
+    return {};
+}
+function deepClone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function readString(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function readToolChoice(value) {
+    if (!value) {
+        return undefined;
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (typeof value === 'object') {
+        return value;
+    }
+    return undefined;
+}
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}

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

@@ -5,6 +5,7 @@ import { buildProcessedRequestFromChatResponse } from './chat-response-utils.js'
 import { buildAnthropicResponseFromChat } from './response-runtime.js';
 import { buildResponsesPayloadFromChat } from '../../responses/responses-openai-bridge.js';
 import { defaultSseCodecRegistry } from '../../../sse/registry/sse-codec-registry.js';
+import { ToolGovernanceEngine } from '../tool-governance/index.js';
 import { ChatFormatAdapter } from '../format-adapters/chat-format-adapter.js';
 import { ResponsesFormatAdapter } from '../format-adapters/responses-format-adapter.js';
 import { AnthropicFormatAdapter } from '../format-adapters/anthropic-format-adapter.js';
@@ -21,6 +22,7 @@ const STAGES = {
     ssePre: 'resp_sse_output_pre',
     ssePost: 'resp_sse_output_post'
 };
+const toolGovernanceEngine = new ToolGovernanceEngine();
 const PROVIDER_RESPONSE_REGISTRY = {
     'openai-chat': {
         protocol: 'openai-chat',
@@ -87,7 +89,7 @@ async function maybeCreateSseStream(protocol, payload, requestId) {
     return codec.convertJsonToSse(payload, { requestId });
 }
 function supportsSseProtocol(protocol) {
-    return protocol === 'openai-chat' || protocol === 'openai-responses' || protocol === 'anthropic-messages';
+    return protocol === 'openai-chat' || protocol === 'openai-responses' || protocol === 'anthropic-messages' || protocol === 'gemini-chat';
 }
 function extractDisplayModel(context) {
     const candidates = [
@@ -155,12 +157,16 @@ export async function convertProviderResponse(options) {
     recordStage(options.stageRecorder, STAGES.formatParse, formatEnvelope);
     const chatResponse = await mapper.toChatCompletion(formatEnvelope, options.context);
     recordStage(options.stageRecorder, STAGES.semanticMap, chatResponse);
-    const governed = await runChatResponseToolFilters(chatResponse, {
+    const filtered = await runChatResponseToolFilters(chatResponse, {
         entryEndpoint: options.entryEndpoint,
         requestId: options.context.requestId,
         profile: 'openai-chat'
     });
-    recordStage(options.stageRecorder, STAGES.governance, governed);
+    const { payload: governed, summary: responseGovernance } = toolGovernanceEngine.governResponse(filtered, clientProtocol);
+    recordStage(options.stageRecorder, STAGES.governance, {
+        ...governed,
+        __toolGovernanceSummary: responseGovernance
+    });
     const finalized = await finalizeOpenAIChatResponse(governed, {
         requestId: options.context.requestId,
         endpoint: options.entryEndpoint,

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

@@ -1,5 +1,5 @@
 import { buildOpenAIChatFromGeminiResponse } from '../../codecs/gemini-openai-codec.js';
-import { buildChatResponseFromResponses } from '../../responses/responses-openai-bridge.js';
+import { buildChatResponseFromResponses } from '../../shared/responses-response-utils.js';
 import { buildOpenAIChatFromAnthropicMessage } from './response-runtime.js';
 export class OpenAIChatResponseMapper {
     toChatCompletion(format, _ctx) {

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

@@ -1,3 +1,7 @@
+import { extractToolCallsFromReasoningText } from '../../shared/reasoning-tool-parser.js';
+import { deriveToolCallKey } from '../../shared/tool-call-utils.js';
+import { createBridgeActionState, runBridgeActionPipeline } from '../../shared/bridge-actions.js';
+import { resolveBridgePolicy, resolvePolicyActions } from '../../shared/bridge-policies.js';
 function flattenAnthropicContent(content) {
     if (typeof content === 'string')
         return content;
@@ -19,6 +23,11 @@ export function buildOpenAIChatFromAnthropicMessage(payload) {
     const content = Array.isArray(payload?.content) ? payload.content : [];
     const textParts = [];
     const toolCalls = [];
+    const inferredToolCalls = [];
+    const reasoningParts = [];
+    if (typeof payload?.reasoning_content === 'string' && payload.reasoning_content.trim().length) {
+        reasoningParts.push(String(payload.reasoning_content).trim());
+    }
     for (const part of content) {
         if (!part || typeof part !== 'object')
             continue;
@@ -50,6 +59,21 @@ export function buildOpenAIChatFromAnthropicMessage(payload) {
                 toolCalls.push({ id, name, args });
             }
         }
+        else if (kind === 'thinking' || kind === 'reasoning') {
+            const text = typeof part.text === 'string'
+                ? part.text
+                : flattenAnthropicContent(part);
+            if (text) {
+                const { cleanedText, toolCalls: inferred } = extractToolCallsFromReasoningText(text, { idPrefix: 'anthropic_reasoning' });
+                const trimmed = cleanedText.trim();
+                if (trimmed.length) {
+                    reasoningParts.push(trimmed);
+                }
+                if (Array.isArray(inferred) && inferred.length) {
+                    inferredToolCalls.push(...inferred);
+                }
+            }
+        }
     }
     const mapFinishReason = (reason) => {
         switch (reason) {
@@ -59,6 +83,60 @@ export function buildOpenAIChatFromAnthropicMessage(payload) {
             default: return 'stop';
         }
     };
+    const canonicalToolCalls = toolCalls.map((tc) => ({
+        id: tc.id,
+        type: 'function',
+        function: { name: tc.name, arguments: tc.args }
+    }));
+    if (inferredToolCalls.length) {
+        const seen = new Set();
+        for (const existing of canonicalToolCalls) {
+            const key = deriveToolCallKey(existing);
+            if (key)
+                seen.add(key);
+        }
+        for (const inferred of inferredToolCalls) {
+            const key = deriveToolCallKey(inferred);
+            if (key && seen.has(key))
+                continue;
+            canonicalToolCalls.push(inferred);
+            if (key)
+                seen.add(key);
+        }
+    }
+    const message = {
+        role: typeof payload.role === 'string' ? payload.role : 'assistant',
+        content: textParts.join('\n')
+    };
+    if (canonicalToolCalls.length) {
+        message.tool_calls = canonicalToolCalls;
+    }
+    if (reasoningParts.length) {
+        message.reasoning_content = reasoningParts.join('\n');
+    }
+    try {
+        const bridgePolicy = resolveBridgePolicy({ protocol: 'anthropic-messages' });
+        const actions = resolvePolicyActions(bridgePolicy, 'response_inbound');
+        if (actions?.length) {
+            const actionState = createBridgeActionState({
+                messages: [message],
+                rawResponse: payload
+            });
+            runBridgeActionPipeline({
+                stage: 'response_inbound',
+                actions,
+                protocol: bridgePolicy?.protocol ?? 'anthropic-messages',
+                moduleType: bridgePolicy?.moduleType ?? 'anthropic-messages',
+                requestId: typeof payload.id === 'string' ? payload.id : undefined,
+                state: actionState
+            });
+        }
+    }
+    catch {
+        // ignore policy failures
+    }
+    const stopReason = typeof payload['stop_reason'] === 'string' ? payload['stop_reason'] : undefined;
+    const finishReason = canonicalToolCalls.length ? 'tool_calls' : mapFinishReason(stopReason);
     return {
         id: typeof payload.id === 'string' ? payload.id : `chatcmpl_${Date.now()}`,
         object: 'chat.completion',
@@ -67,16 +145,8 @@ export function buildOpenAIChatFromAnthropicMessage(payload) {
         choices: [
             {
                 index: 0,
-                finish_reason: mapFinishReason(typeof payload['stop_reason'] === 'string' ? payload['stop_reason'] : undefined),
-                message: {
-                    role: typeof payload.role === 'string' ? payload.role : 'assistant',
-                    content: textParts.join('\n'),
-                    tool_calls: toolCalls.map((tc) => ({
-                        id: tc.id,
-                        type: 'function',
-                        function: { name: tc.name, arguments: tc.args }
-                    }))
-                }
+                finish_reason: finishReason,
+                message
             }
         ],
         usage: payload['usage'] && typeof payload['usage'] === 'object'
@@ -87,9 +157,38 @@ export function buildOpenAIChatFromAnthropicMessage(payload) {
 export function buildAnthropicResponseFromChat(chatResponse) {
     const choice = Array.isArray(chatResponse?.choices) ? chatResponse.choices[0] : undefined;
     const message = choice && typeof choice === 'object' ? choice.message : undefined;
+    if (message) {
+        try {
+            const bridgePolicy = resolveBridgePolicy({ protocol: 'anthropic-messages' });
+            const actions = resolvePolicyActions(bridgePolicy, 'response_outbound');
+            if (actions?.length) {
+                const actionState = createBridgeActionState({
+                    messages: [message]
+                });
+                runBridgeActionPipeline({
+                    stage: 'response_outbound',
+                    actions,
+                    protocol: bridgePolicy?.protocol ?? 'anthropic-messages',
+                    moduleType: bridgePolicy?.moduleType ?? 'anthropic-messages',
+                    requestId: typeof chatResponse.id === 'string' ? chatResponse.id : undefined,
+                    state: actionState
+                });
+            }
+        }
+        catch {
+            // 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 });
     }