@jsonstudio/llms 0.4.4 → 0.4.5

package/dist/conversion/shared/anthropic-message-utils.d.ts

@@ -0,0 +1,12 @@
+import type { ChatToolDefinition, MissingField } from '../hub/types/chat-envelope.js';
+type Unknown = Record<string, unknown>;
+type UnknownArray = Unknown[];
+interface OpenAIChatPayload extends Unknown {
+    messages: UnknownArray;
+}
+export declare function buildOpenAIChatFromAnthropic(payload: unknown): OpenAIChatPayload;
+export declare function buildAnthropicFromOpenAIChat(oa: unknown): Unknown;
+export declare function buildAnthropicRequestFromOpenAIChat(chatReq: unknown): Unknown;
+export declare function mapAnthropicToolsToChat(rawTools: unknown, missing?: MissingField[]): ChatToolDefinition[] | undefined;
+export declare function mapChatToolsToAnthropicTools(rawTools: unknown): UnknownArray | undefined;
+export {};

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

@@ -0,0 +1,587 @@
+import { createBridgeActionState, runBridgeActionPipeline } from './bridge-actions.js';
+import { resolveBridgePolicy, resolvePolicyActions } from './bridge-policies.js';
+import { normalizeChatMessageContent } from './chat-output-normalizer.js';
+import { mapBridgeToolsToChat, mapChatToolsToBridge } from './tool-mapping.js';
+import { jsonClone } from '../hub/types/json.js';
+function isObject(v) {
+    return !!v && typeof v === 'object' && !Array.isArray(v);
+}
+function safeJson(v) {
+    try {
+        return JSON.stringify(v ?? {});
+    }
+    catch {
+        return '{}';
+    }
+}
+function flattenAnthropicText(content) {
+    if (content == null)
+        return '';
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content))
+        return content.map(flattenAnthropicText).join('');
+    if (typeof content === 'object') {
+        const t = String(content.type || '').toLowerCase();
+        if (t === 'text' && typeof content.text === 'string')
+            return String(content.text);
+        if (Array.isArray(content.content))
+            return content.content.map(flattenAnthropicText).join('');
+        if (typeof content.content === 'string')
+            return String(content.content);
+    }
+    return '';
+}
+function requireTrimmedString(value, context) {
+    if (typeof value !== 'string') {
+        throw new Error(`Anthropic bridge constraint violated: ${context} must be a string`);
+    }
+    const trimmed = value.trim();
+    if (!trimmed.length) {
+        throw new Error(`Anthropic bridge constraint violated: ${context} must not be empty`);
+    }
+    return trimmed;
+}
+function requireSystemText(block, context) {
+    const text = flattenAnthropicText(block).trim();
+    if (!text) {
+        throw new Error(`Anthropic bridge constraint violated: ${context} must contain text`);
+    }
+    return text;
+}
+export function buildOpenAIChatFromAnthropic(payload) {
+    const newMessages = [];
+    const body = isObject(payload) ? payload : {};
+    const rawSystem = body.system;
+    const systemBlocks = Array.isArray(rawSystem)
+        ? rawSystem
+        : rawSystem !== undefined && rawSystem !== null
+            ? [rawSystem]
+            : [];
+    for (const block of systemBlocks) {
+        const text = requireSystemText(block, 'system entry');
+        newMessages.push({ role: 'system', content: text });
+    }
+    const msgs = Array.isArray(body.messages) ? body.messages : [];
+    for (const m of msgs) {
+        if (!m || typeof m !== 'object')
+            continue;
+        const role = typeof m.role === 'string' ? String(m.role) : 'user';
+        const content = m.content;
+        if (!Array.isArray(content)) {
+            const text = flattenAnthropicText(content);
+            if (text) {
+                const normalized = normalizeChatMessageContent(text);
+                const message = {
+                    role,
+                    content: normalized.contentText ?? text
+                };
+                if (typeof normalized.reasoningText === 'string' && normalized.reasoningText.trim().length) {
+                    message.reasoning_content = normalized.reasoningText.trim();
+                }
+                newMessages.push(message);
+            }
+            continue;
+        }
+        const textParts = [];
+        const toolCalls = [];
+        const reasoningParts = [];
+        const toolResults = [];
+        for (const block of content) {
+            if (!block || typeof block !== 'object')
+                continue;
+            const t = String(block.type || '').toLowerCase();
+            if (t === 'text' && typeof block.text === 'string') {
+                const s = block.text.trim();
+                if (s)
+                    textParts.push(s);
+            }
+            else if (t === 'thinking' || t === 'reasoning') {
+                const thinkingText = flattenAnthropicText(block).trim();
+                if (thinkingText) {
+                    reasoningParts.push(thinkingText);
+                }
+            }
+            else if (t === 'tool_use') {
+                const name = requireTrimmedString(block.name, 'tool_use.name');
+                const id = requireTrimmedString(block.id, 'tool_use.id');
+                const input = block.input ?? {};
+                const args = safeJson(input);
+                toolCalls.push({ id, type: 'function', function: { name, arguments: args } });
+            }
+            else if (t === 'tool_result') {
+                const callId = requireTrimmedString(block.tool_call_id ??
+                    block.call_id ??
+                    block.tool_use_id ??
+                    block.id, 'tool_result.tool_use_id');
+                let contentStr = '';
+                const c = block.content;
+                if (typeof c === 'string')
+                    contentStr = c;
+                else if (c != null) {
+                    try {
+                        contentStr = JSON.stringify(c);
+                    }
+                    catch {
+                        contentStr = String(c);
+                    }
+                }
+                toolResults.push({ role: 'tool', tool_call_id: callId, content: contentStr });
+            }
+        }
+        const combinedText = textParts.join('\n');
+        const normalized = normalizeChatMessageContent(combinedText);
+        const mergedReasoning = [...reasoningParts];
+        if (typeof normalized.reasoningText === 'string' && normalized.reasoningText.trim().length) {
+            mergedReasoning.push(normalized.reasoningText.trim());
+        }
+        const hasText = typeof normalized.contentText === 'string' && normalized.contentText.length > 0;
+        const hasReasoning = mergedReasoning.length > 0;
+        if (hasText || toolCalls.length > 0 || hasReasoning) {
+            const msg = {
+                role,
+                content: normalized.contentText ?? combinedText ?? ''
+            };
+            if (toolCalls.length)
+                msg.tool_calls = toolCalls;
+            if (hasReasoning) {
+                msg.reasoning_content = mergedReasoning.join('\n');
+            }
+            newMessages.push(msg);
+        }
+        for (const tr of toolResults)
+            newMessages.push(tr);
+    }
+    const request = { messages: newMessages };
+    if (typeof body.model === 'string')
+        request.model = body.model;
+    if (typeof body.max_tokens === 'number')
+        request.max_tokens = body.max_tokens;
+    if (typeof body.temperature === 'number')
+        request.temperature = body.temperature;
+    if (typeof body.top_p === 'number')
+        request.top_p = body.top_p;
+    if (typeof body.stream === 'boolean')
+        request.stream = body.stream;
+    if ('tool_choice' in body)
+        request.tool_choice = body.tool_choice;
+    const normalizedTools = mapAnthropicToolsToChat(body.tools);
+    if (normalizedTools !== undefined) {
+        request.tools = normalizedTools;
+    }
+    try {
+        const bridgePolicy = resolveBridgePolicy({ protocol: 'anthropic-messages' });
+        const actions = resolvePolicyActions(bridgePolicy, 'request_inbound');
+        if (actions?.length) {
+            const actionState = createBridgeActionState({
+                messages: newMessages,
+                rawRequest: body
+            });
+            runBridgeActionPipeline({
+                stage: 'request_inbound',
+                actions,
+                protocol: bridgePolicy?.protocol ?? 'anthropic-messages',
+                moduleType: bridgePolicy?.moduleType ?? 'anthropic-messages',
+                requestId: typeof body?.id === 'string' ? String(body.id) : undefined,
+                state: actionState
+            });
+        }
+    }
+    catch {
+        // ignore policy failures
+    }
+    return request;
+}
+export function buildAnthropicFromOpenAIChat(oa) {
+    const mapFinishReason = (reason) => {
+        if (typeof reason !== 'string' || !reason.trim().length) {
+            return undefined;
+        }
+        const mapping = {
+            stop: 'end_turn',
+            length: 'max_tokens',
+            tool_calls: 'tool_use',
+            content_filter: 'stop_sequence',
+            function_call: 'tool_use'
+        };
+        return mapping[reason.trim()];
+    };
+    const body = isObject(oa) ? oa : {};
+    const choices = Array.isArray(body.choices) ? body.choices : [];
+    const primary = choices[0] && typeof choices[0] === 'object' ? choices[0] : {};
+    const msg = isObject(primary.message) ? primary.message : {};
+    const role = typeof msg.role === 'string' ? msg.role : 'assistant';
+    const blocks = [];
+    const content = msg?.content;
+    const contentArray = Array.isArray(content) ? content : undefined;
+    if (typeof content === 'string') {
+        blocks.push({ type: 'text', text: content });
+    }
+    if (contentArray) {
+        const text = contentArray
+            .map((p) => p && typeof p.text === 'string'
+            ? String(p.text)
+            : typeof p === 'string'
+                ? p
+                : '')
+            .filter(Boolean)
+            .join('');
+        if (text) {
+            blocks.push({ type: 'text', text });
+        }
+    }
+    const reasoningField = typeof msg?.reasoning_content === 'string'
+        ? msg.reasoning_content
+        : typeof msg?.reasoning === 'string'
+            ? msg.reasoning
+            : undefined;
+    if (reasoningField && reasoningField.trim().length) {
+        blocks.push({ type: 'thinking', text: reasoningField.trim() });
+    }
+    const toolCalls = Array.isArray(msg?.tool_calls) ? msg.tool_calls : [];
+    for (const tc of toolCalls) {
+        try {
+            const id = requireTrimmedString(tc?.id, 'chat.tool_call.id');
+            const fn = isObject(tc?.function) ? tc.function : {};
+            const name = requireTrimmedString(fn.name, 'chat.tool_call.function.name');
+            const argsRaw = fn.arguments;
+            let input;
+            if (typeof argsRaw === 'string') {
+                try {
+                    input = JSON.parse(argsRaw);
+                }
+                catch {
+                    input = { _raw: argsRaw };
+                }
+            }
+            else {
+                input = argsRaw ?? {};
+            }
+            blocks.push({ type: 'tool_use', id, name, input });
+        }
+        catch {
+            // ignore malformed tool call
+        }
+    }
+    const usageChunk = isObject(body.usage) ? body.usage : {};
+    const inputTokens = Number(usageChunk.prompt_tokens ?? usageChunk.input_tokens ?? 0);
+    const outputTokens = Number(usageChunk.completion_tokens ?? usageChunk.output_tokens ?? 0);
+    const finishReason = Array.isArray(body.choices) &&
+        body.choices[0] &&
+        typeof body.choices[0]?.finish_reason === 'string'
+        ? String(body.choices[0].finish_reason).trim()
+        : undefined;
+    const stopReason = mapFinishReason(finishReason);
+    return {
+        id: `resp_${Date.now()}`,
+        type: 'message',
+        role,
+        model: String(body.model || 'unknown'),
+        created: Math.floor(Date.now() / 1000),
+        content: blocks,
+        usage: inputTokens || outputTokens ? { input_tokens: inputTokens, output_tokens: outputTokens } : undefined,
+        ...(stopReason ? { stop_reason: stopReason } : {})
+    };
+}
+export function buildAnthropicRequestFromOpenAIChat(chatReq) {
+    const requestBody = isObject(chatReq) ? chatReq : {};
+    const model = String(requestBody?.model || 'unknown');
+    const messages = [];
+    try {
+        const bridgePolicy = resolveBridgePolicy({ protocol: 'anthropic-messages' });
+        const actions = resolvePolicyActions(bridgePolicy, 'request_outbound');
+        if (actions?.length && Array.isArray(requestBody.messages)) {
+            const actionState = createBridgeActionState({
+                messages: requestBody.messages,
+                rawRequest: requestBody
+            });
+            runBridgeActionPipeline({
+                stage: 'request_outbound',
+                actions,
+                protocol: bridgePolicy?.protocol ?? 'anthropic-messages',
+                moduleType: bridgePolicy?.moduleType ?? 'anthropic-messages',
+                state: actionState
+            });
+        }
+    }
+    catch {
+        // ignore policy errors
+    }
+    const collectText = (val) => {
+        if (!val)
+            return '';
+        if (typeof val === 'string')
+            return val;
+        if (Array.isArray(val))
+            return val.map(collectText).join('');
+        if (typeof val === 'object') {
+            if (typeof val.text === 'string')
+                return String(val.text);
+            if (Array.isArray(val.content))
+                return collectText(val.content);
+        }
+        return '';
+    };
+    const msgs = Array.isArray(requestBody?.messages) ? requestBody.messages : [];
+    const knownToolCallIds = new Set();
+    for (const m of msgs) {
+        if (!m || typeof m !== 'object')
+            continue;
+        const role = String(m.role || 'user');
+        if (role !== 'assistant')
+            continue;
+        const toolCalls = m.tool_calls;
+        if (!Array.isArray(toolCalls))
+            continue;
+        for (const tc of toolCalls) {
+            if (!tc || typeof tc !== 'object')
+                continue;
+            const id = requireTrimmedString(tc.id, 'chat.tool_call.id');
+            knownToolCallIds.add(id);
+        }
+    }
+    const systemBlocks = [];
+    const pushSystemBlock = (text) => {
+        const trimmed = text.trim();
+        if (trimmed)
+            systemBlocks.push({ type: 'text', text: trimmed });
+    };
+    try {
+        const sys = requestBody.system;
+        const ingestSystem = (val) => {
+            if (!val)
+                return;
+            if (typeof val === 'string') {
+                pushSystemBlock(requireSystemText(val, 'top-level system'));
+                return;
+            }
+            if (Array.isArray(val)) {
+                for (const entry of val)
+                    ingestSystem(entry);
+                return;
+            }
+            if (typeof val === 'object') {
+                pushSystemBlock(requireSystemText(val, 'top-level system'));
+                return;
+            }
+            throw new Error('Anthropic bridge constraint violated: unsupported system payload type');
+        };
+        ingestSystem(sys);
+    }
+    catch {
+        // ignore system pre-scan errors
+    }
+    for (const m of msgs) {
+        if (!m || typeof m !== 'object')
+            continue;
+        const role = String(m.role || 'user');
+        const text = collectText(m.content).trim();
+        if (role === 'system') {
+            if (!text) {
+                throw new Error('Anthropic bridge constraint violated: Chat system message must contain text');
+            }
+            pushSystemBlock(text);
+            continue;
+        }
+        if (role === 'tool') {
+            const toolCallId = requireTrimmedString(m.tool_call_id ?? m.call_id ?? m.tool_use_id ?? m.id, 'tool_result.tool_call_id');
+            if (!knownToolCallIds.has(toolCallId)) {
+                throw new Error(`Anthropic bridge constraint violated: tool result ${toolCallId} has no matching tool call`);
+            }
+            const block = {
+                type: 'tool_result',
+                content: text
+            };
+            block.tool_use_id = toolCallId;
+            messages.push({
+                role: 'user',
+                content: [block]
+            });
+            continue;
+        }
+        const blocks = [];
+        if (text) {
+            blocks.push({ type: 'text', text });
+        }
+        const toolCalls = Array.isArray(m.tool_calls) ? m.tool_calls : [];
+        for (const tc of toolCalls) {
+            if (!tc || typeof tc !== 'object')
+                continue;
+            const id = requireTrimmedString(tc.id, 'chat.tool_call.id');
+            const fn = tc.function || {};
+            const name = requireTrimmedString(fn.name, 'chat.tool_call.function.name');
+            const argsRaw = fn.arguments;
+            let input;
+            if (typeof argsRaw === 'string') {
+                try {
+                    input = JSON.parse(argsRaw);
+                }
+                catch {
+                    input = { _raw: argsRaw };
+                }
+            }
+            else {
+                input = argsRaw ?? {};
+            }
+            blocks.push({ type: 'tool_use', id, name, input });
+        }
+        if (blocks.length > 0) {
+            messages.push({ role, content: blocks });
+        }
+    }
+    const out = { model };
+    if (systemBlocks.length) {
+        out.system = systemBlocks;
+    }
+    out.messages = messages;
+    const anthropicTools = mapChatToolsToAnthropicTools(requestBody.tools);
+    if (anthropicTools !== undefined) {
+        out.tools = anthropicTools;
+    }
+    try {
+        if (requestBody.metadata && typeof requestBody.metadata === 'object') {
+            out.metadata = JSON.parse(JSON.stringify(requestBody.metadata));
+        }
+    }
+    catch {
+        // best-effort metadata clone
+    }
+    const mt = Number(requestBody.max_tokens ??
+        requestBody.maxTokens ??
+        NaN);
+    if (Number.isFinite(mt) && mt > 0)
+        out.max_tokens = mt;
+    if (typeof requestBody.temperature === 'number') {
+        out.temperature = Number(requestBody.temperature);
+    }
+    if (typeof requestBody.top_p === 'number') {
+        out.top_p = Number(requestBody.top_p);
+    }
+    if (typeof requestBody.stream === 'boolean') {
+        out.stream = Boolean(requestBody.stream);
+    }
+    const stop = requestBody.stop;
+    if (typeof stop === 'string' && stop.trim()) {
+        out.stop_sequences = [stop.trim()];
+    }
+    else if (Array.isArray(stop) && stop.length > 0) {
+        out.stop_sequences = stop.map((s) => String(s)).filter(Boolean);
+    }
+    return out;
+}
+function isPlainRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function coerceJsonValue(value) {
+    if (value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => coerceJsonValue(entry));
+    }
+    if (isPlainRecord(value)) {
+        const obj = {};
+        for (const [key, entry] of Object.entries(value)) {
+            obj[key] = coerceJsonValue(entry);
+        }
+        return obj;
+    }
+    return String(value ?? '');
+}
+function cloneAnthropicSchema(value) {
+    if (isPlainRecord(value)) {
+        try {
+            return JSON.parse(JSON.stringify(value));
+        }
+        catch {
+            return value;
+        }
+    }
+    return { type: 'object', properties: {} };
+}
+function prepareAnthropicBridgeTools(rawTools, missing) {
+    if (!Array.isArray(rawTools) || rawTools.length === 0) {
+        return undefined;
+    }
+    const result = [];
+    rawTools.forEach((entry, index) => {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+            missing?.push({
+                path: `tools[${index}]`,
+                reason: 'invalid_entry',
+                originalValue: jsonClone(coerceJsonValue(entry))
+            });
+            return;
+        }
+        const name = typeof entry.name === 'string'
+            ? entry.name
+            : undefined;
+        if (!name) {
+            missing?.push({ path: `tools[${index}].name`, reason: 'missing_name' });
+            return;
+        }
+        const description = typeof entry.description === 'string'
+            ? entry.description
+            : undefined;
+        const schemaSource = entry.input_schema;
+        const parameters = cloneAnthropicSchema(schemaSource);
+        result.push({
+            type: 'function',
+            function: {
+                name,
+                description,
+                parameters
+            }
+        });
+    });
+    return result.length ? result : undefined;
+}
+function convertBridgeToolToAnthropic(def) {
+    if (!def || typeof def !== 'object') {
+        return null;
+    }
+    const fnNode = def.function && typeof def.function === 'object' ? def.function : undefined;
+    const name = typeof fnNode?.name === 'string'
+        ? fnNode.name
+        : typeof def.name === 'string'
+            ? def.name
+            : undefined;
+    if (!name) {
+        return null;
+    }
+    const description = typeof fnNode?.description === 'string'
+        ? fnNode.description
+        : typeof def.description === 'string'
+            ? def.description
+            : undefined;
+    const schemaSource = fnNode?.parameters ?? def.parameters;
+    const inputSchema = cloneAnthropicSchema(schemaSource);
+    const tool = {
+        name,
+        input_schema: inputSchema
+    };
+    if (description) {
+        tool.description = description;
+    }
+    return tool;
+}
+export function mapAnthropicToolsToChat(rawTools, missing) {
+    const prepared = prepareAnthropicBridgeTools(rawTools, missing);
+    if (prepared === undefined) {
+        return undefined;
+    }
+    return mapBridgeToolsToChat(prepared);
+}
+export function mapChatToolsToAnthropicTools(rawTools) {
+    if (!Array.isArray(rawTools) || rawTools.length === 0) {
+        return undefined;
+    }
+    const bridgeDefs = mapChatToolsToBridge(rawTools);
+    if (!bridgeDefs || !bridgeDefs.length) {
+        return undefined;
+    }
+    const converted = bridgeDefs
+        .map((def) => convertBridgeToolToAnthropic(def))
+        .filter((entry) => !!entry);
+    return converted.length ? converted : undefined;
+}

package/dist/conversion/shared/bridge-actions.d.ts

@@ -0,0 +1,39 @@
+type UnknownRecord = Record<string, unknown>;
+export type BridgeActionStage = 'request_inbound' | 'request_outbound' | 'response_inbound' | 'response_outbound';
+export interface BridgeActionDescriptor {
+    name: string;
+    options?: Record<string, unknown>;
+}
+export interface BridgeActionState {
+    messages: Array<UnknownRecord>;
+    requiredAction?: UnknownRecord;
+    capturedToolResults?: Array<{
+        tool_call_id?: string;
+        call_id?: string;
+        output?: unknown;
+        name?: string;
+    }>;
+    rawRequest?: UnknownRecord;
+    rawResponse?: UnknownRecord;
+    metadata?: Record<string, unknown>;
+}
+export interface BridgeActionContext {
+    stage: BridgeActionStage;
+    protocol?: string;
+    moduleType?: string;
+    requestId?: string;
+    descriptor: BridgeActionDescriptor;
+    state: BridgeActionState;
+}
+export type BridgeAction = (context: BridgeActionContext) => void;
+export declare function registerBridgeAction(name: string, action: BridgeAction): void;
+export declare function createBridgeActionState(seed?: Partial<BridgeActionState>): BridgeActionState;
+export declare function runBridgeActionPipeline(options: {
+    stage: BridgeActionStage;
+    actions?: BridgeActionDescriptor[];
+    protocol?: string;
+    moduleType?: string;
+    requestId?: string;
+    state: BridgeActionState;
+}): void;
+export {};