@jacobbd/relay-ai 0.12.3 → 0.12.5

package/dist/{chunk-R427D6VA.js → chunk-S7HYE2FI.js}

@@ -78,6 +78,7 @@ import {
   silenceSdkWarnings,
   slugifyProviderId,
   splitToolUseId,
+  sseChunk,
   streamAnthropicResponse,
   stripOneMContextSuffix,
   supportsNativeOAuth,
@@ -85,7 +86,7 @@ import {
   translateRequest,
   upstreamHttpStatus,
   validateCustomEndpointUrl
-} from "./chunk-C7TTIGMR.js";
+} from "./chunk-2LUDFIZX.js";
 
 // src/registry/google-model-id.ts
 var GOOGLE_MODEL_PREFIX = "models/";
@@ -1901,7 +1902,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 +1960,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 +1982,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 +2043,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 +2973,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 +3709,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 +3744,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,
@@ -3919,7 +4030,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 +4075,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 +8430,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 +9800,4 @@ export {
   supportsClaudeTransparentMode,
   buildHttpProxyRoutes
 };
-//# sourceMappingURL=chunk-R427D6VA.js.map
+//# sourceMappingURL=chunk-S7HYE2FI.js.map