@jsonstudio/llms 0.6.1892 → 0.6.2172

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

@@ -166,7 +166,8 @@ function requireSystemText(block, context) {
 const ANTHROPIC_TOOL_NAME_ALIASES = new Map([
     ['bash', 'shell_command'],
     ['shell', 'shell_command'],
-    ['terminal', 'shell_command']
+    ['terminal', 'shell_command'],
+    ['exec_command', 'shell_command']
 ]);
 const CANONICAL_TO_ANTHROPIC_TOOL_NAMES = new Map([['shell_command', 'Bash']]);
 const ANTHROPIC_TOP_LEVEL_FIELDS = new Set([
@@ -221,6 +222,69 @@ export function denormalizeAnthropicToolName(value) {
     }
     return trimmed;
 }
+function coerceShellLikeCommand(value) {
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        return trimmed.length ? trimmed : undefined;
+    }
+    if (Array.isArray(value)) {
+        const parts = value
+            .map((entry) => (typeof entry === 'string' ? entry.trim() : ''))
+            .filter((entry) => entry.length > 0);
+        if (!parts.length) {
+            return undefined;
+        }
+        return parts.join(' ');
+    }
+    return undefined;
+}
+function normalizeShellLikeToolInput(toolName, input) {
+    const canonical = normalizeAnthropicToolName(toolName);
+    if (canonical !== 'shell_command') {
+        return input;
+    }
+    const rawToolName = typeof toolName === 'string' ? toolName.trim().toLowerCase() : '';
+    const isExecCommand = rawToolName === 'exec_command';
+    if (!input || typeof input !== 'object' || Array.isArray(input)) {
+        const cmd = coerceShellLikeCommand(input);
+        if (!cmd) {
+            return {};
+        }
+        return isExecCommand ? { cmd } : { command: cmd };
+    }
+    const next = { ...input };
+    const commandValue = coerceShellLikeCommand(next.command);
+    const cmdValue = coerceShellLikeCommand(next.cmd);
+    const fallbackValue = coerceShellLikeCommand(next.script) ??
+        coerceShellLikeCommand(next.toon);
+    if (commandValue) {
+        next.command = commandValue;
+    }
+    if (cmdValue) {
+        next.cmd = cmdValue;
+    }
+    if (!commandValue && !cmdValue && fallbackValue) {
+        if (isExecCommand) {
+            next.cmd = fallbackValue;
+        }
+        else {
+            next.command = fallbackValue;
+        }
+    }
+    else if (!commandValue && cmdValue && !isExecCommand) {
+        next.command = cmdValue;
+    }
+    else if (!cmdValue && commandValue && isExecCommand) {
+        next.cmd = commandValue;
+    }
+    if (!isExecCommand && 'cmd' in next) {
+        delete next.cmd;
+    }
+    if (typeof next.workdir !== 'string' && typeof next.cwd === 'string' && next.cwd.trim().length > 0) {
+        next.workdir = next.cwd.trim();
+    }
+    return next;
+}
 function invertAnthropicAliasMap(source) {
     if (!source) {
         return undefined;
@@ -510,6 +574,7 @@ export function buildAnthropicFromOpenAIChat(oa, options) {
             else {
                 input = argsRaw ?? {};
             }
+            input = normalizeShellLikeToolInput(name, input);
             blocks.push({ type: 'tool_use', id, name, input });
         }
         catch {
@@ -660,7 +725,15 @@ function createAnthropicToolNameResolver(source) {
         if (!trimmed.length) {
             return name;
         }
-        return lookup.get(trimmed) ?? lookup.get(trimmed.toLowerCase()) ?? trimmed;
+        const direct = lookup.get(trimmed) ?? lookup.get(trimmed.toLowerCase());
+        if (direct) {
+            return direct;
+        }
+        const normalized = normalizeAnthropicToolName(trimmed);
+        if (normalized) {
+            return lookup.get(normalized) ?? lookup.get(normalized.toLowerCase()) ?? trimmed;
+        }
+        return trimmed;
     };
 }
 function normalizeAnthropicToolChoice(value) {
@@ -928,6 +1001,7 @@ export function buildAnthropicRequestFromOpenAIChat(chatReq) {
             else {
                 input = argsRaw ?? {};
             }
+            input = normalizeShellLikeToolInput(name, input);
             blocks.push({ type: 'tool_use', id, name, input });
         }
         if (blocks.length > 0) {
@@ -1167,6 +1241,12 @@ export function buildAnthropicToolAliasMap(rawTools) {
             continue;
         }
         aliasMap.set(canonicalKey, rawName);
+        // Anthropic shell-like tools (e.g. Bash) and exec_command are treated as one family.
+        // Keep an explicit exec_command key so reverse mapping can preserve
+        // canonical exec_command when upstream already uses that name.
+        if (canonicalKey === 'shell_command' && !aliasMap.has('exec_command')) {
+            aliasMap.set('exec_command', rawName);
+        }
         const lowerKey = canonicalKey.toLowerCase();
         if (lowerKey !== canonicalKey && !aliasMap.has(lowerKey)) {
             aliasMap.set(lowerKey, rawName);

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

@@ -60,8 +60,8 @@ function collectText(value) {
     }
     return '';
 }
-function extractImageBlocksFromContent(content) {
-    const images = [];
+function extractMediaBlocksFromContent(content) {
+    const media = [];
     const visit = (value) => {
         if (!value)
             return;
@@ -75,14 +75,27 @@ function extractImageBlocksFromContent(content) {
         }
         const record = value;
         const typeValue = typeof record.type === 'string' ? record.type.toLowerCase() : '';
+        let kind = null;
         if (typeValue === 'image' || typeValue === 'image_url' || typeValue === 'input_image') {
+            kind = 'image';
+        }
+        else if (typeValue === 'video' || typeValue === 'video_url' || typeValue === 'input_video') {
+            kind = 'video';
+        }
+        else if (record.video_url !== undefined) {
+            kind = 'video';
+        }
+        else if (record.image_url !== undefined) {
+            kind = 'image';
+        }
+        if (kind) {
             let url = '';
-            const imageUrl = record.image_url;
-            if (typeof imageUrl === 'string') {
-                url = imageUrl;
+            const mediaUrl = kind === 'video' ? record.video_url : record.image_url;
+            if (typeof mediaUrl === 'string') {
+                url = mediaUrl;
             }
-            else if (imageUrl && typeof imageUrl === 'object' && typeof imageUrl.url === 'string') {
-                url = imageUrl.url;
+            else if (mediaUrl && typeof mediaUrl === 'object' && typeof mediaUrl.url === 'string') {
+                url = mediaUrl.url;
             }
             else if (typeof record.url === 'string') {
                 url = record.url;
@@ -96,13 +109,13 @@ function extractImageBlocksFromContent(content) {
             const trimmed = url.trim();
             if (trimmed.length) {
                 let detail;
-                if (imageUrl && typeof imageUrl === 'object' && typeof imageUrl.detail === 'string') {
-                    detail = imageUrl.detail.trim() || undefined;
+                if (mediaUrl && typeof mediaUrl === 'object' && typeof mediaUrl.detail === 'string') {
+                    detail = mediaUrl.detail.trim() || undefined;
                 }
                 else if (typeof record.detail === 'string') {
                     detail = record.detail.trim() || undefined;
                 }
-                images.push({ url: trimmed, detail });
+                media.push({ kind, url: trimmed, detail });
             }
             return;
         }
@@ -111,7 +124,7 @@ function extractImageBlocksFromContent(content) {
         }
     };
     visit(content);
-    return images;
+    return media;
 }
 function extractUserTextFromEntry(entry) {
     if (!entry || typeof entry !== 'object')
@@ -141,7 +154,7 @@ export function convertMessagesToBridgeInput(options) {
         const role = coerceBridgeRole(m.role || 'user');
         const content = m.content;
         const collectedText = collectText(content);
-        const imageBlocks = extractImageBlocksFromContent(content);
+        const mediaBlocks = extractMediaBlocksFromContent(content);
         const text = role === 'system' ? collectedText : collectedText.trim();
         if (role === 'system') {
             if (collectedText && collectedText.length) {
@@ -218,20 +231,26 @@ export function convertMessagesToBridgeInput(options) {
             }
             continue;
         }
-        if (typeof text === 'string' || imageBlocks.length) {
+        if (typeof text === 'string' || mediaBlocks.length) {
             const tRole = role === 'assistant' ? 'output_text' : 'input_text';
             const blocks = [];
             if (typeof text === 'string' && text.length) {
                 blocks.push({ type: tRole, text });
             }
-            for (const img of imageBlocks) {
-                const block = {
-                    type: 'input_image',
-                    image_url: img.url
-                };
-                if (img.detail) {
-                    block.detail = img.detail;
+            for (const media of mediaBlocks) {
+                const block = media.kind === 'video'
+                    ? {
+                        type: 'input_video',
+                        video_url: media.url
+                    }
+                    : {
+                        type: 'input_image',
+                        image_url: media.url
+                    };
+                if (media.detail) {
+                    block.detail = media.detail;
                 }
+                ;
                 blocks.push(block);
             }
             if (blocks.length) {
@@ -324,7 +343,7 @@ function processMessageBlocks(blocks, normalizeFunctionName, tools, toolNameById
     const toolMessages = [];
     let currentLastCall = lastToolCallId;
     const reasoningSegments = [];
-    const images = [];
+    const mediaBlocks = [];
     for (const block of blocks) {
         if (!block || typeof block !== 'object')
             continue;
@@ -347,17 +366,45 @@ function processMessageBlocks(blocks, normalizeFunctionName, tools, toolNameById
                 toolMessages.push(tm);
             currentLastCall = nested.lastCallId;
             reasoningSegments.push(...nested.reasoningSegments);
-            if (nested.images.length)
-                images.push(...nested.images);
+            if (nested.mediaBlocks.length)
+                mediaBlocks.push(...nested.mediaBlocks);
+            continue;
+        }
+        if (type === 'input_image' || type === 'image' || type === 'image_url') {
+            let url = '';
+            if (typeof block.image_url === 'string') {
+                url = block.image_url.trim();
+            }
+            else if (block.image_url && typeof block.image_url.url === 'string') {
+                url = block.image_url.url.trim();
+            }
+            else if (typeof block.url === 'string') {
+                url = block.url.trim();
+            }
+            if (url) {
+                const detail = typeof block.detail === 'string' && block.detail.trim()
+                    ? block.detail.trim()
+                    : undefined;
+                mediaBlocks.push({ kind: 'image', url, detail });
+            }
             continue;
         }
-        if (type === 'input_image') {
-            const url = typeof block.image_url === 'string' ? block.image_url.trim() : '';
+        if (type === 'input_video' || type === 'video' || type === 'video_url') {
+            let url = '';
+            if (typeof block.video_url === 'string') {
+                url = block.video_url.trim();
+            }
+            else if (block.video_url && typeof block.video_url.url === 'string') {
+                url = block.video_url.url.trim();
+            }
+            else if (typeof block.url === 'string') {
+                url = block.url.trim();
+            }
             if (url) {
                 const detail = typeof block.detail === 'string' && block.detail.trim()
                     ? block.detail.trim()
                     : undefined;
-                images.push({ url, detail });
+                mediaBlocks.push({ kind: 'video', url, detail });
             }
             continue;
         }
@@ -421,7 +468,7 @@ function processMessageBlocks(blocks, normalizeFunctionName, tools, toolNameById
         }
     }
     const text = textParts.length ? textParts.join('\n').trim() : null;
-    return { text, images, toolCalls, toolMessages, lastCallId: currentLastCall, reasoningSegments };
+    return { text, mediaBlocks, toolCalls, toolMessages, lastCallId: currentLastCall, reasoningSegments };
 }
 export function convertBridgeInputToChatMessages(options) {
     const { input, tools, normalizeFunctionName, toolResultFallbackText } = options;
@@ -547,17 +594,20 @@ export function convertBridgeInputToChatMessages(options) {
             for (const msg of nested.toolMessages)
                 messages.push(msg);
             const normalizedRole = coerceBridgeRole((explicit.role ?? entry.role) || 'user');
-            if (nested.images.length) {
+            if (nested.mediaBlocks.length) {
                 const contentBlocks = [];
                 if (typeof nested.text === 'string' && nested.text.trim().length) {
                     contentBlocks.push({ type: 'text', text: nested.text });
                 }
-                for (const img of nested.images) {
-                    const imgBlock = { type: 'image_url', image_url: { url: img.url } };
-                    if (img.detail) {
-                        imgBlock.image_url.detail = img.detail;
+                for (const media of nested.mediaBlocks) {
+                    const mediaBlock = media.kind === 'video'
+                        ? { type: 'video_url', video_url: { url: media.url } }
+                        : { type: 'image_url', image_url: { url: media.url } };
+                    if (media.detail) {
+                        const key = media.kind === 'video' ? 'video_url' : 'image_url';
+                        mediaBlock[key].detail = media.detail;
                     }
-                    contentBlocks.push(imgBlock);
+                    contentBlocks.push(mediaBlock);
                 }
                 const msg = {
                     role: normalizedRole,
@@ -590,17 +640,20 @@ export function convertBridgeInputToChatMessages(options) {
             for (const msg of nested.toolMessages)
                 messages.push(msg);
             const normalizedRole = coerceBridgeRole(entry.role || 'user');
-            if (nested.images.length) {
+            if (nested.mediaBlocks.length) {
                 const contentBlocks = [];
                 if (typeof nested.text === 'string' && nested.text.trim().length) {
                     contentBlocks.push({ type: 'text', text: nested.text });
                 }
-                for (const img of nested.images) {
-                    const imgBlock = { type: 'image_url', image_url: { url: img.url } };
-                    if (img.detail) {
-                        imgBlock.image_url.detail = img.detail;
+                for (const media of nested.mediaBlocks) {
+                    const mediaBlock = media.kind === 'video'
+                        ? { type: 'video_url', video_url: { url: media.url } }
+                        : { type: 'image_url', image_url: { url: media.url } };
+                    if (media.detail) {
+                        const key = media.kind === 'video' ? 'video_url' : 'image_url';
+                        mediaBlock[key].detail = media.detail;
                     }
-                    contentBlocks.push(imgBlock);
+                    contentBlocks.push(mediaBlock);
                 }
                 const msg = {
                     role: normalizedRole,

package/dist/conversion/shared/snapshot-hooks.js

@@ -83,11 +83,11 @@ async function writeUniqueErrorsampleFile(dir, baseName, contents) {
     await fs.writeFile(path.join(dir, fallback), contents, { encoding: 'utf-8' });
 }
 function resolveSnapshotFolder(endpoint) {
-    const lowered = (endpoint || '').toLowerCase();
-    if (lowered.includes('/responses')) {
+    const lowered = (endpoint || '').trim().toLowerCase();
+    if (lowered.includes('/v1/responses') || lowered.includes('/responses.submit')) {
         return 'openai-responses';
     }
-    if (lowered.includes('/messages')) {
+    if (lowered.includes('/v1/messages')) {
         return 'anthropic-messages';
     }
     return 'openai-chat';
@@ -187,8 +187,7 @@ function extractNestedEntryEndpoint(value) {
     }
     const obj = value;
     const direct = readStringField(obj.entryEndpoint) ||
-        readStringField(obj.entry_endpoint) ||
-        readStringField(obj.endpoint);
+        readStringField(obj.entry_endpoint);
     if (direct) {
         return direct;
     }
@@ -196,8 +195,7 @@ function extractNestedEntryEndpoint(value) {
     if (meta && typeof meta === 'object') {
         const m = meta;
         const fromMeta = readStringField(m.entryEndpoint) ||
-            readStringField(m.entry_endpoint) ||
-            readStringField(m.endpoint);
+            readStringField(m.entry_endpoint);
         if (fromMeta) {
             return fromMeta;
         }
@@ -205,8 +203,7 @@ function extractNestedEntryEndpoint(value) {
         if (ctx && typeof ctx === 'object') {
             const c = ctx;
             const fromCtx = readStringField(c.entryEndpoint) ||
-                readStringField(c.entry_endpoint) ||
-                readStringField(c.endpoint);
+                readStringField(c.entry_endpoint);
             if (fromCtx) {
                 return fromCtx;
             }
@@ -216,8 +213,7 @@ function extractNestedEntryEndpoint(value) {
     if (metadata && typeof metadata === 'object') {
         const md = metadata;
         const fromMetadata = readStringField(md.entryEndpoint) ||
-            readStringField(md.entry_endpoint) ||
-            readStringField(md.endpoint);
+            readStringField(md.entry_endpoint);
         if (fromMetadata) {
             return fromMetadata;
         }
@@ -226,8 +222,7 @@ function extractNestedEntryEndpoint(value) {
     if (runtime && typeof runtime === 'object') {
         const r = runtime;
         const fromRuntime = readStringField(r.entryEndpoint) ||
-            readStringField(r.entry_endpoint) ||
-            readStringField(r.endpoint);
+            readStringField(r.entry_endpoint);
         if (fromRuntime) {
             return fromRuntime;
         }

package/dist/conversion/shared/text-markup-normalizer/extractors-apply-patch.d.ts

@@ -0,0 +1,2 @@
+import { type ToolCallLite } from './extractors-shared.js';
+export declare function extractApplyPatchCallsFromText(text: string): ToolCallLite[] | null;

package/dist/conversion/shared/text-markup-normalizer/extractors-apply-patch.js

@@ -0,0 +1,129 @@
+import { isStructuredApplyPatchPayload } from '../../../tools/apply-patch-structured.js';
+import { genToolCallId } from './extractors-shared.js';
+function extractStructuredApplyPatchPayloads(text) {
+    const payloads = [];
+    try {
+        const fenceRe = /```(?:json|apply_patch|toon)?\s*([\s\S]*?)\s*```/gi;
+        let fm;
+        while ((fm = fenceRe.exec(text)) !== null) {
+            const body = fm[1] || '';
+            try {
+                const parsed = JSON.parse(body);
+                if (isStructuredApplyPatchPayload(parsed)) {
+                    payloads.push(parsed);
+                }
+            }
+            catch {
+                /* ignore invalid JSON */
+            }
+        }
+        if (!payloads.length && typeof text === 'string' && text.includes('"changes"')) {
+            try {
+                const parsed = JSON.parse(text);
+                if (isStructuredApplyPatchPayload(parsed)) {
+                    payloads.push(parsed);
+                }
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return payloads;
+}
+function normalizeRawApplyPatchBlock(raw) {
+    try {
+        const lines = String(raw || '')
+            .split(/\r?\n/)
+            .map((line) => line.replace(/\r/g, ''));
+        while (lines.length > 0 && !lines[0].trim()) {
+            lines.shift();
+        }
+        while (lines.length > 0 && !lines[lines.length - 1].trim()) {
+            lines.pop();
+        }
+        if (!lines.length)
+            return '';
+        const indents = lines
+            .filter((line) => line.trim().length > 0)
+            .map((line) => {
+            const m = line.match(/^[ \t]*/);
+            return m ? m[0].length : 0;
+        });
+        const minIndent = indents.length ? Math.min(...indents) : 0;
+        if (minIndent <= 0) {
+            return lines.join('\n').trim();
+        }
+        return lines
+            .map((line) => line.replace(new RegExp(`^[ \\t]{0,${minIndent}}`), ''))
+            .join('\n')
+            .trim();
+    }
+    catch {
+        return String(raw || '').trim();
+    }
+}
+function extractRawApplyPatchBlocks(text) {
+    const out = [];
+    try {
+        if (typeof text !== 'string' || !text)
+            return out;
+        const seen = new Set();
+        const blockRe = /\*\*\*\s*Begin Patch(?:\s*\*\*\*)?[\s\S]*?\*\*\*\s*End Patch(?:\s*\*\*\*)?/gi;
+        let m;
+        while ((m = blockRe.exec(text)) !== null) {
+            const normalized = normalizeRawApplyPatchBlock(String(m[0] || ''));
+            if (!normalized)
+                continue;
+            // Avoid turning incidental prose into apply_patch.
+            if (!/\*\*\*\s*(?:Add|Update|Delete)\s+File:/i.test(normalized))
+                continue;
+            if (seen.has(normalized))
+                continue;
+            seen.add(normalized);
+            out.push(normalized);
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return out;
+}
+export function extractApplyPatchCallsFromText(text) {
+    try {
+        if (typeof text !== 'string' || !text)
+            return null;
+        const payloads = extractStructuredApplyPatchPayloads(text);
+        const patchBlocks = extractRawApplyPatchBlocks(text);
+        if (!payloads.length && !patchBlocks.length)
+            return null;
+        const out = [];
+        for (const payload of payloads) {
+            let argsStr = '{}';
+            try {
+                argsStr = JSON.stringify(payload);
+            }
+            catch {
+                argsStr = '{"changes":[]}';
+            }
+            out.push({ id: genToolCallId(), name: 'apply_patch', args: argsStr });
+        }
+        for (const patch of patchBlocks) {
+            let argsStr = '{}';
+            try {
+                argsStr = JSON.stringify({ patch, input: patch });
+            }
+            catch {
+                argsStr = '{"patch":""}';
+            }
+            out.push({ id: genToolCallId(), name: 'apply_patch', args: argsStr });
+        }
+        return out;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/conversion/shared/text-markup-normalizer/extractors-json.d.ts

@@ -0,0 +1,4 @@
+import { type TextMarkupNormalizeOptions, type ToolCallLite } from './extractors-shared.js';
+export declare function tryParseJsonWithModelRepairs(raw: string): unknown | null;
+export declare function salvageToolArgsFromRawText(toolName: string, rawArgs: string): Record<string, unknown> | null;
+export declare function extractJsonToolCallsFromText(text: string, options?: TextMarkupNormalizeOptions): ToolCallLite[] | null;