@jacobbd/relay-ai 0.12.4 → 0.12.6

package/README.md

@@ -564,6 +564,19 @@ For agent / alef-agent integration (boot flags, NDJSON): **[docs/AI-AGENTS.md](d
 
 When OpenCode Zen is in your registry, `subscriptionFilter` controls which Zen models appear (`free` = free tier only; default = all Zen models). Add or change Zen via `relay-ai providers`.
 
+Zen, Go, OpenRouter, and Command Code gateways can expose both Chat
+Completions and Anthropic Messages. Relay uses current model metadata first, so
+newly named models are not forced into a provider-wide format. For requests
+Relay translates (OpenAI-format models, and any model used from Codex, Gemini,
+or Antigravity), an early protocol or gateway error makes Relay retry the same
+provider/account/model once on the sibling endpoint before streaming any
+output. Successful choices are remembered for 24 hours; two failed attempts
+pause protocol retries for five minutes. Authentication, quota, context,
+moderation, and cancellation errors do not trigger a retry. Anthropic-format
+models in Claude Code, and the server's direct routes, are forwarded untouched
+so prompt caching, beta headers, and thinking keep working; they do not retry
+on the sibling endpoint.
+
 ### Environment isolation
 
 When you launch, relay-ai builds a clean child environment:
@@ -584,7 +597,7 @@ OpenCode exposes models through different API formats. relay-ai handles them whe
 
 | Model format | Examples | How it works | Label |
 |---|---|---|---|
-| Anthropic native | Claude, Qwen, MiniMax (Go) | Direct connection | *(none)* |
+| Anthropic native | Claude, Union Alpha, Qwen, MiniMax (Go) | Direct connection | *(none)* |
 | OpenAI chat completions | DeepSeek, Kimi, MiMo, GLM, Grok, GPT-4o (OpenCode OpenAI provider) | SDK adapter proxy (Vercel AI SDK) | `via proxy` |
 | OpenAI Responses API | GPT-5.4+, GPT-5.5, Codex, o-series (OpenCode OpenAI provider only) | Same proxy; SDK picks Responses API | `via proxy` |
 | Gemini native | Gemini (OpenCode Google provider) | SDK adapter, Gemini native API | `via proxy` |

package/dist/{chunk-LPOAO33X.js → chunk-5MEDBKPX.js}

@@ -47,6 +47,7 @@ import {
   injectClaudeCodeBillingSystemLine,
   injectClaudeIdentity,
   isBrowserRedirectOAuth,
+  isOpencodeApi,
   isOpencodeOAuth,
   isSdkMigratedNpm,
   isValidProviderId,
@@ -78,6 +79,7 @@ import {
   silenceSdkWarnings,
   slugifyProviderId,
   splitToolUseId,
+  sseChunk,
   streamAnthropicResponse,
   stripOneMContextSuffix,
   supportsNativeOAuth,
@@ -85,7 +87,7 @@ import {
   translateRequest,
   upstreamHttpStatus,
   validateCustomEndpointUrl
-} from "./chunk-5INR7PKO.js";
+} from "./chunk-VPDX24ZR.js";
 
 // src/registry/google-model-id.ts
 var GOOGLE_MODEL_PREFIX = "models/";
@@ -1901,7 +1903,7 @@ function estimateAnthropicInputTokens(body) {
 }
 
 // src/upstream-forward.ts
-import { Readable } from "stream";
+import { once } from "events";
 
 // src/server/auth.ts
 function sanitizeCredential(value) {
@@ -1959,7 +1961,7 @@ async function fetchWithOAuthRetry(apiKey, request, refreshToken) {
   response = await request(refreshed);
   return { response, apiKey: refreshed, refreshed: true };
 }
-async function relayAnthropicMessages(res, messagesUrl, body, apiKey, clientWantsStream, inboundBeta, authType, log7, claudeCodeSessionId, extraHeaders, refreshToken, onTokenRefreshed) {
+async function relayAnthropicMessages(res, messagesUrl, body, apiKey, clientWantsStream, inboundBeta, authType, log7, claudeCodeSessionId, extraHeaders, refreshToken, onTokenRefreshed, retryEmptyStream = false) {
   const doFetch = (key) => fetch(messagesUrl, {
     method: "POST",
     headers: anthropicUpstreamHeaders(key, clientWantsStream, inboundBeta, authType, claudeCodeSessionId, extraHeaders),
@@ -1981,12 +1983,46 @@ async function relayAnthropicMessages(res, messagesUrl, body, apiKey, clientWant
     return;
   }
   if (clientWantsStream && upstreamRes.body) {
+    const reader = upstreamRes.body.getReader();
+    const first = await reader.read().catch(() => ({ done: true, value: void 0 }));
+    if (first.done) {
+      reader.releaseLock();
+      if (retryEmptyStream) {
+        log7?.("anthropic upstream returned an empty stream; retrying without streaming");
+        await replayWithoutStreaming(
+          res,
+          messagesUrl,
+          body,
+          apiKey,
+          inboundBeta,
+          authType,
+          claudeCodeSessionId,
+          extraHeaders,
+          log7
+        );
+        return;
+      }
+    }
     res.writeHead(200, {
       "Content-Type": "text/event-stream",
       "Cache-Control": "no-cache",
       "Connection": "keep-alive"
     });
-    Readable.fromWeb(upstreamRes.body).on("error", () => res.destroy()).pipe(res);
+    if (first.done) {
+      res.end();
+      return;
+    }
+    res.write(Buffer.from(first.value));
+    try {
+      while (true) {
+        const next = await reader.read();
+        if (next.done) break;
+        if (!res.write(Buffer.from(next.value))) await once(res, "drain");
+      }
+      res.end();
+    } catch {
+      res.destroy();
+    }
     return;
   }
   if (!upstreamRes.body) {
@@ -2008,6 +2044,85 @@ async function relayAnthropicMessages(res, messagesUrl, body, apiKey, clientWant
   });
   res.end(text4);
 }
+async function replayWithoutStreaming(res, messagesUrl, body, apiKey, inboundBeta, authType, claudeCodeSessionId, extraHeaders, log7) {
+  let retryRes;
+  try {
+    retryRes = await fetch(messagesUrl, {
+      method: "POST",
+      headers: anthropicUpstreamHeaders(apiKey, false, inboundBeta, authType, claudeCodeSessionId, extraHeaders),
+      body: JSON.stringify({ ...body, stream: false })
+    });
+  } catch (err) {
+    throw new UpstreamUnreachableError(err);
+  }
+  const text4 = await retryRes.text();
+  if (!retryRes.ok) {
+    log7?.(`anthropic upstream ${retryRes.status} on empty-stream retry: ${text4}`);
+    res.writeHead(retryRes.status, { "Content-Type": retryRes.headers.get("content-type") || "application/json" });
+    res.end(text4);
+    return;
+  }
+  let message;
+  try {
+    message = JSON.parse(text4);
+  } catch {
+    res.writeHead(502, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ type: "error", error: { type: "api_error", message: "Upstream response was not valid JSON" } }));
+    return;
+  }
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    "Connection": "keep-alive"
+  });
+  writeMessageAsSse(res, message);
+}
+function writeMessageAsSse(res, message) {
+  const content = Array.isArray(message.content) ? message.content : [];
+  res.write(sseChunk("message_start", {
+    type: "message_start",
+    message: { ...message, content: [], stop_reason: null, stop_sequence: null }
+  }));
+  content.forEach((block, index) => {
+    const type = block.type;
+    const opening = type === "text" ? { type: "text", text: "" } : type === "thinking" ? { type: "thinking", thinking: "", signature: "" } : type === "tool_use" ? { type: "tool_use", id: block.id, name: block.name, input: {} } : block;
+    res.write(sseChunk("content_block_start", { type: "content_block_start", index, content_block: opening }));
+    if (type === "text") {
+      res.write(sseChunk("content_block_delta", {
+        type: "content_block_delta",
+        index,
+        delta: { type: "text_delta", text: block.text ?? "" }
+      }));
+    } else if (type === "thinking") {
+      res.write(sseChunk("content_block_delta", {
+        type: "content_block_delta",
+        index,
+        delta: { type: "thinking_delta", thinking: block.thinking ?? "" }
+      }));
+      if (typeof block.signature === "string") {
+        res.write(sseChunk("content_block_delta", {
+          type: "content_block_delta",
+          index,
+          delta: { type: "signature_delta", signature: block.signature }
+        }));
+      }
+    } else if (type === "tool_use") {
+      res.write(sseChunk("content_block_delta", {
+        type: "content_block_delta",
+        index,
+        delta: { type: "input_json_delta", partial_json: JSON.stringify(block.input ?? {}) }
+      }));
+    }
+    res.write(sseChunk("content_block_stop", { type: "content_block_stop", index }));
+  });
+  res.write(sseChunk("message_delta", {
+    type: "message_delta",
+    delta: { stop_reason: message.stop_reason ?? "end_turn", stop_sequence: message.stop_sequence ?? null },
+    usage: message.usage ?? {}
+  }));
+  res.write(sseChunk("message_stop", { type: "message_stop" }));
+  res.end();
+}
 
 // src/antigravity/anthropic-to-cloudcode.ts
 import { randomUUID } from "crypto";
@@ -2859,7 +2974,8 @@ function startProxyCatalog(routes, defaultAliasId, debug = false) {
             route.refreshToken,
             (refreshed) => {
               route.apiKey = refreshed;
-            }
+            },
+            true
           );
         } catch (err) {
           const message = err instanceof UpstreamUnreachableError ? err.message : String(err);
@@ -3594,8 +3710,7 @@ function readModelsFromModelsDev(backendId, cache = loadModelsDevCache()) {
     const id = entry.id ?? modelKey;
     if (entry.status === "deprecated") continue;
     const isFree = entry.cost !== void 0 && entry.cost.input === 0 && entry.cost.output === 0;
-    const rawFormat = classifyModelFormat(id, entry.provider?.npm);
-    const modelFormat = backendId === "go" && rawFormat === "anthropic" ? "openai" : rawFormat;
+    const modelFormat = classifyModelFormat(id, entry.provider?.npm);
     result.set(id, {
       id,
       name: entry.name ?? id,
@@ -3630,10 +3745,7 @@ function mergeModels(apiIds, cache, backendId) {
   const uniqueIds = Array.from(new Set(apiIds));
   return uniqueIds.filter((id) => !shouldHideModel({ providerId: backendId, modelId: id, agent: "claude" })).map((id) => {
     const cached = cache?.get(id);
-    if (cached) {
-      const modelFormat2 = backendId === "go" && cached.modelFormat === "anthropic" ? "openai" : cached.modelFormat;
-      return { ...cached, sourceBackend: backendId, modelFormat: modelFormat2 };
-    }
+    if (cached) return { ...cached, sourceBackend: backendId };
     const modelFormat = classifyModelFormat(id, void 0);
     return {
       id,
@@ -3799,7 +3911,12 @@ function buildImportProviderList(raw, authEntries) {
   const oauthByProviderId = /* @__PURE__ */ new Map();
   const covered = /* @__PURE__ */ new Set();
   const merged = [];
-  for (const provider of normalizeProviders(raw)) {
+  const rawWithLegacyKeys = raw.map((provider) => {
+    const authEntry = authEntries[provider.id];
+    if (provider.key?.trim() || !isOpencodeApi(authEntry)) return provider;
+    return { ...provider, key: authEntry.key };
+  });
+  for (const provider of normalizeProviders(rawWithLegacyKeys)) {
     const normalized = normalizeImportProviderIdentity(provider);
     if (covered.has(normalized.id)) continue;
     merged.push(normalized);
@@ -3856,7 +3973,7 @@ function listCredentialSkippedProviders(raw, authEntries, importedIds, alreadyRe
     if (isOpencodeOAuth(authEntries[provider.id])) continue;
     if (!provider.models || Object.keys(provider.models).length === 0) continue;
     const reason = classifyOpencodeCredentialGap(provider.id);
-    if (reason !== "oauth-no-token" && !registryProviderIds.has(provider.id)) continue;
+    if (reason !== "oauth-no-token" && !provider.configured && !registryProviderIds.has(provider.id)) continue;
     skipped.push({ id: provider.id, name: provider.name, reason });
   }
   return skipped;
@@ -3919,7 +4036,30 @@ function buildCatalogRoutes(startingRoute, favorites, resolveRoute, max = MAX_MO
 
 // src/registry/materialize.ts
 init_provider_templates();
-function cachedModelToLocal(cached, provider) {
+
+// src/registry/model-protocol.ts
+function reconcileCachedModelProtocol(model, provider, metadata = loadModelsDevCache()) {
+  if (model.source === "manual") return model;
+  const isZenGo = provider.id === "zen" || provider.id === "go" || provider.templateId === "zen" || provider.templateId === "go";
+  if (!isZenGo) return model;
+  const metadataNpm = findModelsDevModel(provider.id, model.id, metadata)?.provider?.npm;
+  if (!metadataNpm) return model;
+  const format = classifyModelFormat(model.id, metadataNpm);
+  if (format === "unsupported") return model;
+  const backendId = provider.id === "go" || provider.templateId === "go" ? "go" : "zen";
+  const apiUrl = model.apiUrl ?? provider.api.url ?? BACKENDS[backendId].baseUrl;
+  return {
+    ...model,
+    modelFormat: format,
+    npm: metadataNpm,
+    apiUrl
+  };
+}
+
+// src/registry/materialize.ts
+function cachedModelToLocal(cached, provider, metadata = loadModelsDevCache()) {
+  const reconciled = reconcileCachedModelProtocol(cached, provider, metadata);
+  cached = reconciled;
   const freeStatus = classifyFreeStatus({
     model: cached,
     providerId: provider.id,
@@ -3941,20 +4081,24 @@ function cachedModelToLocal(cached, provider) {
       interleavedReasoningField: cached.interleavedReasoningField
     };
   }
+  const modelsDev = findModelsDevModel(provider.id, cached.id, metadata);
+  const isZenGo = provider.id === "zen" || provider.id === "go" || provider.templateId === "zen" || provider.templateId === "go";
+  const metadataNpm = !cached.source && isZenGo ? modelsDev?.provider?.npm : void 0;
   const npm = cached.npm ?? provider.api.npm ?? "";
-  const apiUrl = cached.apiUrl ?? provider.api.url ?? "";
+  const apiUrl = cached.apiUrl ?? provider.api.url ?? (isZenGo ? BACKENDS[provider.id === "go" || provider.templateId === "go" ? "go" : "zen"].baseUrl : "");
   const endpoint = resolveEndpoint(npm, apiUrl);
   if (endpoint === null) return null;
-  const modelsDev = findModelsDevModel(provider.id, cached.id);
   const { id, upstreamModelId: upstreamModelId2 } = normalizeGoogleModelId(cached.id, npm);
   const normalizedUpstream = normalizeGoogleModelId(cached.upstreamModelId ?? cached.id, npm).upstreamModelId;
   const family = npm === "@ai-sdk/google" ? id.split(/[-/:]/)[0] ?? id : cached.family ?? "";
+  const classifiedFormat = classifyModelFormat(cached.id, npm);
+  const resolvedFormat = classifiedFormat === "anthropic" ? classifiedFormat : "openai";
   return {
     id,
     name: npm === "@ai-sdk/google" ? normalizeGoogleDisplayName(cached.name, id) : cached.name,
     family,
     brand: npm === "@ai-sdk/google" ? deriveBrand(family) : cached.brand ?? deriveBrand(cached.family ?? ""),
-    modelFormat: cached.modelFormat ?? endpoint.format,
+    modelFormat: metadataNpm ? resolvedFormat : cached.modelFormat ?? endpoint.format,
     upstreamModelId: normalizedUpstream,
     baseUrl: endpoint.baseUrl,
     completionsUrl: endpoint.completionsUrl,
@@ -8292,6 +8436,7 @@ function httpProxyModelId(providerId, modelId) {
   return `${HTTP_PROXY_MODEL_PREFIX}${providerId}:${modelId}`;
 }
 function supportsClaudeTransparentMode(model) {
+  if (model.modelFormat === "anthropic") return Boolean(model.baseUrl);
   return model.modelFormat === "openai" && isSdkMigratedNpm(model.npm);
 }
 function buildHttpProxyRoutes(providers, favorites, selected, max = MAX_MODEL_CATALOG) {
@@ -9661,4 +9806,4 @@ export {
   supportsClaudeTransparentMode,
   buildHttpProxyRoutes
 };
-//# sourceMappingURL=chunk-LPOAO33X.js.map
+//# sourceMappingURL=chunk-5MEDBKPX.js.map