@jsonstudio/llms 0.4.3 → 0.4.5

package/dist/conversion/shared/metadata-passthrough.js

@@ -0,0 +1,57 @@
+import { isJsonObject, jsonClone } from '../hub/types/json.js';
+function isValidKey(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+export function encodeMetadataPassthrough(parameters, options) {
+    if (!parameters)
+        return undefined;
+    const encoded = {};
+    const { prefix, keys } = options;
+    for (const key of keys) {
+        if (!isValidKey(key))
+            continue;
+        const value = parameters[key];
+        if (value === undefined)
+            continue;
+        try {
+            encoded[`${prefix}${key}`] = JSON.stringify(value);
+        }
+        catch {
+            continue;
+        }
+    }
+    return Object.keys(encoded).length ? encoded : undefined;
+}
+export function extractMetadataPassthrough(metadataField, options) {
+    if (!metadataField || !isJsonObject(metadataField)) {
+        return {};
+    }
+    const cloned = jsonClone(metadataField);
+    const passthrough = {};
+    const { prefix, keys } = options;
+    const allowedKeys = new Set(keys.filter(isValidKey));
+    let mutated = false;
+    for (const rawKey of Object.keys(cloned)) {
+        if (!rawKey.startsWith(prefix))
+            continue;
+        const suffix = rawKey.slice(prefix.length);
+        if (!allowedKeys.has(suffix))
+            continue;
+        const rawValue = cloned[rawKey];
+        if (typeof rawValue !== 'string')
+            continue;
+        try {
+            const parsed = rawValue ? JSON.parse(rawValue) : undefined;
+            passthrough[suffix] = parsed;
+            delete cloned[rawKey];
+            mutated = true;
+        }
+        catch {
+            continue;
+        }
+    }
+    return {
+        metadata: mutated ? (Object.keys(cloned).length ? cloned : undefined) : cloned,
+        passthrough: Object.keys(passthrough).length ? passthrough : undefined
+    };
+}

package/dist/conversion/shared/output-content-normalizer.d.ts

@@ -0,0 +1,12 @@
+type UnknownRecord = Record<string, unknown>;
+export interface OutputContentExtractionResult {
+    textParts: string[];
+    reasoningParts: string[];
+}
+export declare function extractOutputSegments(source: UnknownRecord | undefined, itemsKey?: string): OutputContentExtractionResult;
+export declare function normalizeContentPart(part: unknown, reasoningCollector: string[]): UnknownRecord | null;
+export declare function normalizeMessageContentParts(parts: unknown, reasoningCollector?: string[]): {
+    normalizedParts: UnknownRecord[];
+    reasoningChunks: string[];
+};
+export {};

package/dist/conversion/shared/output-content-normalizer.js

@@ -0,0 +1,119 @@
+import { extractReasoningSegments, sanitizeReasoningTaggedText } from './reasoning-utils.js';
+function collectTextAndReasoning(blocks, collector) {
+    const pushText = (value) => {
+        if (typeof value === 'string' && value.trim().length) {
+            const cleaned = extractReasoningSegments(value, collector.reasoningParts);
+            if (cleaned.length) {
+                collector.textParts.push(cleaned);
+            }
+        }
+    };
+    if (typeof blocks === 'string') {
+        pushText(blocks);
+        return;
+    }
+    if (!Array.isArray(blocks))
+        return;
+    for (const block of blocks) {
+        if (!block || typeof block !== 'object')
+            continue;
+        const type = typeof block.type === 'string' ? String(block.type).toLowerCase() : '';
+        if (type === 'text' || type === 'input_text' || type === 'output_text' || type === 'commentary') {
+            pushText(block.text ?? block.content);
+            continue;
+        }
+        if (Array.isArray(block.content)) {
+            collectTextAndReasoning(block.content, collector);
+            continue;
+        }
+        if (typeof block.text === 'string') {
+            pushText(block.text);
+        }
+    }
+}
+export function extractOutputSegments(source, itemsKey = 'output') {
+    if (!source || typeof source !== 'object') {
+        return { textParts: [], reasoningParts: [] };
+    }
+    const outputItems = Array.isArray(source[itemsKey]) ? source[itemsKey] : [];
+    const result = { textParts: [], reasoningParts: [] };
+    for (const item of outputItems) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const type = typeof item.type === 'string' ? String(item.type).toLowerCase() : '';
+        if (type === 'message') {
+            const message = item.message && typeof item.message === 'object'
+                ? item.message
+                : item;
+            const content = Array.isArray(message.content) ? message.content : [];
+            collectTextAndReasoning(content, result);
+            continue;
+        }
+        if (type === 'output_text' && typeof item.text === 'string') {
+            const cleaned = extractReasoningSegments(item.text, result.reasoningParts);
+            if (cleaned.length) {
+                result.textParts.push(cleaned);
+            }
+            continue;
+        }
+        if (type === 'reasoning') {
+            const content = Array.isArray(item.content) ? item.content : [];
+            for (const block of content) {
+                if (block && typeof block === 'object' && typeof block.text === 'string') {
+                    const sanitized = sanitizeReasoningTaggedText(block.text);
+                    if (sanitized.length)
+                        result.reasoningParts.push(sanitized);
+                }
+            }
+        }
+    }
+    return result;
+}
+export function normalizeContentPart(part, reasoningCollector) {
+    if (part == null)
+        return null;
+    if (typeof part === 'string') {
+        const cleaned = extractReasoningSegments(part, reasoningCollector);
+        return { type: 'output_text', text: cleaned };
+    }
+    if (typeof part !== 'object') {
+        return { type: 'output_text', text: sanitizeReasoningTaggedText(String(part)) };
+    }
+    const clone = { ...part };
+    delete clone._initialText;
+    delete clone._hasDelta;
+    if (typeof clone.text === 'string') {
+        clone.text = extractReasoningSegments(clone.text, reasoningCollector);
+    }
+    if (clone.output_text && typeof clone.output_text === 'object' && typeof clone.output_text.text === 'string') {
+        clone.output_text = {
+            ...clone.output_text,
+            text: extractReasoningSegments(clone.output_text.text, reasoningCollector)
+        };
+    }
+    if (typeof clone.content === 'string') {
+        clone.content = extractReasoningSegments(clone.content, reasoningCollector);
+    }
+    if (!clone.type)
+        clone.type = 'output_text';
+    if (clone.type === 'output_text' && typeof clone.text !== 'string') {
+        clone.text = '';
+    }
+    return clone;
+}
+export function normalizeMessageContentParts(parts, reasoningCollector) {
+    const reasoningChunks = reasoningCollector ?? [];
+    const normalizedParts = [];
+    if (!Array.isArray(parts)) {
+        const normalized = normalizeContentPart(parts, reasoningChunks);
+        if (normalized)
+            normalizedParts.push(normalized);
+        return { normalizedParts, reasoningChunks };
+    }
+    for (const part of parts) {
+        const normalized = normalizeContentPart(part, reasoningChunks);
+        if (normalized)
+            normalizedParts.push(normalized);
+    }
+    return { normalizedParts, reasoningChunks };
+}

package/dist/conversion/shared/reasoning-normalizer.d.ts

@@ -0,0 +1,21 @@
+import type { JsonObject, JsonValue } from '../hub/types/json.js';
+export declare const RESPONSES_INSTRUCTIONS_REASONING_FIELD = "__rcc_reasoning_instructions";
+interface ResponsesReasoningNormalizeOptions {
+    includeInput?: boolean;
+    includeOutput?: boolean;
+    includeRequiredAction?: boolean;
+    includeInstructions?: boolean;
+}
+export declare function normalizeReasoningInChatPayload(payload: {
+    messages?: JsonValue[];
+} | null | undefined): void;
+export declare function normalizeReasoningInResponsesPayload(payload: {
+    output?: JsonValue[];
+    id?: string;
+    input?: JsonValue[];
+    instructions?: unknown;
+    required_action?: JsonObject;
+} | null | undefined, options?: ResponsesReasoningNormalizeOptions): void;
+export declare function normalizeReasoningInGeminiPayload(payload: JsonObject | null | undefined): void;
+export declare function normalizeReasoningInAnthropicPayload(payload: JsonObject | null | undefined): void;
+export {};

package/dist/conversion/shared/reasoning-normalizer.js

@@ -0,0 +1,368 @@
+import { normalizeChatMessageContent } from './chat-output-normalizer.js';
+import { extractReasoningSegments } from './reasoning-utils.js';
+import { expandResponsesMessageItem } from '../../sse/shared/responses-output-normalizer.js';
+export const RESPONSES_INSTRUCTIONS_REASONING_FIELD = '__rcc_reasoning_instructions';
+function isRecord(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+export function normalizeReasoningInChatPayload(payload) {
+    if (!payload || !Array.isArray(payload.messages)) {
+        return;
+    }
+    payload.messages = payload.messages.map((entry) => {
+        if (!entry || typeof entry !== 'object') {
+            return entry;
+        }
+        const msg = entry;
+        const normalized = normalizeChatMessageContent(msg.content);
+        if (normalized.contentText !== undefined) {
+            msg.content = normalized.contentText;
+        }
+        if (normalized.reasoningText && normalized.reasoningText.trim().length) {
+            msg.reasoning_content = normalized.reasoningText.trim();
+        }
+        else {
+            delete msg.reasoning_content;
+        }
+        return msg;
+    });
+}
+export function normalizeReasoningInResponsesPayload(payload, options = { includeOutput: true }) {
+    if (!payload) {
+        return;
+    }
+    const includeOutput = options.includeOutput !== false;
+    if (includeOutput) {
+        normalizeResponsesOutput(payload);
+    }
+    if (options.includeInput) {
+        normalizeResponsesInput(payload);
+    }
+    if (options.includeInstructions) {
+        normalizeResponsesInstructions(payload);
+    }
+    if (options.includeRequiredAction) {
+        normalizeResponsesRequiredAction(payload);
+    }
+}
+function normalizeResponsesOutput(payload) {
+    if (!Array.isArray(payload.output)) {
+        return;
+    }
+    const normalized = [];
+    payload.output.forEach((entry, index) => {
+        if (isResponsesMessageItem(entry)) {
+            const expanded = expandResponsesMessageItem(entry, {
+                requestId: typeof payload.id === 'string' ? payload.id : 'responses',
+                outputIndex: index
+            });
+            expanded.forEach((item) => {
+                normalized.push(item);
+            });
+        }
+        else {
+            normalized.push(entry);
+        }
+    });
+    payload.output = normalized;
+}
+function isResponsesMessageItem(entry) {
+    if (!isRecord(entry)) {
+        return false;
+    }
+    const type = typeof entry.type === 'string' ? entry.type : undefined;
+    if (type !== 'message') {
+        return false;
+    }
+    if (!Array.isArray(entry.content)) {
+        return false;
+    }
+    const status = typeof entry.status === 'string' ? entry.status : undefined;
+    const role = typeof entry.role === 'string' ? entry.role : undefined;
+    return Boolean(status && role);
+}
+function normalizeResponsesInput(payload) {
+    if (!Array.isArray(payload.input)) {
+        return;
+    }
+    payload.input.forEach((entry) => {
+        if (!isRecord(entry))
+            return;
+        const reasoningSegments = [];
+        if (typeof entry.content === 'string') {
+            const { cleaned, segments } = stripReasoningFromString(entry.content);
+            entry.content = cleaned;
+            reasoningSegments.push(...segments);
+        }
+        else if (Array.isArray(entry.content)) {
+            entry.content = entry.content.map((block) => normalizeResponsesContentBlock(block, reasoningSegments));
+        }
+        if (isRecord(entry.message)) {
+            normalizeResponsesMessageBlock(entry.message, reasoningSegments);
+        }
+        if (typeof entry.text === 'string') {
+            const { cleaned, segments } = stripReasoningFromString(entry.text);
+            entry.text = cleaned;
+            reasoningSegments.push(...segments);
+        }
+        if (reasoningSegments.length) {
+            entry.reasoning_content = mergeReasoningText(entry.reasoning_content, reasoningSegments);
+        }
+        else if ('reasoning_content' in entry) {
+            delete entry.reasoning_content;
+        }
+    });
+}
+function normalizeResponsesMessageBlock(message, collector) {
+    const localSegments = [];
+    if (Array.isArray(message.content)) {
+        message.content = message.content.map((block) => normalizeResponsesContentBlock(block, localSegments));
+    }
+    else if (typeof message.content === 'string') {
+        const { cleaned, segments } = stripReasoningFromString(message.content);
+        message.content = cleaned;
+        localSegments.push(...segments);
+    }
+    if (typeof message.text === 'string') {
+        const { cleaned, segments } = stripReasoningFromString(message.text);
+        message.text = cleaned;
+        localSegments.push(...segments);
+    }
+    if (localSegments.length) {
+        collector.push(...localSegments);
+        message.reasoning_content = mergeReasoningText(message.reasoning_content, localSegments);
+    }
+    else if ('reasoning_content' in message) {
+        delete message.reasoning_content;
+    }
+}
+function normalizeResponsesContentBlock(block, collector) {
+    if (typeof block === 'string') {
+        const { cleaned, segments } = stripReasoningFromString(block);
+        collector.push(...segments);
+        return cleaned;
+    }
+    if (!isRecord(block)) {
+        return block;
+    }
+    const type = typeof block.type === 'string' ? block.type.toLowerCase() : '';
+    if ((type === 'input_text' || type === 'output_text' || type === 'text' || type === 'commentary') && typeof block.text === 'string') {
+        const { cleaned, segments } = stripReasoningFromString(block.text);
+        block.text = cleaned;
+        if (segments.length) {
+            collector.push(...segments);
+            block.reasoning_content = mergeReasoningText(block.reasoning_content, segments);
+        }
+        else if ('reasoning_content' in block) {
+            delete block.reasoning_content;
+        }
+    }
+    if (Array.isArray(block.content)) {
+        block.content = block.content.map((nested) => normalizeResponsesContentBlock(nested, collector));
+    }
+    else if (typeof block.content === 'string') {
+        const { cleaned, segments } = stripReasoningFromString(block.content);
+        block.content = cleaned;
+        if (segments.length) {
+            collector.push(...segments);
+            block.reasoning_content = mergeReasoningText(block.reasoning_content, segments);
+        }
+        else if ('reasoning_content' in block) {
+            delete block.reasoning_content;
+        }
+    }
+    return block;
+}
+function normalizeResponsesInstructions(payload) {
+    if (typeof payload.instructions !== 'string') {
+        if (RESPONSES_INSTRUCTIONS_REASONING_FIELD in payload) {
+            delete payload[RESPONSES_INSTRUCTIONS_REASONING_FIELD];
+        }
+        return;
+    }
+    const { cleaned, segments } = stripReasoningFromString(payload.instructions);
+    payload.instructions = cleaned;
+    if (segments.length) {
+        payload[RESPONSES_INSTRUCTIONS_REASONING_FIELD] = segments.join('\n');
+    }
+    else if (RESPONSES_INSTRUCTIONS_REASONING_FIELD in payload) {
+        delete payload[RESPONSES_INSTRUCTIONS_REASONING_FIELD];
+    }
+}
+function normalizeResponsesRequiredAction(payload) {
+    if (!isRecord(payload.required_action)) {
+        return;
+    }
+    const submit = payload.required_action.submit_tool_outputs;
+    if (!submit || typeof submit !== 'object') {
+        return;
+    }
+    const toolCalls = Array.isArray(submit.tool_calls)
+        ? submit.tool_calls
+        : [];
+    toolCalls.forEach((call) => {
+        if (!isRecord(call))
+            return;
+        if (typeof call.instructions === 'string') {
+            const { cleaned, segments } = stripReasoningFromString(call.instructions);
+            call.instructions = cleaned;
+            if (segments.length) {
+                call.reasoning_content = mergeReasoningText(call.reasoning_content, segments);
+            }
+            else if ('reasoning_content' in call) {
+                delete call.reasoning_content;
+            }
+        }
+    });
+}
+function stripReasoningFromString(value) {
+    if (typeof value !== 'string') {
+        return { cleaned: typeof value === 'string' ? value : '', segments: [] };
+    }
+    const segments = [];
+    const cleaned = extractReasoningSegments(value, segments);
+    return { cleaned, segments };
+}
+function mergeReasoningText(existing, segments) {
+    const combined = [];
+    if (typeof existing === 'string' && existing.trim().length) {
+        combined.push(existing.trim());
+    }
+    for (const segment of segments) {
+        if (typeof segment === 'string' && segment.trim().length) {
+            combined.push(segment.trim());
+        }
+    }
+    return combined.join('\n');
+}
+export function normalizeReasoningInGeminiPayload(payload) {
+    if (!payload) {
+        return;
+    }
+    const contents = Array.isArray(payload.contents) ? payload.contents : [];
+    contents.forEach((content) => {
+        if (!isRecord(content))
+            return;
+        const parts = Array.isArray(content.parts) ? content.parts : [];
+        parts.forEach((part) => {
+            if (!isRecord(part) || typeof part.text !== 'string') {
+                return;
+            }
+            const reasoningSegments = [];
+            const cleaned = extractReasoningSegments(part.text, reasoningSegments);
+            part.text = cleaned;
+            if (reasoningSegments.length) {
+                part.reasoning = reasoningSegments.join('\n');
+            }
+            else if ('reasoning' in part) {
+                delete part.reasoning;
+            }
+        });
+    });
+}
+export function normalizeReasoningInAnthropicPayload(payload) {
+    if (!payload) {
+        return;
+    }
+    const responseContent = Array.isArray(payload.content) ? payload.content : undefined;
+    if (responseContent) {
+        const responseReasoning = [];
+        responseContent.forEach((block) => normalizeAnthropicBlock(block, responseReasoning));
+        if (responseReasoning.length) {
+            payload.reasoning_content = mergeReasoningText(payload.reasoning_content, responseReasoning);
+        }
+        else if ('reasoning_content' in payload) {
+            delete payload.reasoning_content;
+        }
+    }
+    const messages = Array.isArray(payload.messages) ? payload.messages : [];
+    messages.forEach((message) => {
+        if (!isRecord(message))
+            return;
+        normalizeAnthropicMessage(message);
+    });
+    const systemField = payload.system;
+    if (typeof systemField === 'string') {
+        const { cleaned } = stripReasoningFromString(systemField);
+        payload.system = cleaned;
+    }
+    else if (Array.isArray(systemField)) {
+        systemField.forEach((entry) => normalizeAnthropicBlock(entry, []));
+    }
+    else if (isRecord(systemField) && Array.isArray(systemField.content)) {
+        const sysBlocks = systemField.content;
+        systemField.content = sysBlocks.map((block) => {
+            normalizeAnthropicBlock(block, []);
+            return block;
+        });
+    }
+}
+function normalizeAnthropicMessage(message) {
+    const reasoningSegments = [];
+    if (Array.isArray(message.content)) {
+        message.content.forEach((block) => normalizeAnthropicBlock(block, reasoningSegments));
+    }
+    else if (typeof message.content === 'string') {
+        const { cleaned, segments } = stripReasoningFromString(message.content);
+        message.content = cleaned;
+        reasoningSegments.push(...segments);
+    }
+    if (reasoningSegments.length) {
+        message.reasoning_content = mergeReasoningText(message.reasoning_content, reasoningSegments);
+    }
+    else if ('reasoning_content' in message) {
+        delete message.reasoning_content;
+    }
+}
+function normalizeAnthropicBlock(block, collector) {
+    if (typeof block === 'string') {
+        const { cleaned, segments } = stripReasoningFromString(block);
+        collector.push(...segments);
+        return;
+    }
+    if (!isRecord(block)) {
+        return;
+    }
+    const type = typeof block.type === 'string' ? block.type.toLowerCase() : '';
+    if (type === 'text' && typeof block.text === 'string') {
+        const { cleaned, segments } = stripReasoningFromString(block.text);
+        block.text = cleaned;
+        collector.push(...segments);
+        return;
+    }
+    if (type === 'thinking' || type === 'reasoning') {
+        const flattened = flattenAnthropicText(block);
+        if (flattened.trim().length) {
+            collector.push(flattened.trim());
+        }
+        return;
+    }
+    if (Array.isArray(block.content)) {
+        block.content.forEach((nested) => normalizeAnthropicBlock(nested, collector));
+    }
+    else if (typeof block.content === 'string') {
+        const { cleaned, segments } = stripReasoningFromString(block.content);
+        block.content = cleaned;
+        collector.push(...segments);
+    }
+}
+function flattenAnthropicText(source) {
+    if (typeof source === 'string') {
+        return source;
+    }
+    if (Array.isArray(source)) {
+        return source.map((entry) => flattenAnthropicText(entry)).filter(Boolean).join('');
+    }
+    if (isRecord(source)) {
+        if (typeof source.text === 'string') {
+            return source.text;
+        }
+        if (typeof source.content === 'string') {
+            return source.content;
+        }
+        if (Array.isArray(source.content)) {
+            return source.content.map((entry) => flattenAnthropicText(entry)).filter(Boolean).join('');
+        }
+    }
+    return '';
+}

package/dist/conversion/shared/reasoning-tool-normalizer.d.ts

@@ -0,0 +1,12 @@
+type UnknownRecord = Record<string, unknown>;
+export interface ReasoningNormalizationResult {
+    toolCallsAdded: number;
+    cleanedReasoning?: string;
+}
+export declare function normalizeMessageReasoningTools(message: UnknownRecord | null | undefined, options?: {
+    idPrefix?: string;
+}): ReasoningNormalizationResult;
+export declare function normalizeChatResponseReasoningTools(response: UnknownRecord | null | undefined, options?: {
+    idPrefixBase?: string;
+}): void;
+export {};