lynkr 9.14.11 → 9.14.13

package/src/clients/databricks.js

@@ -10,6 +10,30 @@ const { createBulkhead } = require("./resilience");
 const logger = require("../logger");
 const { STANDARD_TOOLS, STANDARD_TOOL_NAMES } = require("./standard-tools");
 const { convertAnthropicToolsToOpenRouter } = require("./openrouter-utils");
+
+/**
+ * Capability-boundary guard (issue #114): a caller that sets
+ * tool_choice "none" grants no tools. Substituting STANDARD_TOOLS widens
+ * the grant to shell execution with zero caller-visible signal, so every
+ * injection site below must consult this first. Matches the convention
+ * already used by the OpenRouter ingress path.
+ */
+function toolsDeclined(body) {
+  const tc = body?.tool_choice;
+  if (typeof tc === 'string') return tc.toLowerCase() === 'none';
+  if (tc && typeof tc === 'object') return tc.type === 'none';
+  return false;
+}
+
+/**
+ * Carry the caller's tool_choice through where the target expresses it.
+ * Only "none" is forwarded verbatim (the safety-critical value — the model
+ * must not be offered tools the caller forbade); everything else keeps the
+ * historical "auto" default so exotic shapes never 400 strict providers.
+ */
+function forwardToolChoice(body) {
+  return toolsDeclined(body) ? 'none' : 'auto';
+}
 const {
   detectModelFamily
 } = require("./bedrock-utils");
@@ -190,8 +214,9 @@ async function invokeDatabricks(body, _incomingHeaders = {}) {
   // Create a copy of body to avoid mutating the original
   const databricksBody = { ...body };
 
-  // Inject standard tools if client didn't send any (passthrough mode)
-  if (!Array.isArray(databricksBody.tools) || databricksBody.tools.length === 0) {
+  // Inject standard tools if client didn't send any (passthrough mode).
+  // Never when the caller declined tools (issue #114).
+  if (!toolsDeclined(body) && (!Array.isArray(databricksBody.tools) || databricksBody.tools.length === 0)) {
     databricksBody.tools = STANDARD_TOOLS;
     logger.debug({
       injectedToolCount: STANDARD_TOOLS.length,
@@ -535,7 +560,7 @@ async function invokeOllama(body, _incomingHeaders = {}) {
 
   if (!supportsTools) {
     toolsToSend = null;
-  } else if (injectToolsOllama && (!Array.isArray(toolsToSend) || toolsToSend.length === 0)) {
+  } else if (!toolsDeclined(body) && injectToolsOllama && (!Array.isArray(toolsToSend) || toolsToSend.length === 0)) {
     toolsToSend = STANDARD_TOOLS;
     toolsInjected = true;
   }
@@ -827,7 +852,7 @@ async function invokeOpenRouter(body, _incomingHeaders = {}) {
   let toolsToSend = body.tools;
   let toolsInjected = false;
 
-  if (!Array.isArray(toolsToSend) || toolsToSend.length === 0) {
+  if (!toolsDeclined(body) && (!Array.isArray(toolsToSend) || toolsToSend.length === 0)) {
     toolsToSend = STANDARD_TOOLS;
     toolsInjected = true;
     logger.debug({
@@ -844,6 +869,10 @@ async function invokeOpenRouter(body, _incomingHeaders = {}) {
       toolNames: toolsToSend.map(t => t.name || t.function?.name),
       toolsInjected
     }, "Sending tools to OpenRouter");
+  } else if (toolsDeclined(body)) {
+    // Explicit none with nothing to offer: state it so the upstream never
+    // defaults into tool use (issue #114).
+    openRouterBody.tool_choice = "none";
   }
 
   // Same pre-return 429 check as invokeMoonshot/invokeBaidu — see the comment
@@ -904,7 +933,7 @@ async function invokeEdenAI(body, _incomingHeaders = {}) {
   let toolsToSend = body.tools;
   let toolsInjected = false;
 
-  if (!Array.isArray(toolsToSend) || toolsToSend.length === 0) {
+  if (!toolsDeclined(body) && (!Array.isArray(toolsToSend) || toolsToSend.length === 0)) {
     toolsToSend = STANDARD_TOOLS;
     toolsInjected = true;
     logger.debug({
@@ -921,6 +950,10 @@ async function invokeEdenAI(body, _incomingHeaders = {}) {
       toolNames: toolsToSend.map(t => t.name || t.function?.name),
       toolsInjected
     }, "Sending tools to Eden AI");
+  } else if (toolsDeclined(body)) {
+    // Explicit none with nothing to offer: state it so the upstream never
+    // defaults into tool use (issue #114).
+    edenAIBody.tool_choice = "none";
   }
 
   return performJsonRequest(endpoint, { headers, body: edenAIBody }, "EdenAI");
@@ -1009,7 +1042,7 @@ async function invokeAzureOpenAI(body, _incomingHeaders = {}) {
   let toolsToSend = body.tools;
   let toolsInjected = false;
 
-  if (!Array.isArray(toolsToSend) || toolsToSend.length === 0) {
+  if (!toolsDeclined(body) && (!Array.isArray(toolsToSend) || toolsToSend.length === 0)) {
     toolsToSend = STANDARD_TOOLS;
     toolsInjected = true;
     logger.debug({
@@ -1022,7 +1055,7 @@ async function invokeAzureOpenAI(body, _incomingHeaders = {}) {
   if (Array.isArray(toolsToSend) && toolsToSend.length > 0) {
     azureBody.tools = convertAnthropicToolsToOpenRouter(toolsToSend);
     azureBody.parallel_tool_calls = true;
-    azureBody.tool_choice = "auto";  // Explicitly enable tool use (helps GPT models understand they should use tools)
+    azureBody.tool_choice = forwardToolChoice(body);  // Explicitly enable tool use (helps GPT models understand they should use tools)
     logger.debug({
       toolCount: toolsToSend.length,
       toolNames: toolsToSend.map(t => t.name || t.function?.name),
@@ -1457,7 +1490,7 @@ async function invokeOpenAI(body, _incomingHeaders = {}) {
   let toolsToSend = body.tools;
   let toolsInjected = false;
 
-  if (!Array.isArray(toolsToSend) || toolsToSend.length === 0) {
+  if (!toolsDeclined(body) && (!Array.isArray(toolsToSend) || toolsToSend.length === 0)) {
     toolsToSend = STANDARD_TOOLS;
     toolsInjected = true;
     logger.debug({
@@ -1470,7 +1503,7 @@ async function invokeOpenAI(body, _incomingHeaders = {}) {
   if (Array.isArray(toolsToSend) && toolsToSend.length > 0) {
     openAIBody.tools = convertAnthropicToolsToOpenRouter(toolsToSend);
     openAIBody.parallel_tool_calls = false;  // Disable parallel tool calls - GPT often makes duplicate calls
-    openAIBody.tool_choice = "auto";  // Let the model decide when to use tools
+    openAIBody.tool_choice = forwardToolChoice(body);  // Let the model decide when to use tools
     logger.debug({
       toolCount: toolsToSend.length,
       toolNames: toolsToSend.map(t => t.name || t.function?.name),
@@ -1538,7 +1571,7 @@ async function invokeAtlas(body) {
 
   let toolsToSend = body.tools;
   let toolsInjected = false;
-  if (!Array.isArray(toolsToSend) || toolsToSend.length === 0) {
+  if (!toolsDeclined(body) && (!Array.isArray(toolsToSend) || toolsToSend.length === 0)) {
     toolsToSend = STANDARD_TOOLS;
     toolsInjected = true;
   }
@@ -1546,7 +1579,7 @@ async function invokeAtlas(body) {
   if (toolsToSend.length > 0) {
     atlasBody.tools = convertAnthropicToolsToOpenRouter(toolsToSend);
     atlasBody.parallel_tool_calls = false;
-    atlasBody.tool_choice = "auto";
+    atlasBody.tool_choice = forwardToolChoice(body);
   }
 
   logger.debug({
@@ -1681,7 +1714,7 @@ async function invokeLlamaCpp(body, _incomingHeaders = {}) {
   let toolsInjected = false;
 
   const injectToolsLlamacpp = process.env.INJECT_TOOLS_LLAMACPP !== "false";
-  if (injectToolsLlamacpp && (!Array.isArray(toolsToSend) || toolsToSend.length === 0)) {
+  if (!toolsDeclined(body) && injectToolsLlamacpp && (!Array.isArray(toolsToSend) || toolsToSend.length === 0)) {
     toolsToSend = STANDARD_TOOLS;
     toolsInjected = true;
     logger.debug({
@@ -1695,7 +1728,7 @@ async function invokeLlamaCpp(body, _incomingHeaders = {}) {
 
   if (Array.isArray(toolsToSend) && toolsToSend.length > 0) {
     llamacppBody.tools = convertAnthropicToolsToOpenRouter(toolsToSend);
-    llamacppBody.tool_choice = "auto";
+    llamacppBody.tool_choice = forwardToolChoice(body);
     logger.debug({
       toolCount: toolsToSend.length,
       toolNames: toolsToSend.map(t => t.name || t.function?.name),
@@ -1779,7 +1812,7 @@ async function invokeLMStudio(body, _incomingHeaders = {}) {
   let toolsToSend = body.tools;
   let toolsInjected = false;
 
-  if (!Array.isArray(toolsToSend) || toolsToSend.length === 0) {
+  if (!toolsDeclined(body) && (!Array.isArray(toolsToSend) || toolsToSend.length === 0)) {
     toolsToSend = STANDARD_TOOLS;
     toolsInjected = true;
     logger.debug({
@@ -1791,7 +1824,7 @@ async function invokeLMStudio(body, _incomingHeaders = {}) {
 
   if (Array.isArray(toolsToSend) && toolsToSend.length > 0) {
     lmstudioBody.tools = convertAnthropicToolsToOpenRouter(toolsToSend);
-    lmstudioBody.tool_choice = "auto";
+    lmstudioBody.tool_choice = forwardToolChoice(body);
     logger.debug({
       toolCount: toolsToSend.length,
       toolNames: toolsToSend.map(t => t.name || t.function?.name),
@@ -1938,7 +1971,7 @@ async function invokeBedrock(body, _incomingHeaders = {}) {
   // Inject standard tools if needed
   let toolsToSend = body.tools;
 
-  if (!Array.isArray(toolsToSend) || toolsToSend.length === 0) {
+  if (!toolsDeclined(body) && (!Array.isArray(toolsToSend) || toolsToSend.length === 0)) {
     toolsToSend = STANDARD_TOOLS;
     logger.debug({
       injectedToolCount: STANDARD_TOOLS.length,
@@ -2199,7 +2232,7 @@ async function invokeZai(body, _incomingHeaders = {}) {
       zaiBody.tools = tools;
       // Use "auto" to let the model decide when to use tools
       // "required" was forcing tools even for simple greetings
-      zaiBody.tool_choice = "auto";
+      zaiBody.tool_choice = forwardToolChoice(body);
       zaiBody.parallel_tool_calls = false;  // Disabled: duplicate-call risk
     }
 
@@ -2230,8 +2263,9 @@ async function invokeZai(body, _incomingHeaders = {}) {
     // that's a different bug — add zai to DEFAULT_OPENAI_SSE_PROVIDERS then,
     // don't reintroduce this override.
 
-    // Inject standard tools if client didn't send any (passthrough mode)
-    if (!Array.isArray(zaiBody.tools) || zaiBody.tools.length === 0) {
+    // Inject standard tools if client didn't send any (passthrough mode).
+    // Never when the caller declined tools (issue #114).
+    if (!toolsDeclined(body) && (!Array.isArray(zaiBody.tools) || zaiBody.tools.length === 0)) {
       zaiBody.tools = STANDARD_TOOLS;
       logger.debug({
         injectedToolCount: STANDARD_TOOLS.length,
@@ -2404,7 +2438,7 @@ async function invokeMoonshot(body, _incomingHeaders = {}) {
 
   if (Array.isArray(body.tools) && body.tools.length > 0) {
     moonshotBody.tools = convertAnthropicToolsToOpenRouter(body.tools);
-    moonshotBody.tool_choice = "auto";
+    moonshotBody.tool_choice = forwardToolChoice(body);
     moonshotBody.parallel_tool_calls = false;
   }
 
@@ -2558,7 +2592,7 @@ async function invokeBaidu(body, _incomingHeaders = {}) {
 
   if (Array.isArray(body.tools) && body.tools.length > 0) {
     baiduBody.tools = convertAnthropicToolsToOpenRouter(body.tools);
-    baiduBody.tool_choice = "auto";
+    baiduBody.tool_choice = forwardToolChoice(body);
     baiduBody.parallel_tool_calls = false;
   }
 
@@ -2696,7 +2730,7 @@ async function invokeFireworks(body, _incomingHeaders = {}) {
 
   if (Array.isArray(body.tools) && body.tools.length > 0) {
     fireworksBody.tools = convertAnthropicToolsToOpenRouter(body.tools);
-    fireworksBody.tool_choice = "auto";
+    fireworksBody.tool_choice = forwardToolChoice(body);
     fireworksBody.parallel_tool_calls = false;
   }
 
@@ -2893,6 +2927,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 = forwardToolChoice(body);
+    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
  *
@@ -3370,6 +3535,7 @@ const PROVIDER_INVOKERS = {
   codex: invokeCodex,
   baidu: invokeBaidu,
   fireworks: invokeFireworks,
+  orcarouter: invokeOrcaRouter,
 };
 
 function invokeProvider(provider, body, incomingHeaders) {
@@ -3635,6 +3801,7 @@ async function invokeModel(body, options = {}) {
       candidates: routingResult.candidates ?? null,
       pinned: routingResult.pinned ? 1 : 0,
       switch_reason: routingResult.switch_reason ?? null,
+      ...telemetry.jevFields(routingResult),
       cache_decision: routingResult._cacheDecision ?? null,
       cache_read_tokens: result.json?.usage?.cache_read_input_tokens ?? null,
       cache_creation_tokens: result.json?.usage?.cache_creation_input_tokens ?? null,
@@ -3870,6 +4037,7 @@ async function invokeModel(body, options = {}) {
         candidates: routingResult.candidates ?? null,
         pinned: routingResult.pinned ? 1 : 0,
         switch_reason: routingResult.switch_reason ?? null,
+      ...telemetry.jevFields(routingResult),
       cache_decision: routingResult._cacheDecision ?? null,
       });
 
@@ -3983,6 +4151,7 @@ async function invokeModel(body, options = {}) {
           candidates: routingResult.candidates ?? null,
           pinned: routingResult.pinned ? 1 : 0,
           switch_reason: routingResult.switch_reason ?? null,
+      ...telemetry.jevFields(routingResult),
           cache_decision: routingResult._cacheDecision ?? null,
         });
 
@@ -4080,6 +4249,7 @@ async function invokeModel(body, options = {}) {
         candidates: routingResult.candidates ?? null,
         pinned: routingResult.pinned ? 1 : 0,
         switch_reason: routingResult.switch_reason ?? null,
+      ...telemetry.jevFields(routingResult),
       cache_decision: routingResult._cacheDecision ?? null,
       cache_read_tokens: fallbackResult.json?.usage?.cache_read_input_tokens ?? null,
       cache_creation_tokens: fallbackResult.json?.usage?.cache_creation_input_tokens ?? null,
@@ -4141,6 +4311,7 @@ async function invokeModel(body, options = {}) {
         candidates: routingResult.candidates ?? null,
         pinned: routingResult.pinned ? 1 : 0,
         switch_reason: routingResult.switch_reason ?? null,
+      ...telemetry.jevFields(routingResult),
       cache_decision: routingResult._cacheDecision ?? null,
       });
 
@@ -4232,6 +4403,8 @@ function destroyHttpAgents() {
 
 module.exports = {
   invokeModel,
+  toolsDeclined,
+  forwardToolChoice,
   computeCostUsd,
   convertOpenAIToAnthropic,
   invokeAzureAnthropic,
@@ -4241,6 +4414,7 @@ module.exports = {
   invokeBaidu,
   invokeFireworks,
   invokeAtlas,
+  invokeOrcaRouter,
   PROVIDER_INVOKERS,
   stripLynkrBadges,
   destroyHttpAgents,

package/src/clients/openai-format.js

@@ -69,12 +69,47 @@ function convertOpenAIToAnthropic(openaiRequest) {
           } else if (part.type === "image_url") {
             const url = part.image_url?.url || "";
             if (url.startsWith("data:")) {
-              const match = url.match(/^data:(image\/[^;]+);base64,(.+)$/);
+              // Accept base64 and base64url alphabets; anything else falls
+              // through to url-shape (provider validates downstream).
+              const match = url.match(/^data:([^;]+);base64,([A-Za-z0-9+/=_-]+)$/);
               if (match) {
-                return { type: "image", source: { type: "base64", media_type: match[1], data: match[2] } };
+                // Image payloads become Anthropic image blocks; anything
+                // else (e.g. application/pdf) becomes a document block so
+                // the bytes survive the translation (issue #115).
+                if (match[1].startsWith("image/")) {
+                  return { type: "image", source: { type: "base64", media_type: match[1], data: match[2] } };
+                }
+                return { type: "document", source: { type: "base64", media_type: match[1], data: match[2] } };
               }
             }
             return { type: "image", source: { type: "url", url } };
+          } else if (part.type === "file" && part.file) {
+            // OpenAI file part → Anthropic document block. file_data carries
+            // a data URL whose media type + base64 payload map directly
+            // (issue #115: previously forwarded unchanged → upstream 400).
+            const dataUrl = part.file.file_data || "";
+            const match = typeof dataUrl === "string" && dataUrl.match(/^data:([^;]+);base64,([A-Za-z0-9+/=_-]+)$/);
+            if (match) {
+              return { type: "document", source: { type: "base64", media_type: match[1], data: match[2] } };
+            }
+            const err = new Error(
+              `Cannot translate OpenAI file part "${part.file.filename || "unnamed"}" to Anthropic format: ` +
+              `file_data must be a base64 data: URL.`
+            );
+            err.statusCode = 400;
+            err.code = "unsupported_content_block";
+            err.isOperational = true;
+            throw err;
+          } else if (part.type === "input_audio") {
+            // No Anthropic equivalent — fail loudly naming the block rather
+            // than forwarding bytes the upstream rejects opaquely (issue #115).
+            const err = new Error(
+              "Cannot translate OpenAI input_audio content to Anthropic format: audio input is not supported."
+            );
+            err.statusCode = 400;
+            err.code = "unsupported_content_block";
+            err.isOperational = true;
+            throw err;
           } else if (part.type === "document" || part.type === "image") {
             return part;
           }

package/src/clients/openrouter-utils.js

@@ -208,6 +208,26 @@ function convertAnthropicMessagesToOpenRouter(anthropicMessages) {
         }
         let message;
         if (imageUrls.length === 0) {
+          // Fail loudly instead of emptying: an attachment-only message
+          // whose blocks have no OpenAI representation (document, file,
+          // video, audio) must error naming the block, not become "" and
+          // earn a confident 2xx answer about an attachment never received
+          // (issue #115). Thinking-only turns are exempt — thinking models
+          // legitimately send those.
+          const unconvertible = content
+            .filter((b) => b && typeof b === 'object'
+              && ['document', 'file', 'video', 'audio', 'input_audio'].includes(b.type))
+            .map((b) => b.type);
+          if (unconvertible.length > 0 && !textContent) {
+            const err = new Error(
+              `Cannot convert ${[...new Set(unconvertible)].join('/')} content block(s) to OpenAI format: ` +
+              `no equivalent representation exists.`
+            );
+            err.statusCode = 400;
+            err.code = 'unsupported_content_block';
+            err.isOperational = true;
+            throw err;
+          }
           message = { role: msg.role, content: textContent || '' };
         } else {
           const parts = [];