@fudrouter/fsrouter 0.6.59 → 0.6.61

package/open-sse/executors/yuanbao-web.js

@@ -1,385 +0,0 @@
-import {
-  BaseExecutor,
-  mergeAbortSignals,
-  mergeUpstreamExtraHeaders
-} from "./base.ts";
-import { FETCH_TIMEOUT_MS } from "../config/constants.ts";
-import { buildErrorBody, sanitizeErrorMessage } from "../utils/error.js";
-import { extractCookieValue, stripCookieInputPrefix } from '../../dist/lib/providers/webCookieAuth.js';
-const YUANBAO_BASE = "https://yuanbao.tencent.com";
-const CREATE_URL = `${YUANBAO_BASE}/api/user/agent/conversation/create`;
-const CHAT_URL = `${YUANBAO_BASE}/api/chat`;
-const DEFAULT_AGENT_ID = "naQivTmsDa";
-const USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36";
-const DEFAULT_MODEL = "deepseek-v3";
-const MODEL_MAP = {
-  "deepseek-v3": { chatModelId: "deep_seek_v3" },
-  "deepseek-r1": { chatModelId: "deep_seek" },
-  "deepseek-v3-search": {
-    chatModelId: "deep_seek_v3",
-    supportFunctions: ["supportInternetSearch"]
-  },
-  "deepseek-r1-search": {
-    chatModelId: "deep_seek",
-    supportFunctions: ["supportInternetSearch"]
-  },
-  hunyuan: { chatModelId: "hunyuan_gpt_175B_0404" },
-  "hunyuan-t1": { chatModelId: "hunyuan_t1" },
-  "hunyuan-search": {
-    chatModelId: "hunyuan_gpt_175B_0404",
-    supportFunctions: ["supportInternetSearch"]
-  },
-  "hunyuan-t1-search": {
-    chatModelId: "hunyuan_t1",
-    supportFunctions: ["supportInternetSearch"]
-  }
-};
-function isEncryptedCredentialBlob(value) {
-  return typeof value === "string" && value.trim().startsWith("enc:v1:");
-}
-function extractText(content) {
-  if (typeof content === "string") return content;
-  if (!Array.isArray(content)) return String(content ?? "");
-  return content.map((part) => {
-    if (!part || typeof part !== "object") return "";
-    const item = part;
-    if ((item.type === "text" || item.type === "input_text") && typeof item.text === "string") {
-      return item.text;
-    }
-    return "";
-  }).filter((p) => p.length > 0).join("\n");
-}
-function buildPrompt(messages) {
-  const parts = [];
-  for (const msg of messages) {
-    const role = String(msg.role || "user");
-    const text = extractText(msg.content).trim();
-    if (!text) continue;
-    parts.push({ role, content: text });
-  }
-  if (parts.length === 0) return "";
-  if (parts.length === 1) return parts[0].content;
-  return parts.map((p) => `#[${p.role.trim()}]
-${p.content}`).join("\n\n");
-}
-function buildYuanbaoCookie(rawApiKey) {
-  const raw = stripCookieInputPrefix(rawApiKey || "");
-  const hyUser = extractCookieValue(raw, "hy_user");
-  const hyToken = extractCookieValue(raw, "hy_token");
-  if (hyUser && hyToken) {
-    return { cookie: `hy_source=web; hy_user=${hyUser}; hy_token=${hyToken}`, hasToken: true };
-  }
-  const hasToken = raw.includes("hy_token=");
-  return { cookie: raw, hasToken };
-}
-function estimateTokens(text) {
-  return Math.max(1, Math.ceil((text || "").length / 4));
-}
-async function readUpstreamErrorDetails(response) {
-  const contentType = response.headers.get("content-type") || "";
-  const text = await response.text().catch(() => "");
-  if (!text) return { message: null, details: null };
-  if (contentType.includes("json")) {
-    try {
-      const parsed = JSON.parse(text);
-      const message = typeof parsed.message === "string" ? parsed.message : typeof parsed.error === "string" ? parsed.error : null;
-      return { message: message ? sanitizeErrorMessage(message) : null, details: parsed };
-    } catch {
-    }
-  }
-  return { message: sanitizeErrorMessage(text), details: { body: text } };
-}
-class YuanbaoWebExecutor extends BaseExecutor {
-  constructor() {
-    super("yuanbao-web", { id: "yuanbao-web", baseUrl: CHAT_URL });
-  }
-  errorResponse(status, message, url, details) {
-    return {
-      response: new Response(JSON.stringify(buildErrorBody(status, message, details)), {
-        status,
-        headers: { "Content-Type": "application/json" }
-      }),
-      url,
-      headers: {},
-      transformedBody: void 0
-    };
-  }
-  async execute(input) {
-    const { model, body, stream, credentials, signal, log, upstreamExtraHeaders } = input;
-    const messages = body.messages;
-    if (!messages || !Array.isArray(messages) || messages.length === 0) {
-      return this.errorResponse(400, "Missing or empty messages array", CHAT_URL);
-    }
-    if (isEncryptedCredentialBlob(credentials.apiKey)) {
-      return this.errorResponse(
-        401,
-        "Yuanbao credentials are encrypted but STORAGE_ENCRYPTION_KEY is not loaded. Restore the encryption key or re-save the Yuanbao cookie.",
-        CREATE_URL
-      );
-    }
-    const { cookie, hasToken } = buildYuanbaoCookie(credentials.apiKey || "");
-    if (!hasToken) {
-      return this.errorResponse(
-        401,
-        "Yuanbao requires a session cookie. Log in to yuanbao.tencent.com, open DevTools > Application > Cookies, and paste the full Cookie header (it must contain hy_user and hy_token).",
-        CREATE_URL
-      );
-    }
-    const resolvedModel = model && MODEL_MAP[model] ? model : DEFAULT_MODEL;
-    const modelSpec = MODEL_MAP[resolvedModel];
-    const prompt = buildPrompt(messages);
-    if (!prompt.trim()) {
-      return this.errorResponse(400, "Empty prompt after processing messages", CHAT_URL);
-    }
-    const baseHeaders = {
-      Cookie: cookie,
-      "User-Agent": USER_AGENT,
-      Origin: YUANBAO_BASE,
-      Referer: `${YUANBAO_BASE}/chat/${DEFAULT_AGENT_ID}`,
-      "X-Agentid": DEFAULT_AGENT_ID
-    };
-    const timeoutSignal = AbortSignal.timeout(FETCH_TIMEOUT_MS);
-    const combinedSignal = signal ? mergeAbortSignals(signal, timeoutSignal) : timeoutSignal;
-    let conversationId;
-    try {
-      const createRes = await fetch(CREATE_URL, {
-        method: "POST",
-        headers: { ...baseHeaders, "Content-Type": "application/json" },
-        body: JSON.stringify({ agentId: DEFAULT_AGENT_ID }),
-        signal: combinedSignal
-      });
-      if (!createRes.ok) {
-        const status = createRes.status;
-        const upstreamError = await readUpstreamErrorDetails(createRes);
-        let message = `Yuanbao conversation creation failed (HTTP ${status})`;
-        if (status === 401 || status === 403) {
-          message = "Yuanbao auth failed \u2014 your hy_user/hy_token cookies may be missing or expired. Log in to yuanbao.tencent.com and re-paste your Cookie header.";
-        } else if (status === 429) {
-          message = "Yuanbao rate limited. Wait a moment and retry.";
-        }
-        if (upstreamError.message) message = `${message}: ${upstreamError.message}`;
-        return this.errorResponse(status, message, CREATE_URL, upstreamError.details);
-      }
-      const createData = await createRes.json();
-      conversationId = String(createData.id || "");
-      if (!conversationId) {
-        return this.errorResponse(
-          502,
-          "Yuanbao did not return a conversation id",
-          CREATE_URL
-        );
-      }
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      log?.error?.("YUANBAO-WEB", `Conversation creation failed: ${message}`);
-      return this.errorResponse(
-        502,
-        `Yuanbao connection failed: ${sanitizeErrorMessage(message)}`,
-        CREATE_URL
-      );
-    }
-    const messageUrl = `${CHAT_URL}/${conversationId}`;
-    const chatBody = {
-      model: "gpt_175B_0404",
-      prompt,
-      plugin: "Adaptive",
-      displayPrompt: prompt,
-      displayPromptType: 1,
-      options: {
-        imageIntention: {
-          needIntentionModel: true,
-          backendUpdateFlag: 2,
-          intentionStatus: true
-        }
-      },
-      multimedia: [],
-      agentId: DEFAULT_AGENT_ID,
-      supportHint: 1,
-      version: "v2",
-      chatModelId: modelSpec.chatModelId
-    };
-    if (modelSpec.supportFunctions) chatBody.supportFunctions = modelSpec.supportFunctions;
-    const chatHeaders = {
-      ...baseHeaders,
-      "Content-Type": "application/json",
-      Accept: "text/event-stream"
-    };
-    mergeUpstreamExtraHeaders(chatHeaders, upstreamExtraHeaders);
-    let upstreamResponse;
-    try {
-      upstreamResponse = await fetch(messageUrl, {
-        method: "POST",
-        headers: chatHeaders,
-        body: JSON.stringify(chatBody),
-        signal: combinedSignal
-      });
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      log?.error?.("YUANBAO-WEB", `Message send failed: ${message}`);
-      return this.errorResponse(
-        502,
-        `Yuanbao connection failed: ${sanitizeErrorMessage(message)}`,
-        messageUrl
-      );
-    }
-    if (!upstreamResponse.ok) {
-      const status = upstreamResponse.status;
-      const upstreamError = await readUpstreamErrorDetails(upstreamResponse);
-      let message = `Yuanbao returned HTTP ${status}`;
-      if (status === 401 || status === 403) {
-        message = "Yuanbao auth failed \u2014 session cookie may be expired.";
-      } else if (status === 429) {
-        message = "Yuanbao rate limited. Wait a moment and retry.";
-      }
-      if (upstreamError.message) message = `${message}: ${upstreamError.message}`;
-      return this.errorResponse(status, message, messageUrl, upstreamError.details);
-    }
-    if (!upstreamResponse.body) {
-      return this.errorResponse(502, "Yuanbao returned empty response body", messageUrl);
-    }
-    const id = `chatcmpl-yuanbao-${crypto.randomUUID().slice(0, 12)}`;
-    const created = Math.floor(Date.now() / 1e3);
-    if (stream) {
-      return {
-        response: new Response(
-          transformYuanbaoStream(upstreamResponse.body, resolvedModel, id, created, signal, log),
-          {
-            status: 200,
-            headers: {
-              "Content-Type": "text/event-stream",
-              "Cache-Control": "no-cache",
-              "X-Accel-Buffering": "no"
-            }
-          }
-        ),
-        url: messageUrl,
-        headers: chatHeaders,
-        transformedBody: chatBody
-      };
-    }
-    const { content, reasoning } = await collectYuanbaoResponse(upstreamResponse.body, signal);
-    const completionTokens = estimateTokens(content + reasoning);
-    const messagePayload = { role: "assistant", content };
-    if (reasoning) messagePayload.reasoning_content = reasoning;
-    return {
-      response: new Response(
-        JSON.stringify({
-          id,
-          object: "chat.completion",
-          created,
-          model: resolvedModel,
-          choices: [{ index: 0, message: messagePayload, finish_reason: "stop" }],
-          usage: {
-            prompt_tokens: estimateTokens(prompt),
-            completion_tokens: completionTokens,
-            total_tokens: estimateTokens(prompt) + completionTokens
-          }
-        }),
-        { status: 200, headers: { "Content-Type": "application/json" } }
-      ),
-      url: messageUrl,
-      headers: chatHeaders,
-      transformedBody: chatBody
-    };
-  }
-}
-function parseYuanbaoDataLine(line) {
-  if (!line.startsWith("data: ")) return null;
-  const payload = line.slice(6).trim();
-  if (!payload || payload === "[DONE]" || !payload.startsWith("{")) return null;
-  try {
-    return JSON.parse(payload);
-  } catch {
-    return null;
-  }
-}
-function transformYuanbaoStream(upstream, model, id, created, signal, log) {
-  const encoder = new TextEncoder();
-  const decoder = new TextDecoder();
-  let roleEmitted = false;
-  return new ReadableStream({
-    async start(controller) {
-      const reader = upstream.getReader();
-      let buffer = "";
-      const emit = (delta, finish) => {
-        controller.enqueue(
-          encoder.encode(
-            `data: ${JSON.stringify({
-              id,
-              object: "chat.completion.chunk",
-              created,
-              model,
-              choices: [{ index: 0, delta, finish_reason: finish ?? null }]
-            })}
-
-`
-          )
-        );
-      };
-      const ensureRole = () => {
-        if (!roleEmitted) {
-          roleEmitted = true;
-          emit({ role: "assistant", content: "" });
-        }
-      };
-      try {
-        while (true) {
-          if (signal?.aborted) break;
-          const { done, value } = await reader.read();
-          if (done) break;
-          buffer += decoder.decode(value, { stream: true });
-          const lines = buffer.split("\n");
-          buffer = lines.pop() ?? "";
-          for (const line of lines) {
-            const event = parseYuanbaoDataLine(line);
-            if (!event) continue;
-            if (event.type === "think" && event.content) {
-              ensureRole();
-              emit({ reasoning_content: event.content });
-            } else if (event.type === "text" && typeof event.msg === "string" && event.msg) {
-              ensureRole();
-              emit({ content: event.msg });
-            }
-          }
-        }
-      } catch (err) {
-        log?.error?.("YUANBAO-WEB", `Stream error: ${err}`);
-      } finally {
-        ensureRole();
-        emit({}, "stop");
-        controller.enqueue(encoder.encode("data: [DONE]\n\n"));
-        controller.close();
-        reader.releaseLock();
-      }
-    }
-  });
-}
-async function collectYuanbaoResponse(upstream, signal) {
-  const decoder = new TextDecoder();
-  const reader = upstream.getReader();
-  let buffer = "";
-  let content = "";
-  let reasoning = "";
-  try {
-    while (true) {
-      if (signal?.aborted) break;
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() ?? "";
-      for (const line of lines) {
-        const event = parseYuanbaoDataLine(line);
-        if (!event) continue;
-        if (event.type === "think" && event.content) reasoning += event.content;
-        else if (event.type === "text" && typeof event.msg === "string") content += event.msg;
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  return { content, reasoning };
-}
-export {
-  YuanbaoWebExecutor
-};

package/open-sse/executors/zed-hosted.js

@@ -1,281 +0,0 @@
-import { BaseExecutor } from "./base.ts";
-import { PROVIDERS } from "../config/constants.ts";
-import { FORMATS } from "../translator/formats.ts";
-import { initState } from "../translator/index.ts";
-import { openaiToClaudeRequest } from "../translator/request/openai-to-claude.ts";
-import { openaiToGeminiRequest } from "../translator/request/openai-to-gemini.ts";
-import { openaiToOpenAIResponsesRequest } from "../translator/request/openai-responses/toResponses.ts";
-import { claudeToOpenAIResponse } from "../translator/response/claude-to-openai.ts";
-import { geminiToOpenAIResponse } from "../translator/response/gemini-to-openai.ts";
-import { openaiResponsesToOpenAIResponse } from "../translator/response/openai-responses.ts";
-import { ZED_HEADERS, resolveZedModels, zedLlmFetch } from "../shared/zedAuth.ts";
-const ZED_PROVIDER = {
-  anthropic: "Anthropic",
-  openai: "OpenAi",
-  google: "Google",
-  xai: "XAi"
-};
-function normalizeZedProvider(value, model) {
-  const raw = String(value || "").toLowerCase();
-  if (raw === "anthropic") return ZED_PROVIDER.anthropic;
-  if (raw === "openai" || raw === "open_ai") return ZED_PROVIDER.openai;
-  if (raw === "google" || raw === "gemini") return ZED_PROVIDER.google;
-  if (raw === "xai" || raw === "x_ai" || raw === "x-ai") return ZED_PROVIDER.xai;
-  const m = String(model || "").toLowerCase();
-  if (m.includes("claude")) return ZED_PROVIDER.anthropic;
-  if (m.includes("gemini")) return ZED_PROVIDER.google;
-  if (m.includes("grok") || m.includes("xai")) return ZED_PROVIDER.xai;
-  return ZED_PROVIDER.openai;
-}
-function buildProviderRequest(provider, model, body, stream, credentials) {
-  if (provider === ZED_PROVIDER.anthropic) {
-    return openaiToClaudeRequest(model, body, true);
-  }
-  if (provider === ZED_PROVIDER.google) {
-    return openaiToGeminiRequest(model, body, true, credentials);
-  }
-  if (provider === ZED_PROVIDER.openai) {
-    return openaiToOpenAIResponsesRequest(model, body, true, credentials);
-  }
-  return {
-    ...body,
-    model,
-    stream: stream !== false
-  };
-}
-function initProviderState(provider, model) {
-  if (provider === ZED_PROVIDER.anthropic) return initState(FORMATS.CLAUDE);
-  if (provider === ZED_PROVIDER.google) return initState(FORMATS.GEMINI);
-  if (provider === ZED_PROVIDER.openai) return initState(FORMATS.OPENAI_RESPONSES);
-  const state = initState(FORMATS.OPENAI);
-  state.model = model;
-  return state;
-}
-function convertProviderEvent(provider, event, state) {
-  if (provider === ZED_PROVIDER.anthropic) return claudeToOpenAIResponse(event, state);
-  if (provider === ZED_PROVIDER.google) return geminiToOpenAIResponse(event, state);
-  if (provider === ZED_PROVIDER.openai) return openaiResponsesToOpenAIResponse(event, state);
-  return event;
-}
-function createErrorChunk(model, message) {
-  return {
-    id: `chatcmpl-zed-error-${Date.now()}`,
-    object: "chat.completion.chunk",
-    created: Math.floor(Date.now() / 1e3),
-    model,
-    choices: [{ index: 0, delta: { content: `[Zed error] ${message}` }, finish_reason: "stop" }]
-  };
-}
-function enqueueSseObject(controller, encoder, chunk) {
-  if (!chunk) return;
-  const items = Array.isArray(chunk) ? chunk : [chunk];
-  for (const item of items) {
-    if (!item) continue;
-    controller.enqueue(encoder.encode(`data: ${JSON.stringify(item)}
-
-`));
-  }
-}
-function unwrapZedLine(line) {
-  let text = line.replace(/\r$/, "").trim();
-  if (!text) return null;
-  if (text.startsWith("data:")) text = text.slice(5).trimStart();
-  if (text === "[DONE]") return { done: true };
-  try {
-    const parsed = JSON.parse(text);
-    if (parsed && Object.prototype.hasOwnProperty.call(parsed, "event")) {
-      return { event: parsed.event };
-    }
-    if (parsed && Object.prototype.hasOwnProperty.call(parsed, "status")) {
-      return { status: parsed.status };
-    }
-    return { event: parsed };
-  } catch {
-    return null;
-  }
-}
-function normalizeStatus(status) {
-  if (!status) return null;
-  if (typeof status === "string") return { type: status };
-  if (typeof status === "object") {
-    const rec = status;
-    const key = Object.keys(rec)[0];
-    if (key && typeof rec[key] === "object") return { type: key, ...rec[key] };
-    return rec;
-  }
-  return null;
-}
-function wrapZedCompletionStream(response, provider, model) {
-  if (!response.ok || !response.body) return response;
-  const decoder = new TextDecoder();
-  const encoder = new TextEncoder();
-  const state = initProviderState(provider, model);
-  let buffer = "";
-  let done = false;
-  const finish = (controller) => {
-    if (done) return;
-    const finalChunk = convertProviderEvent(provider, null, state);
-    enqueueSseObject(controller, encoder, finalChunk);
-    controller.enqueue(encoder.encode("data: [DONE]\n\n"));
-    done = true;
-  };
-  const processLine = (line, controller) => {
-    if (done) return;
-    const payload = unwrapZedLine(line);
-    if (!payload) return;
-    if (payload.done) {
-      finish(controller);
-      return;
-    }
-    if (payload.status) {
-      const status = normalizeStatus(payload.status);
-      if (status?.type === "failed" || status?.failed) {
-        const failed = status.failed || status;
-        const message = String(failed.message || failed.error || failed.code || "request failed");
-        enqueueSseObject(controller, encoder, createErrorChunk(model, message));
-        finish(controller);
-      } else if (status?.type === "stream_ended" || status === "stream_ended") {
-        finish(controller);
-      }
-      return;
-    }
-    const converted = convertProviderEvent(provider, payload.event, state);
-    enqueueSseObject(controller, encoder, converted);
-  };
-  const transformed = response.body.pipeThrough(
-    new TransformStream({
-      transform(chunk, controller) {
-        buffer += decoder.decode(chunk, { stream: true });
-        let nl;
-        while ((nl = buffer.indexOf("\n")) !== -1) {
-          const line = buffer.slice(0, nl);
-          buffer = buffer.slice(nl + 1);
-          processLine(line, controller);
-        }
-      },
-      flush(controller) {
-        buffer += decoder.decode();
-        if (buffer) {
-          processLine(buffer, controller);
-          buffer = "";
-        }
-        finish(controller);
-      }
-    })
-  );
-  return new Response(transformed, {
-    status: response.status,
-    statusText: response.statusText,
-    headers: {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache"
-    }
-  });
-}
-class ZedHostedExecutor extends BaseExecutor {
-  constructor() {
-    super("zed-hosted", PROVIDERS["zed-hosted"] || {});
-  }
-  async resolveModel(model, credentials, signal, log) {
-    try {
-      const catalog = await resolveZedModels(credentials, { config: this.config, signal });
-      let raw = catalog?.rawById?.get(model) ?? null;
-      if (!raw) {
-        const refreshed = await resolveZedModels(credentials, {
-          config: this.config,
-          signal,
-          forceRefresh: true
-        });
-        raw = refreshed?.rawById?.get(model) ?? null;
-      }
-      return {
-        raw,
-        provider: normalizeZedProvider(raw?.provider, model)
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      log?.warn?.("ZED", `model catalog unavailable, inferring provider for ${model}: ${message}`);
-      return { raw: null, provider: normalizeZedProvider(null, model) };
-    }
-  }
-  async execute({ model, body, stream, credentials, signal, log }) {
-    const zedCredentials = credentials;
-    const { provider } = await this.resolveModel(model, zedCredentials, signal, log);
-    const providerRequest = buildProviderRequest(provider, model, body, stream, credentials);
-    const bodyRecord = body ?? {};
-    const payload = {
-      thread_id: bodyRecord.thread_id || credentials?._clientSessionId,
-      prompt_id: bodyRecord.prompt_id,
-      provider,
-      model,
-      provider_request: providerRequest
-    };
-    const response = await zedLlmFetch(zedCredentials, "/completions", {
-      config: this.config,
-      signal,
-      fetchOptions: {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Accept: "application/x-ndjson, text/event-stream, */*",
-          "User-Agent": `OmniRoute/zed-hosted`,
-          "x-zed-version": this.config?.appVersion?.toString() || "0.200.0",
-          [ZED_HEADERS.clientSupportsStatus]: "true",
-          [ZED_HEADERS.clientSupportsStreamEnded]: "true"
-        },
-        body: JSON.stringify(payload)
-      }
-    });
-    const wrapped = response.ok ? wrapZedCompletionStream(response, provider, model) : response;
-    return {
-      response: wrapped,
-      url: `${this.config?.llmBaseUrl || "https://cloud.zed.dev"}/completions`,
-      headers: { "Content-Type": "application/json", Authorization: "Bearer <zed-llm-token>" },
-      transformedBody: payload
-    };
-  }
-  parseError(response, bodyText) {
-    let parsed = null;
-    try {
-      parsed = JSON.parse(bodyText || "{}");
-    } catch {
-      parsed = null;
-    }
-    const errorObj = parsed?.error || void 0;
-    const code = parsed?.code || errorObj?.code || "";
-    const rawMessage = parsed?.message || errorObj?.message || bodyText || response.statusText;
-    if (code === "trial_blocked") {
-      return {
-        status: response.status,
-        message: `Zed trial access is blocked upstream. The account can list hosted models, but Zed is refusing completions until trial/billing access is enabled or unblocked. Zed says: ${rawMessage}`
-      };
-    }
-    if (code) {
-      return {
-        status: response.status,
-        message: `Zed ${code}: ${rawMessage}`
-      };
-    }
-    return {
-      status: response.status,
-      message: rawMessage || `Zed upstream error: ${response.status}`
-    };
-  }
-  async refreshCredentials() {
-    return null;
-  }
-  needsRefresh() {
-    return false;
-  }
-}
-var zed_hosted_default = ZedHostedExecutor;
-const __test__ = {
-  normalizeZedProvider,
-  unwrapZedLine,
-  wrapZedCompletionStream
-};
-export {
-  ZedHostedExecutor,
-  __test__,
-  zed_hosted_default as default
-};