lynkr 9.14.10 → 9.14.12

package/src/cache/prompt.js

@@ -37,6 +37,45 @@ function stableStringify(value) {
   return JSON.stringify(normaliseObject(value));
 }
 
+/**
+ * Replace image bytes with short hashes for cache keys.
+ * Prevents multi-MB base64 from entering SQLite keys/values index path and
+ * gives stable keys for identical images without hashing megabytes per request.
+ */
+function stripImageBytesForKey(messages) {
+  if (!Array.isArray(messages)) return messages;
+  let hashImageData = null;
+  try {
+    hashImageData = require('../routing/vision').hashImageData;
+  } catch { hashImageData = null; }
+  const shortHash = (s) => {
+    if (!hashImageData || typeof s !== 'string') return `[image:${String(s ?? '').length}]`;
+    try { return `[image:${hashImageData(s)}]`; } catch { return `[image:${String(s).length}]`; }
+  };
+  return messages.map((msg) => {
+    if (!msg || !Array.isArray(msg.content)) return msg;
+    return {
+      ...msg,
+      content: msg.content.map((block) => {
+        if (!block || typeof block !== 'object') return block;
+        if (block.type === 'image' && typeof block.source?.data === 'string') {
+          return { ...block, source: { ...block.source, data: shortHash(block.source.data) } };
+        }
+        if (typeof block.image_url?.url === 'string' && block.image_url.url.startsWith('data:image')) {
+          return { ...block, image_url: { ...block.image_url, url: shortHash(block.image_url.url) } };
+        }
+        if (typeof block.inlineData?.data === 'string') {
+          return { ...block, inlineData: { ...block.inlineData, data: shortHash(block.inlineData.data) } };
+        }
+        if (block.type === 'tool_result' && Array.isArray(block.content)) {
+          return { ...block, content: stripImageBytesForKey([{ content: block.content }])[0].content };
+        }
+        return block;
+      }),
+    };
+  });
+}
+
 class PromptCache {
   constructor(options = {}) {
     this.enabled = options.enabled === true;
@@ -158,7 +197,7 @@ class PromptCache {
       const canonical = {
         model: payload.model ?? null,
         input: payload.input ?? null,
-        messages: payload.messages ? normaliseObject(payload.messages) : null,
+        messages: payload.messages ? normaliseObject(stripImageBytesForKey(payload.messages)) : null,
         tools: payload.tools ? normaliseObject(payload.tools) : null,
         tool_choice: payload.tool_choice ? normaliseObject(payload.tool_choice) : null,
         temperature: payload.temperature ?? null,

package/src/cache/semantic.js

@@ -162,6 +162,13 @@ class SemanticCache {
         }
         return count;
       }, 0),
+      // Vision hash: same text + different image must NOT hit. Null when no
+      // images (backwards compatible with existing entries).
+      visionHash: (() => {
+        try {
+          return require('../routing/vision').visionContextHash(messages);
+        } catch { return null; }
+      })(),
     };
 
     hash.update(JSON.stringify(conversationState));

package/src/clients/databricks.js

@@ -1810,6 +1810,62 @@ async function invokeLMStudio(body, _incomingHeaders = {}) {
   return performJsonRequest(endpoint, { headers, body: lmstudioBody }, "LM Studio");
 }
 
+/**
+ * Map a single Anthropic content block to Bedrock Converse content.
+ * Text -> {text}; image base64 -> {image:{format, source:{bytes}}};
+ * image URL / unsupported -> text placeholder (Converse has no URL fetch).
+ * Returns null for cache_control-only / empty blocks.
+ *
+ * @param {object|string} block
+ * @returns {object|null}
+ */
+function anthropicBlockToConverseContent(block) {
+  if (block == null) return null;
+  if (typeof block === 'string') return block ? { text: block } : null;
+  if (block.type === 'text' && typeof block.text === 'string') {
+    return block.text ? { text: block.text } : null;
+  }
+  if (block.type === 'image' && block.source) {
+    const src = block.source;
+    if (src.type === 'base64' && src.data) {
+      const mediaType = (src.media_type || 'image/jpeg').toLowerCase();
+      const format = mediaType.includes('png') ? 'png'
+        : mediaType.includes('gif') ? 'gif'
+        : mediaType.includes('webp') ? 'webp'
+        : 'jpeg';
+      try {
+        return { image: { format, source: { bytes: src.data } } };
+      } catch { return null; }
+    }
+    if (src.type === 'url' && src.url) {
+      return { text: `[Image URL: ${src.url}]` };
+    }
+  }
+  // OpenAI-shaped image_url (may already be converted upstream)
+  const imageUrl = block.image_url?.url || (typeof block.url === 'string' ? block.url : null);
+  if ((block.type === 'image_url' || block.type === 'input_image' || imageUrl) && imageUrl) {
+    const dataMatch = String(imageUrl).match(/^data:(image\/[^;]+);base64,(.+)$/);
+    if (dataMatch) {
+      const mediaType = dataMatch[1].toLowerCase();
+      const format = mediaType.includes('png') ? 'png'
+        : mediaType.includes('gif') ? 'gif'
+        : mediaType.includes('webp') ? 'webp'
+        : 'jpeg';
+      return { image: { format, source: { bytes: dataMatch[2] } } };
+    }
+    return { text: `[Image URL: ${imageUrl}]` };
+  }
+  if (block.type === 'tool_use' || block.type === 'tool_result' || block.type === 'thinking') {
+    // Tool/thinking blocks are handled by the toolConfig path or dropped for
+    // pure-text turns — preserve text content when present.
+    const text = block.text || (typeof block.content === 'string' ? block.content : null);
+    return text ? { text } : null;
+  }
+  if (typeof block.text === 'string' && block.text) return { text: block.text };
+  if (typeof block.content === 'string' && block.content) return { text: block.content };
+  return null;
+}
+
 /**
  * Flatten an Anthropic-style content value into a plain string for the
  * Bedrock Converse API.
@@ -1919,9 +1975,10 @@ async function invokeBedrock(body, _incomingHeaders = {}) {
       .map(msg => ({
         role: msg.role,
         content: Array.isArray(msg.content)
-          ? msg.content.map(c => ({ text: c.text || c.content || "" }))
-          : [{ text: msg.content }]
+          ? msg.content.map(c => anthropicBlockToConverseContent(c)).filter(Boolean)
+          : [{ text: String(msg.content ?? '') }]
       }))
+      .map(m => ({ ...m, content: m.content.length > 0 ? m.content : [{ text: ' ' }] }))
   };
 
   // Add system prompt (from Anthropic system field OR extracted from messages)
@@ -2836,6 +2893,137 @@ function sanitizeSchemaForGemini(schema) {
   return sanitized;
 }
 
+/**
+ * OrcaRouter Provider (OpenAI-compatible gateway)
+ *
+ * OrcaRouter exposes an OpenAI-compatible Chat Completions API at
+ * https://api.orcarouter.ai/v1/chat/completions with Bearer-token auth.
+ * Modeled on invokeFireworks/invokeAtlas: request side reuses the shared
+ * openrouter-utils converters, streaming returns the raw OpenAI SSE stream
+ * (orcarouter is in DEFAULT_OPENAI_SSE_PROVIDERS), buffered responses are
+ * converted to Anthropic shape locally so the orchestrator branch is a plain
+ * passthrough.
+ *
+ * The key comes from the credential seam (src/clients/orcarouter-credentials):
+ * either a user-pasted sk-orca-… key or a key issued via OAuth 2.0 + PKCE.
+ * Downstream code never knows which source produced it.
+ */
+async function invokeOrcaRouter(body, _incomingHeaders = {}) {
+  const {
+    convertAnthropicToolsToOpenRouter,
+    convertAnthropicMessagesToOpenRouter
+  } = require("./openrouter-utils");
+  const { chatCompletionsUrl } = require("./orcarouter-catalog");
+
+  const apiKey = config.orcarouter?.apiKey;
+  if (!apiKey) {
+    throw new Error("OrcaRouter API key is not configured. Run `lynkr connect orcarouter` or set ORCAROUTER_API_KEY in your .env file.");
+  }
+
+  // Defense in depth: never send the Bearer key over remote plaintext HTTP.
+  // chatCompletionsUrl() already validates the base; validate an explicit
+  // ORCAROUTER_ENDPOINT override here too (config is lazy by design).
+  try {
+    const { assertAllowedOrigin } = require("./orcarouter-credentials");
+    const epOrigin = new URL(config.orcarouter?.endpoint || chatCompletionsUrl(config.orcarouter?.apiBaseUrl)).origin;
+    assertAllowedOrigin(epOrigin, { allowHttpLoopback: true });
+  } catch (err) {
+    throw new Error(`OrcaRouter endpoint rejected: ${err.message}`);
+  }
+
+  const endpoint = config.orcarouter?.endpoint || chatCompletionsUrl(config.orcarouter?.apiBaseUrl || "https://api.orcarouter.ai");
+
+  const requestedModel = body._tierModel || body.model || config.orcarouter?.model || "orcarouter/auto";
+  const messages = convertAnthropicMessagesToOpenRouter(body.messages || []);
+
+  if (body.system) {
+    const systemContent = Array.isArray(body.system)
+      ? body.system.map(s => s.text || s).join("\n")
+      : body.system;
+    messages.unshift({ role: "system", content: systemContent });
+  }
+
+  const { resolveThinkingParam } = require("./provider-capabilities");
+  const orcaBody = {
+    model: requestedModel,
+    messages,
+    max_tokens: body.max_tokens || 16384,
+    temperature: body.temperature ?? 0.7,
+    top_p: body.top_p ?? 1.0,
+    thinking: resolveThinkingParam(body),
+    stream: body.stream ?? false,
+  };
+
+  if (Array.isArray(body.tools) && body.tools.length > 0) {
+    orcaBody.tools = convertAnthropicToolsToOpenRouter(body.tools);
+    orcaBody.tool_choice = "auto";
+    orcaBody.parallel_tool_calls = false;
+  }
+
+  const headers = {
+    "Content-Type": "application/json",
+    "Authorization": `Bearer ${apiKey}`,
+  };
+
+  logger.debug({
+    endpoint,
+    model: orcaBody.model,
+    originalModel: requestedModel,
+    messageCount: orcaBody.messages?.length || 0,
+    hasTools: !!orcaBody.tools,
+    toolCount: orcaBody.tools?.length || 0,
+  }, "=== OrcaRouter REQUEST ===");
+
+  // Same pre-return 429 check as the other OpenAI-compatible providers:
+  // performJsonRequest's streaming branch never throws on a bad status, so a
+  // 429 would otherwise be silently handed back as a "successful" response
+  // and tier-fallback would never climb. Like Atlas Cloud, chat completions
+  // are billable POSTs and are never replayed automatically — callers can
+  // retry explicitly with their own idempotency policy; only 429 escalates
+  // to tier-fallback.
+  const response = await performJsonRequest(endpoint, {
+    headers,
+    body: orcaBody,
+    maxRetriesOverride: 0,
+    retryableStatusesOverride: [],
+  }, "OrcaRouter");
+
+  // A 401 means the durable key was revoked (there is no refresh grant).
+  // Mark the exact credential generation needsReauth — the UI/status command
+  // surfaces it and the user re-runs `lynkr connect orcarouter`. No retry
+  // loop, no fake refresh.
+  if (response && !response.ok && response.status === 401) {
+    try {
+      const { getCredentialStore } = require("./orcarouter-credentials");
+      getCredentialStore().markRejected(apiKey, null);
+    } catch { /* reauth marking is best-effort — never fail the request path */ }
+  }
+
+  if (!response.ok && response.status === 429) {
+    const err = new Error(`OrcaRouter rate-limited: ${String(response.json?.error?.message || '').slice(0, 120)}`);
+    err.status = 429;
+    throw err;
+  }
+
+  if (response?.stream) {
+    return response;
+  }
+
+  if (response?.ok && response?.json) {
+    const anthropicJson = convertOpenAIToAnthropic(response.json);
+    return {
+      ok: response.ok,
+      status: response.status,
+      json: anthropicJson,
+      text: JSON.stringify(anthropicJson),
+      contentType: "application/json",
+      headers: response.headers,
+    };
+  }
+
+  return response;
+}
+
 /**
  * Vertex AI Provider - Gemini Models
  *
@@ -2997,6 +3185,33 @@ IMPORTANT TOOL USAGE RULES:
       for (const block of msg.content) {
         if (block.type === "text") {
           parts.push({ text: block.text });
+        } else if (block.type === "image" && block.source?.type === "base64" && block.source?.data) {
+          parts.push({
+            inlineData: {
+              mimeType: block.source.media_type || "image/jpeg",
+              data: block.source.data,
+            },
+          });
+        } else if (block.type === "image" && block.source?.type === "url" && block.source?.url) {
+          parts.push({ text: `[Image URL: ${block.source.url}]` });
+        } else if ((block.type === "image_url" || block.type === "input_image") && block.image_url?.url) {
+          const url = block.image_url.url;
+          const dataMatch = String(url).match(/^data:(image\/[^;]+);base64,(.+)$/);
+          if (dataMatch) {
+            parts.push({ inlineData: { mimeType: dataMatch[1], data: dataMatch[2] } });
+          } else {
+            parts.push({ text: `[Image URL: ${url}]` });
+          }
+        } else if (block.image_url?.url) {
+          const url = block.image_url.url;
+          const dataMatch = String(url).match(/^data:(image\/[^;]+);base64,(.+)$/);
+          if (dataMatch) {
+            parts.push({ inlineData: { mimeType: dataMatch[1], data: dataMatch[2] } });
+          } else {
+            parts.push({ text: `[Image URL: ${url}]` });
+          }
+        } else if (block.inlineData?.data) {
+          parts.push({ inlineData: block.inlineData });
         } else if (block.type === "tool_use") {
           // Assistant's tool call
           parts.push({
@@ -3286,6 +3501,7 @@ const PROVIDER_INVOKERS = {
   codex: invokeCodex,
   baidu: invokeBaidu,
   fireworks: invokeFireworks,
+  orcarouter: invokeOrcaRouter,
 };
 
 function invokeProvider(provider, body, incomingHeaders) {
@@ -4157,6 +4373,7 @@ module.exports = {
   invokeBaidu,
   invokeFireworks,
   invokeAtlas,
+  invokeOrcaRouter,
   PROVIDER_INVOKERS,
   stripLynkrBadges,
   destroyHttpAgents,

package/src/clients/openrouter-utils.js

@@ -55,6 +55,25 @@ function convertAnthropicToolsToOpenRouter(anthropicTools) {
  * - User messages with tool_result blocks → OpenRouter tool role messages
  * - Regular text content → OpenRouter text content
  */
+function anthropicImageToOpenAIUrl(block) {
+  if (!block || typeof block !== 'object') return null;
+  // Anthropic: {type:'image', source:{type:'base64', media_type, data}}
+  if (block.type === 'image' && block.source?.type === 'base64' && block.source?.data) {
+    const mediaType = block.source.media_type || 'image/jpeg';
+    return `data:${mediaType};base64,${block.source.data}`;
+  }
+  if (block.type === 'image' && block.source?.type === 'url' && block.source?.url) {
+    return block.source.url;
+  }
+  // Already OpenAI-shaped
+  if ((block.type === 'image_url' || block.type === 'input_image') && block.image_url?.url) {
+    return block.image_url.url;
+  }
+  if (block.image_url?.url) return block.image_url.url;
+  if (typeof block.url === 'string' && block.url.startsWith('data:image')) return block.url;
+  return null;
+}
+
 function convertAnthropicMessagesToOpenRouter(anthropicMessages) {
   if (!Array.isArray(anthropicMessages)) return [];
 
@@ -124,32 +143,80 @@ function convertAnthropicMessagesToOpenRouter(anthropicMessages) {
       // providers 400 the unpaired function_call.
       else if (msg.role === 'user' && toolResultBlocks.length > 0) {
         // Tool results first — adjacent to their assistant tool_calls.
+        // Preserve nested screenshots: emit text to the tool message and
+        // re-attach images as a following user message with image_url parts.
+        const pendingImages = [];
         for (const toolResult of toolResultBlocks) {
+          let toolText = '';
+          const trContent = toolResult.content;
+          if (typeof trContent === 'string') {
+            toolText = trContent;
+          } else if (Array.isArray(trContent)) {
+            const texts = [];
+            for (const b of trContent) {
+              if (b?.type === 'text' && b.text) texts.push(b.text);
+              else {
+                const url = anthropicImageToOpenAIUrl(b);
+                if (url) pendingImages.push(url);
+                else if (b) texts.push(typeof b === 'string' ? b : JSON.stringify(b));
+              }
+            }
+            toolText = texts.join('\n');
+          } else {
+            try { toolText = JSON.stringify(trContent || {}); } catch { toolText = ''; }
+          }
           converted.push({
             role: 'tool',
             tool_call_id: toolResult.tool_use_id || `call_${Date.now()}`,
-            content: typeof toolResult.content === 'string'
-              ? toolResult.content
-              : JSON.stringify(toolResult.content || {})
+            content: toolText
           });
         }
 
-        // Then any user-authored/injected text as a user message.
+        // Then any user-authored/injected text + images as a user message.
         const textContent = textBlocks.map(block => block.text || '').join('\n');
-        if (textContent) {
-          converted.push({
-            role: 'user',
-            content: textContent
-          });
+        for (const b of content) {
+          const url = anthropicImageToOpenAIUrl(b);
+          if (url) pendingImages.push(url);
+        }
+        if (textContent || pendingImages.length > 0) {
+          if (pendingImages.length === 0) {
+            converted.push({ role: 'user', content: textContent });
+          } else {
+            const parts = [];
+            if (textContent) parts.push({ type: 'text', text: textContent });
+            for (const url of pendingImages) {
+              parts.push({ type: 'image_url', image_url: { url } });
+            }
+            converted.push({ role: 'user', content: parts });
+          }
         }
       }
-      // Regular message with just text
+      // Regular message (may carry text + images)
       else {
         const textContent = textBlocks.map(block => block.text || '').join('\n');
-        const message = {
-          role: msg.role,
-          content: textContent || ''
-        };
+        const imageUrls = [];
+        for (const b of content) {
+          const url = anthropicImageToOpenAIUrl(b);
+          if (url) imageUrls.push(url);
+        }
+        // Document blocks with embedded base64 images
+        for (const b of content) {
+          if (b?.type === 'document' && b.source?.data && imageUrls.length === 0) {
+            // PDFs aren't image_url-compatible — keep a text placeholder so the
+            // turn isn't silently emptied (becomes ' ' downstream if nothing else).
+          }
+        }
+        let message;
+        if (imageUrls.length === 0) {
+          message = { role: msg.role, content: textContent || '' };
+        } else {
+          const parts = [];
+          if (textContent) parts.push({ type: 'text', text: textContent });
+          for (const url of imageUrls) {
+            parts.push({ type: 'image_url', image_url: { url } });
+          }
+          message = { role: msg.role, content: parts };
+        }
         if (msg.role === 'assistant' && thinkingText) {
           message.reasoning_content = thinkingText;
         }
@@ -188,6 +255,9 @@ function convertAnthropicMessagesToOpenRouter(anthropicMessages) {
     if (m.role === 'tool') continue;
     const hasToolCalls = Array.isArray(m.tool_calls) && m.tool_calls.length > 0;
     if (hasToolCalls) continue;
+    // Array content (text + image_url parts) must be preserved verbatim —
+    // only string content gets the empty-string guard.
+    if (Array.isArray(m.content)) continue;
     if (typeof m.content !== 'string' || m.content.trim() === '') {
       m.content = ' ';
     }