@openhoo/hoopilot 0.7.4 → 0.8.0

package/dist/index.cjs

@@ -30,6 +30,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AnthropicCompatibilityError: () => AnthropicCompatibilityError,
   COPILOT_USAGE_API_VERSION: () => COPILOT_USAGE_API_VERSION,
   CopilotAuth: () => CopilotAuth,
   CopilotAuthError: () => CopilotAuthError,
@@ -40,6 +41,7 @@ __export(index_exports, {
   DEFAULT_MODEL: () => DEFAULT_MODEL,
   MetricsRegistry: () => MetricsRegistry,
   PROMETHEUS_CONTENT_TYPE: () => PROMETHEUS_CONTENT_TYPE,
+  anthropicMessagesToResponsesRequest: () => anthropicMessagesToResponsesRequest,
   applyCopilotHeaders: () => applyCopilotHeaders,
   applyGithubApiHeaders: () => applyGithubApiHeaders,
   authStorePath: () => authStorePath,
@@ -49,6 +51,7 @@ __export(index_exports, {
   completionsRequestToChatCompletion: () => completionsRequestToChatCompletion,
   createHoopilotHandler: () => createHoopilotHandler,
   createHoopilotLogger: () => createHoopilotLogger,
+  estimateAnthropicMessageTokens: () => estimateAnthropicMessageTokens,
   extractTokenUsage: () => extractTokenUsage,
   fallbackModels: () => fallbackModels,
   githubCopilotDeviceLogin: () => githubCopilotDeviceLogin,
@@ -62,16 +65,14 @@ __export(index_exports, {
   parseLogLevel: () => parseLogLevel,
   readStoredCopilotAuth: () => readStoredCopilotAuth,
   responsesRequestToChatCompletion: () => responsesRequestToChatCompletion,
+  responsesResponseToAnthropicMessage: () => responsesResponseToAnthropicMessage,
   responsesStreamFromChatStream: () => responsesStreamFromChatStream,
+  responsesStreamToAnthropicStream: () => responsesStreamToAnthropicStream,
   startHoopilotServer: () => startHoopilotServer,
   writeStoredCopilotAuth: () => writeStoredCopilotAuth
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/auth-store.ts
-var import_node_fs = require("fs");
-var import_node_path = require("path");
-
 // src/util.ts
 function trimTrailingSlash(value) {
   return value.replace(/\/+$/, "");
@@ -120,633 +121,786 @@ function asRecord(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 
-// src/auth-store.ts
-var StoredCopilotAuthError = class extends Error {
+// src/openai.ts
+var DEFAULT_MODEL = "gpt-4.1";
+var OpenAICompatibilityError = class extends Error {
   constructor(message) {
     super(message);
-    this.name = "StoredCopilotAuthError";
+    this.name = "OpenAICompatibilityError";
   }
 };
-function authStorePath(env = process.env) {
-  const explicit = envValue(env.HOOPILOT_AUTH_FILE);
-  if (explicit) {
-    return explicit;
-  }
-  const xdg = envValue(env.XDG_CONFIG_HOME);
-  if (xdg) {
-    return (0, import_node_path.join)(xdg, "hoopilot", "auth.json");
-  }
-  const appdata = envValue(env.APPDATA);
-  if (appdata) {
-    return (0, import_node_path.join)(appdata, "hoopilot", "auth.json");
+function responsesRequestToChatCompletion(request) {
+  const messages = [];
+  const instructions = contentToText(request.instructions);
+  if (instructions) {
+    messages.push({ content: instructions, role: "system" });
   }
-  const home = envValue(env.HOME);
-  if (!home) {
-    throw new StoredCopilotAuthError(
-      "Cannot resolve Hoopilot auth file path without HOOPILOT_AUTH_FILE, XDG_CONFIG_HOME, APPDATA, or HOME."
-    );
+  for (const message of inputToMessages(request.input)) {
+    messages.push(message);
   }
-  const base = (0, import_node_path.join)(home, ".config");
-  return (0, import_node_path.join)(base, "hoopilot", "auth.json");
+  return removeUndefined({
+    frequency_penalty: request.frequency_penalty,
+    max_tokens: request.max_output_tokens ?? request.max_tokens,
+    messages,
+    metadata: request.metadata,
+    model: normalizeRequestedModel(request.model),
+    presence_penalty: request.presence_penalty,
+    reasoning_effort: asRecord(request.reasoning).effort,
+    response_format: asRecord(request.text).format,
+    seed: request.seed,
+    stream: request.stream === true,
+    temperature: request.temperature,
+    tool_choice: chatToolChoice(request.tool_choice),
+    tools: chatTools(request.tools),
+    top_p: request.top_p
+  });
 }
-function readStoredCopilotAuth(path = authStorePath()) {
-  let text;
-  try {
-    text = (0, import_node_fs.readFileSync)(path, "utf8");
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return void 0;
+function normalizeChatCompletionRequest(request) {
+  return removeUndefined({
+    ...request,
+    model: normalizeRequestedModel(request.model)
+  });
+}
+function completionsRequestToChatCompletion(request) {
+  assertSupportedLegacyCompletionRequest(request);
+  return removeUndefined({
+    frequency_penalty: request.frequency_penalty,
+    logit_bias: request.logit_bias,
+    max_tokens: request.max_tokens,
+    messages: [{ content: legacyPromptToText(request.prompt), role: "user" }],
+    model: normalizeRequestedModel(request.model),
+    n: request.n,
+    presence_penalty: request.presence_penalty,
+    seed: request.seed,
+    stop: request.stop,
+    stream: request.stream === true,
+    stream_options: request.stream_options,
+    temperature: request.temperature,
+    top_p: request.top_p,
+    user: request.user
+  });
+}
+function normalizeRequestedModel(model) {
+  const requested = contentToText(model).trim();
+  return requested || DEFAULT_MODEL;
+}
+function chatCompletionToResponse(completion, responseId) {
+  const id = responseId ?? `resp_${randomId()}`;
+  const choice = firstChoice(completion);
+  const message = asRecord(choice.message);
+  const model = contentToText(completion.model) || DEFAULT_MODEL;
+  const output = outputItemsFromMessage(message);
+  const usage = responseUsage(completion.usage);
+  return removeUndefined({
+    created_at: epochSeconds(),
+    error: null,
+    id,
+    incomplete_details: null,
+    instructions: null,
+    max_output_tokens: null,
+    metadata: {},
+    model,
+    object: "response",
+    output,
+    output_text: outputText(output),
+    parallel_tool_calls: true,
+    status: "completed",
+    temperature: null,
+    tool_choice: "auto",
+    tools: [],
+    top_p: null,
+    usage
+  });
+}
+function chatCompletionToCompletion(completion) {
+  return removeUndefined({
+    choices: completionChoices(completion).map((choice, index) => {
+      const message = asRecord(choice.message);
+      return {
+        finish_reason: choice.finish_reason ?? "stop",
+        index: typeof choice.index === "number" ? choice.index : index,
+        logprobs: choice.logprobs ?? null,
+        text: contentToText(choice.text) || contentToText(message.content)
+      };
+    }),
+    created: completion.created ?? epochSeconds(),
+    id: completion.id ?? `cmpl_${randomId()}`,
+    model: completion.model ?? DEFAULT_MODEL,
+    object: "text_completion",
+    system_fingerprint: completion.system_fingerprint,
+    usage: completion.usage
+  });
+}
+function completionStreamFromChatStream(chatStream) {
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let sawTerminalEvent = false;
+  return new ReadableStream({
+    async start(controller) {
+      const enqueue = (data) => {
+        controller.enqueue(encoder.encode(encodeDataSse(data)));
+      };
+      const markTerminal = () => {
+        sawTerminalEvent = true;
+      };
+      const reader = chatStream.getReader();
+      try {
+        while (true) {
+          const result = await reader.read();
+          if (result.done) {
+            break;
+          }
+          buffer += decoder.decode(result.value, { stream: true });
+          const blocks = buffer.split(/\r?\n\r?\n/);
+          buffer = blocks.pop() ?? "";
+          for (const block of blocks) {
+            processCompletionSseBlock(block, enqueue, markTerminal);
+          }
+        }
+        const tail = `${buffer}${decoder.decode()}`;
+        if (tail.trim()) {
+          processCompletionSseBlock(tail, enqueue, markTerminal);
+        }
+        if (!sawTerminalEvent) {
+          enqueue("[DONE]");
+        }
+        controller.close();
+      } catch (error) {
+        await reader.cancel(error).catch(() => {
+        });
+        controller.error(error);
+      } finally {
+        reader.releaseLock();
+      }
     }
-    throw new StoredCopilotAuthError(`Could not read Hoopilot auth file at ${path}.`);
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(text);
-  } catch {
-    throw new StoredCopilotAuthError(
-      `Hoopilot auth file at ${path} is not valid JSON. Run \`hoopilot login\` to replace it.`
-    );
-  }
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new StoredCopilotAuthError(`Hoopilot auth file at ${path} must contain a JSON object.`);
-  }
-  const record = parsed;
-  const token = typeof record.token === "string" ? record.token.trim() : "";
-  if (!token) {
-    throw new StoredCopilotAuthError(`Hoopilot auth file at ${path} does not contain a token.`);
-  }
+  });
+}
+function normalizeModelsResponse(upstream) {
+  const record = asRecord(upstream);
+  const data = Array.isArray(record.data) ? record.data : Array.isArray(upstream) ? upstream : [];
+  const models = data.map((model) => asRecord(model)).filter((model) => typeof model.id === "string").map((model) => ({
+    created: model.created ?? 0,
+    id: model.id,
+    object: "model",
+    owned_by: model.owned_by ?? "github-copilot"
+  }));
   return {
-    apiBaseUrl: typeof record.apiBaseUrl === "string" ? record.apiBaseUrl : void 0,
-    createdAt: typeof record.createdAt === "string" ? record.createdAt : void 0,
-    githubDomain: typeof record.githubDomain === "string" ? record.githubDomain : void 0,
-    source: typeof record.source === "string" ? record.source : void 0,
-    token
+    data: models.length > 0 ? models : fallbackModels(),
+    object: "list"
   };
 }
-function writeStoredCopilotAuth(auth, path = authStorePath()) {
-  (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(path), { recursive: true });
-  const data = `${JSON.stringify(
+function fallbackModels() {
+  return [
     {
-      ...auth,
-      createdAt: auth.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
-    },
-    null,
-    2
-  )}
-`;
-  const tmpPath = `${path}.${process.pid}.tmp`;
-  (0, import_node_fs.writeFileSync)(tmpPath, data, { mode: 384 });
-  (0, import_node_fs.renameSync)(tmpPath, path);
-  try {
-    (0, import_node_fs.chmodSync)(path, 384);
-  } catch {
-  }
+      created: 0,
+      id: DEFAULT_MODEL,
+      object: "model",
+      owned_by: "github-copilot"
+    }
+  ];
 }
-
-// src/auth.ts
-var DEFAULT_COPILOT_API_BASE_URL = "https://api.githubcopilot.com";
-var REFRESH_SKEW_MS = 6e4;
-var STORED_TOKEN_TTL_MS = 10 * 6e4;
-var CopilotAuthError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "CopilotAuthError";
-  }
-};
-var CopilotAuth = class {
-  #authStorePath;
-  #copilotApiBaseUrl;
-  #hasCopilotApiBaseUrlOverride;
-  #cachedAccess;
-  constructor(options = {}) {
-    const envAuthStorePath = envValue(options.env?.HOOPILOT_AUTH_FILE);
-    const envCopilotApiBaseUrl = envValue(options.env?.COPILOT_API_BASE_URL);
-    this.#authStorePath = options.authStorePath ?? envAuthStorePath;
-    this.#hasCopilotApiBaseUrlOverride = Boolean(options.copilotApiBaseUrl ?? envCopilotApiBaseUrl);
-    this.#copilotApiBaseUrl = trimTrailingSlash(
-      options.copilotApiBaseUrl ?? envCopilotApiBaseUrl ?? DEFAULT_COPILOT_API_BASE_URL
-    );
-  }
-  async getAccess() {
-    if (this.#cachedAccess && this.#cachedAccess.expiresAtMs - REFRESH_SKEW_MS > Date.now()) {
-      return this.#cachedAccess;
-    }
-    let stored;
-    try {
-      stored = readStoredCopilotAuth(this.#authStorePath);
-    } catch (error) {
-      if (error instanceof StoredCopilotAuthError) {
-        throw new CopilotAuthError(error.message);
-      }
-      throw error;
-    }
-    if (stored) {
-      return this.#cacheAccess({
-        apiBaseUrl: trimTrailingSlash(
-          this.#hasCopilotApiBaseUrlOverride ? this.#copilotApiBaseUrl : stored.apiBaseUrl ?? this.#copilotApiBaseUrl
-        ),
-        expiresAtMs: Date.now() + STORED_TOKEN_TTL_MS,
-        source: "github-copilot-oauth",
-        token: stored.token
+function responsesStreamFromChatStream(chatStream, options) {
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder();
+  const responseId = options.responseId ?? `resp_${randomId()}`;
+  const messageId = `msg_${randomId()}`;
+  const createdAt = epochSeconds();
+  let buffer = "";
+  let text = "";
+  let messageOutputIndex;
+  let nextOutputIndex = 0;
+  let sequenceNumber = 0;
+  const tools = /* @__PURE__ */ new Map();
+  return new ReadableStream({
+    async start(controller) {
+      const enqueue = (event, data) => {
+        controller.enqueue(
+          encoder.encode(
+            encodeSse(
+              event,
+              data === "[DONE]" ? data : { ...data, sequence_number: sequenceNumber++ }
+            )
+          )
+        );
+      };
+      enqueue("response.created", {
+        response: baseStreamResponse(responseId, options.model, createdAt, "in_progress", []),
+        type: "response.created"
       });
+      const ensureMessageStarted = () => {
+        if (messageOutputIndex !== void 0) {
+          return;
+        }
+        messageOutputIndex = nextOutputIndex++;
+        enqueue("response.output_item.added", {
+          item: {
+            content: [],
+            id: messageId,
+            role: "assistant",
+            status: "in_progress",
+            type: "message"
+          },
+          output_index: messageOutputIndex,
+          type: "response.output_item.added"
+        });
+        enqueue("response.content_part.added", {
+          content_index: 0,
+          item_id: messageId,
+          output_index: messageOutputIndex,
+          part: {
+            annotations: [],
+            text: "",
+            type: "output_text"
+          },
+          type: "response.content_part.added"
+        });
+      };
+      const appendText = (delta) => {
+        ensureMessageStarted();
+        text += delta;
+        enqueue("response.output_text.delta", {
+          content_index: 0,
+          delta,
+          item_id: messageId,
+          output_index: messageOutputIndex ?? 0,
+          type: "response.output_text.delta"
+        });
+      };
+      const appendToolCall = (toolCall) => {
+        const fn = asRecord(toolCall.function);
+        const index = typeof toolCall.index === "number" ? toolCall.index : tools.size;
+        let existing = tools.get(index);
+        const isNew = !existing;
+        existing ??= {
+          arguments: "",
+          id: contentToText(toolCall.id) || `call_${randomId()}`,
+          index,
+          itemId: `fc_${randomId()}`,
+          name: "",
+          outputIndex: nextOutputIndex++
+        };
+        existing.id = contentToText(toolCall.id) || existing.id;
+        existing.name += contentToText(fn.name);
+        tools.set(index, existing);
+        if (isNew) {
+          enqueue("response.output_item.added", {
+            item: functionCallItem(existing, "in_progress"),
+            output_index: existing.outputIndex ?? 0,
+            type: "response.output_item.added"
+          });
+        }
+        const argumentDelta = contentToText(fn.arguments);
+        if (argumentDelta) {
+          existing.arguments += argumentDelta;
+          enqueue("response.function_call_arguments.delta", {
+            delta: argumentDelta,
+            item_id: existing.itemId,
+            output_index: existing.outputIndex ?? 0,
+            type: "response.function_call_arguments.delta"
+          });
+        }
+      };
+      const reader = chatStream.getReader();
+      try {
+        while (true) {
+          const result = await reader.read();
+          if (result.done) {
+            break;
+          }
+          buffer += decoder.decode(result.value, { stream: true });
+          const lines = buffer.split(/\r?\n/);
+          buffer = lines.pop() ?? "";
+          for (const line of lines) {
+            processChatSseLine(line, { appendText, appendToolCall });
+          }
+        }
+        if (buffer) {
+          processChatSseLine(buffer, { appendText, appendToolCall });
+        }
+        const outputEntries = [];
+        if (messageOutputIndex !== void 0) {
+          const item = messageOutputItem(text, messageId);
+          outputEntries.push([messageOutputIndex, item]);
+          enqueue("response.output_text.done", {
+            content_index: 0,
+            item_id: messageId,
+            output_index: messageOutputIndex,
+            text,
+            type: "response.output_text.done"
+          });
+          enqueue("response.content_part.done", {
+            content_index: 0,
+            item_id: messageId,
+            output_index: messageOutputIndex,
+            part: {
+              annotations: [],
+              text,
+              type: "output_text"
+            },
+            type: "response.content_part.done"
+          });
+          enqueue("response.output_item.done", {
+            item,
+            output_index: messageOutputIndex,
+            type: "response.output_item.done"
+          });
+        }
+        for (const tool of [...tools.values()].sort(
+          (a, b) => (a.outputIndex ?? 0) - (b.outputIndex ?? 0)
+        )) {
+          const item = functionCallItem(tool);
+          const outputIndex = tool.outputIndex ?? 0;
+          outputEntries.push([outputIndex, item]);
+          enqueue("response.function_call_arguments.done", {
+            arguments: tool.arguments,
+            item_id: item.id,
+            output_index: outputIndex,
+            type: "response.function_call_arguments.done"
+          });
+          enqueue("response.output_item.done", {
+            item,
+            output_index: outputIndex,
+            type: "response.output_item.done"
+          });
+        }
+        const output = outputEntries.sort(([left], [right]) => left - right).map(([, item]) => item);
+        enqueue("response.completed", {
+          response: baseStreamResponse(responseId, options.model, createdAt, "completed", output),
+          type: "response.completed"
+        });
+        enqueue("done", "[DONE]");
+        controller.close();
+      } catch (error) {
+        await reader.cancel(error).catch(() => {
+        });
+        controller.error(error);
+      } finally {
+        reader.releaseLock();
+      }
     }
-    throw new CopilotAuthError(
-      "No GitHub Copilot OAuth credential found. Run `hoopilot login` to sign in through your browser."
-    );
-  }
-  #cacheAccess(access) {
-    this.#cachedAccess = access;
-    return access;
-  }
-};
-
-// src/copilot.ts
-var DEFAULT_GITHUB_API_BASE_URL = "https://api.github.com";
-var ALLOWED_COPILOT_API_HOSTS = ["api.githubcopilot.com"];
-var ALLOWED_GITHUB_API_HOSTS = ["api.github.com"];
-var COPILOT_USAGE_API_VERSION = "2025-04-01";
-function applyCopilotHeaders(headers, token) {
-  headers.set("accept", headers.get("accept") ?? "application/json");
-  headers.set("authorization", `Bearer ${token}`);
-  headers.set("copilot-integration-id", "vscode-chat");
-  headers.set("editor-plugin-version", "hoopilot/0.1.0");
-  headers.set("editor-version", "Hoopilot/0.1.0");
-  headers.set("openai-intent", "conversation-panel");
-  headers.set("user-agent", "hoopilot/0.1.0");
-  headers.set("x-github-api-version", "2026-06-01");
-  return headers;
-}
-function applyGithubApiHeaders(headers, token) {
-  headers.set("accept", headers.get("accept") ?? "application/json");
-  headers.set("authorization", `token ${token}`);
-  headers.set("editor-plugin-version", "hoopilot/0.1.0");
-  headers.set("editor-version", "Hoopilot/0.1.0");
-  headers.set("user-agent", "hoopilot/0.1.0");
-  headers.set("x-github-api-version", COPILOT_USAGE_API_VERSION);
-  return headers;
+  });
 }
-var CopilotClient = class {
-  #auth;
-  #allowUnsafeUpstream;
-  #fetch;
-  #githubApiBaseUrl;
-  constructor(options = {}) {
-    this.#auth = new CopilotAuth(options);
-    this.#allowUnsafeUpstream = envValue(options.env?.HOOPILOT_ALLOW_UNSAFE_UPSTREAM) === "1";
-    this.#fetch = options.fetch ?? fetch;
-    this.#githubApiBaseUrl = trimTrailingSlash(
-      options.githubApiBaseUrl ?? envValue(options.env?.HOOPILOT_GITHUB_API_BASE_URL) ?? DEFAULT_GITHUB_API_BASE_URL
-    );
-  }
-  /**
-   * Fetch the Copilot account's quota / premium-request usage from the GitHub
-   * REST `copilot_internal/user` endpoint. The stored device-flow OAuth token is
-   * accepted directly here — no Copilot token exchange is required to read quota.
-   */
-  async usage(signal) {
-    if (!isTrustedTokenBaseUrl(
-      this.#githubApiBaseUrl,
-      ALLOWED_GITHUB_API_HOSTS,
-      this.#allowUnsafeUpstream
-    )) {
-      throw new Error(
-        `Refusing to send the GitHub OAuth token to an untrusted GitHub API host: ${this.#githubApiBaseUrl}`
-      );
-    }
-    const access = await this.#auth.getAccess();
-    const headers = applyGithubApiHeaders(new Headers(), access.token);
-    return this.#fetch(`${this.#githubApiBaseUrl}/copilot_internal/user`, {
-      headers,
-      method: "GET",
-      signal
-    });
-  }
-  async chatCompletions(body, signal) {
-    return this.fetchCopilot("/chat/completions", {
-      body: JSON.stringify(body),
-      headers: {
-        "content-type": "application/json"
-      },
-      method: "POST",
-      signal
-    });
-  }
-  async responses(body, signal) {
-    return this.fetchCopilot("/responses", {
-      body,
-      headers: {
-        "content-type": "application/json"
-      },
-      method: "POST",
-      signal
-    });
+function inputToMessages(input) {
+  if (typeof input === "string") {
+    return [{ content: input, role: "user" }];
   }
-  async models(signal) {
-    return this.fetchCopilot("/models", {
-      headers: {
-        accept: "application/json"
-      },
-      method: "GET",
-      signal
-    });
+  if (!Array.isArray(input)) {
+    return [];
   }
-  async fetchCopilot(path, init) {
-    const access = await this.#auth.getAccess();
-    if (!isTrustedTokenBaseUrl(
-      access.apiBaseUrl,
-      ALLOWED_COPILOT_API_HOSTS,
-      this.#allowUnsafeUpstream
-    )) {
-      throw new Error(
-        `Refusing to send the GitHub OAuth token to an untrusted Copilot API host: ${access.apiBaseUrl}`
-      );
+  const messages = [];
+  for (const item of input) {
+    const record = asRecord(item);
+    const type = contentToText(record.type);
+    if (type === "function_call_output") {
+      messages.push({
+        content: contentToText(record.output),
+        role: "tool",
+        tool_call_id: contentToText(record.call_id)
+      });
+      continue;
     }
-    const headers = applyCopilotHeaders(new Headers(init.headers), access.token);
-    return this.#fetch(`${access.apiBaseUrl}${path}`, {
-      ...init,
-      headers
-    });
-  }
-};
-function normalizeCopilotUsage(body) {
-  const record = asRecord(body);
-  const quotas = {};
-  const snapshots = asRecord(record.quota_snapshots);
-  for (const [category, detail] of Object.entries(snapshots)) {
-    quotas[category] = normalizeQuotaDetail(asRecord(detail));
-  }
-  if (Object.keys(quotas).length === 0) {
-    const remaining = asRecord(record.limited_user_quotas);
-    const monthly = asRecord(record.monthly_quotas);
-    for (const category of /* @__PURE__ */ new Set([...Object.keys(remaining), ...Object.keys(monthly)])) {
-      const entitlement = numberOrUndefined(monthly[category]);
-      const left = numberOrUndefined(remaining[category]);
-      quotas[category] = removeUndefinedQuota({
-        entitlement,
-        percentRemaining: entitlement !== void 0 && entitlement > 0 && left !== void 0 ? left / entitlement * 100 : void 0,
-        remaining: left,
-        used: usedFrom(entitlement, left)
+    if (type === "function_call") {
+      messages.push({
+        role: "assistant",
+        tool_calls: [
+          {
+            function: {
+              arguments: contentToText(record.arguments),
+              name: contentToText(record.name)
+            },
+            id: contentToText(record.call_id) || contentToText(record.id),
+            type: "function"
+          }
+        ]
       });
+      continue;
+    }
+    if (type && type !== "message") {
+      unsupportedResponsesFeature(`input item type "${type}"`);
+    }
+    const role = responsesRoleToChatRole(contentToText(record.role));
+    const content = chatMessageContent(record.content);
+    if (role && content !== void 0) {
+      messages.push({ content, role });
     }
   }
-  return removeUndefinedUsage({
-    accessTypeSku: stringOrUndefined(record.access_type_sku),
-    chatEnabled: typeof record.chat_enabled === "boolean" ? record.chat_enabled : void 0,
-    plan: stringOrUndefined(record.copilot_plan),
-    quotaResetDate: stringOrUndefined(record.quota_reset_date) ?? stringOrUndefined(record.quota_reset_date_utc) ?? stringOrUndefined(record.limited_user_reset_date),
-    quotas
-  });
-}
-function normalizeQuotaDetail(detail) {
-  const entitlement = numberOrUndefined(detail.entitlement);
-  const remaining = numberOrUndefined(detail.remaining) ?? numberOrUndefined(detail.quota_remaining);
-  return removeUndefinedQuota({
-    entitlement,
-    overageCount: numberOrUndefined(detail.overage_count),
-    overagePermitted: typeof detail.overage_permitted === "boolean" ? detail.overage_permitted : void 0,
-    percentRemaining: numberOrUndefined(detail.percent_remaining),
-    remaining,
-    unlimited: typeof detail.unlimited === "boolean" ? detail.unlimited : void 0,
-    used: usedFrom(entitlement, remaining)
-  });
-}
-function usedFrom(entitlement, remaining) {
-  if (entitlement === void 0 || remaining === void 0) {
-    return void 0;
-  }
-  return Math.max(0, entitlement - remaining);
-}
-function numberOrUndefined(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-}
-function stringOrUndefined(value) {
-  return typeof value === "string" && value.length > 0 ? value : void 0;
-}
-function removeUndefinedQuota(quota) {
-  return Object.fromEntries(
-    Object.entries(quota).filter(([, value]) => value !== void 0)
-  );
-}
-function removeUndefinedUsage(usage) {
-  const entries = Object.entries(usage).filter(([, value]) => value !== void 0);
-  return Object.fromEntries(entries);
-}
-
-// src/github-device.ts
-var import_promises = require("timers/promises");
-var DEFAULT_GITHUB_COPILOT_CLIENT_ID = "Ov23li8tweQw6odWQebz";
-var DEFAULT_GITHUB_DOMAIN = "github.com";
-var DEVICE_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:device_code";
-var POLLING_SAFETY_MARGIN_MS = 3e3;
-var REQUEST_TIMEOUT_MS = 15e3;
-async function githubCopilotDeviceLogin(options = {}) {
-  const env = options.env ?? process.env;
-  const fetcher = options.fetch ?? fetch;
-  const sleeper = options.sleep ?? import_promises.setTimeout;
-  const domain = normalizeDomain(
-    options.domain ?? envValue(env.HOOPILOT_GITHUB_DOMAIN) ?? DEFAULT_GITHUB_DOMAIN
-  );
-  const clientId = options.clientId ?? envValue(env.HOOPILOT_GITHUB_CLIENT_ID) ?? envValue(env.COPILOT_GITHUB_CLIENT_ID) ?? DEFAULT_GITHUB_COPILOT_CLIENT_ID;
-  const device = await requestDeviceCode(fetcher, domain, clientId);
-  const verificationUrl = device.verification_uri;
-  const userCode = device.user_code;
-  const deviceCode = device.device_code;
-  if (!verificationUrl || !userCode || !deviceCode) {
-    throw new Error("GitHub device authorization response is missing required fields.");
-  }
-  options.logger?.info(`First copy your one-time code: ${userCode}`);
-  options.logger?.info(`Open ${verificationUrl} in your browser to authorize Hoopilot.`);
-  await options.openBrowser?.(verificationUrl);
-  return {
-    domain,
-    token: await pollForAccessToken(fetcher, sleeper, domain, clientId, {
-      deviceCode,
-      expiresIn: positiveSeconds(device.expires_in, 900),
-      interval: positiveSeconds(device.interval, 5)
-    })
-  };
-}
-async function requestDeviceCode(fetcher, domain, clientId) {
-  const response = await fetcher(`https://${domain}/login/device/code`, {
-    body: JSON.stringify({
-      client_id: clientId,
-      scope: "read:user"
-    }),
-    headers: oauthHeaders(),
-    method: "POST",
-    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
-  });
-  if (!response.ok) {
-    throw new Error(
-      `GitHub device authorization failed with ${response.status}: ${await truncatedResponseText(
-        response
-      )}`
-    );
-  }
-  return parseJsonResponse(
-    response,
-    "GitHub device authorization response was not valid JSON"
-  );
+  return messages;
 }
-async function pollForAccessToken(fetcher, sleeper, domain, clientId, device) {
-  let intervalMs = device.interval * 1e3 + POLLING_SAFETY_MARGIN_MS;
-  const deadline = Date.now() + device.expiresIn * 1e3;
-  while (Date.now() < deadline) {
-    await sleeper(intervalMs);
-    const response = await fetcher(`https://${domain}/login/oauth/access_token`, {
-      body: JSON.stringify({
-        client_id: clientId,
-        device_code: device.deviceCode,
-        grant_type: DEVICE_GRANT_TYPE
-      }),
-      headers: oauthHeaders(),
-      method: "POST",
-      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
-    });
-    if (!response.ok) {
-      throw new Error(
-        `GitHub device token exchange failed with ${response.status}: ${await truncatedResponseText(
-          response
-        )}`
-      );
-    }
-    const data = await parseJsonResponse(
-      response,
-      "GitHub device token response was not valid JSON"
-    );
-    if (data.access_token) {
-      return data.access_token;
+function chatMessageContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    if (content === void 0 || content === null) {
+      return void 0;
     }
-    if (data.error === "authorization_pending") {
+    unsupportedResponsesFeature("non-array message content objects");
+  }
+  const parts = [];
+  for (const part of content) {
+    const record = asRecord(part);
+    const type = contentToText(record.type);
+    if (type === "input_text" || type === "output_text" || type === "text") {
+      parts.push({ text: contentToText(record.text), type: "text" });
       continue;
     }
-    if (data.error === "slow_down") {
-      intervalMs = positiveSeconds(data.interval, device.interval + 5) * 1e3 + POLLING_SAFETY_MARGIN_MS;
+    if (type === "input_image") {
+      if (contentToText(record.file_id)) {
+        unsupportedResponsesFeature("input_image file_id parts");
+      }
+      const imageUrl = contentToText(record.image_url);
+      if (!imageUrl) {
+        unsupportedResponsesFeature("input_image parts without image_url");
+      }
+      const image = { url: imageUrl };
+      const detail = contentToText(record.detail);
+      if (detail) {
+        image.detail = detail;
+      }
+      parts.push({ image_url: image, type: "image_url" });
       continue;
     }
-    if (data.error === "expired_token") {
-      throw new Error("GitHub device login expired. Run `hoopilot login` again.");
-    }
-    if (data.error === "access_denied") {
-      throw new Error("GitHub device login was cancelled.");
+    if (type === "input_file") {
+      unsupportedResponsesFeature("input_file parts");
     }
-    if (data.error) {
-      throw new Error(data.error_description || `GitHub device login failed: ${data.error}`);
+    if (type === "input_audio") {
+      unsupportedResponsesFeature("input_audio parts");
     }
+    unsupportedResponsesFeature(`content part type "${type || "unknown"}"`);
   }
-  throw new Error("GitHub device login timed out. Run `hoopilot login` again.");
+  if (parts.length === 0) {
+    return void 0;
+  }
+  if (parts.every((part) => part.type === "text")) {
+    return parts.map((part) => contentToText(part.text)).join("\n");
+  }
+  return parts;
 }
-function oauthHeaders() {
-  const headers = new Headers();
-  headers.set("accept", "application/json");
-  headers.set("content-type", "application/json");
-  headers.set("user-agent", "hoopilot");
-  return headers;
+function legacyPromptToText(prompt) {
+  if (typeof prompt === "string") {
+    return prompt;
+  }
+  if (Array.isArray(prompt) && prompt.length === 1 && typeof prompt[0] === "string") {
+    return prompt[0];
+  }
+  throw new OpenAICompatibilityError(
+    "Hoopilot legacy completions compatibility supports exactly one string prompt per request."
+  );
 }
-function normalizeDomain(value) {
-  return value.replace(/^https?:\/\//, "").replace(/\/+$/, "");
+function assertSupportedLegacyCompletionRequest(request) {
+  if (request.echo === true) {
+    throw new OpenAICompatibilityError(
+      "Hoopilot legacy completions compatibility does not support echo=true."
+    );
+  }
+  if (typeof request.best_of === "number" && request.best_of > 1) {
+    throw new OpenAICompatibilityError(
+      "Hoopilot legacy completions compatibility does not support best_of greater than 1."
+    );
+  }
+  if (typeof request.logprobs === "number" && request.logprobs > 0) {
+    throw new OpenAICompatibilityError(
+      "Hoopilot legacy completions compatibility does not support legacy logprobs."
+    );
+  }
+  if (contentToText(request.suffix)) {
+    throw new OpenAICompatibilityError(
+      "Hoopilot legacy completions compatibility does not support suffix."
+    );
+  }
 }
-function positiveSeconds(value, fallback) {
-  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+function contentToText(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (typeof content === "number" || typeof content === "boolean") {
+    return String(content);
+  }
+  if (Array.isArray(content)) {
+    return content.map((item) => contentToText(item)).filter(Boolean).join("\n");
+  }
+  if (content && typeof content === "object") {
+    const record = content;
+    if (typeof record.text === "string") {
+      return record.text;
+    }
+    if (typeof record.output_text === "string") {
+      return record.output_text;
+    }
+    return JSON.stringify(content);
+  }
+  return "";
 }
-async function parseJsonResponse(response, context) {
-  const text = await response.text();
-  try {
-    return JSON.parse(text);
-  } catch {
-    throw new Error(`${context}: ${text.slice(0, 500)}`);
+function responsesRoleToChatRole(role) {
+  if (!role) {
+    return "user";
   }
+  if (role === "assistant" || role === "developer" || role === "system" || role === "tool" || role === "user") {
+    return role === "developer" ? "system" : role;
+  }
+  unsupportedResponsesFeature(`message role "${role}"`);
 }
-
-// src/logger.ts
-var import_pino = __toESM(require("pino"), 1);
-var import_pino_pretty = __toESM(require("pino-pretty"), 1);
-var DEFAULT_LOG_FORMAT = "pretty";
-var DEFAULT_LOG_LEVEL = "info";
-var LOG_FORMATS = ["json", "pretty"];
-var LOG_LEVELS = ["trace", "debug", "info", "warn", "error", "fatal", "silent"];
-var REDACT_PATHS = [
-  "apiKey",
-  "authorization",
-  "cookie",
-  "headers.authorization",
-  "headers.Authorization",
-  "headers.cookie",
-  "headers.Cookie",
-  "headers.x-api-key",
-  "headers.X-Api-Key",
-  "token",
-  "*.apiKey",
-  "*.authorization",
-  "*.cookie",
-  "*.token",
-  "*.headers.authorization",
-  "*.headers.Authorization",
-  "*.headers.cookie",
-  "*.headers.Cookie",
-  "*.headers.x-api-key",
-  "*.headers.X-Api-Key"
-];
-var noopLogger = {
-  child: () => noopLogger,
-  debug: () => {
-  },
-  error: () => {
-  },
-  fatal: () => {
-  },
-  info: () => {
-  },
-  trace: () => {
-  },
-  warn: () => {
+function chatTools(tools) {
+  if (!Array.isArray(tools)) {
+    return void 0;
   }
-};
-function createHoopilotLogger(options = {}) {
-  const env = options.env ?? process.env;
-  const level = parseLogLevel(options.level ?? envValue(env.HOOPILOT_LOG_LEVEL));
-  const format = parseLogFormat(options.format ?? envValue(env.HOOPILOT_LOG_FORMAT));
-  const pinoOptions = {
-    base: {
-      service: "hoopilot",
-      ...options.base
-    },
-    level,
-    redact: {
-      censor: "[Redacted]",
-      paths: REDACT_PATHS
-    },
-    timestamp: import_pino.default.stdTimeFunctions.isoTime
-  };
-  if (format === "pretty") {
-    return (0, import_pino.default)(
-      pinoOptions,
-      (0, import_pino_pretty.default)({
-        colorize: options.colorize ?? process.stderr.isTTY,
-        destination: options.stream ?? 1,
-        ignore: "pid,hostname",
-        singleLine: true,
-        translateTime: "SYS:standard"
-      })
-    );
+  const converted = tools.map((tool) => {
+    const record = asRecord(tool);
+    const type = contentToText(record.type);
+    if (type !== "function") {
+      unsupportedResponsesFeature(`tool type "${type || "unknown"}"`);
+    }
+    return {
+      function: removeUndefined({
+        description: record.description,
+        name: record.name,
+        parameters: record.parameters,
+        strict: record.strict
+      }),
+      type: "function"
+    };
+  });
+  return converted.length > 0 ? converted : void 0;
+}
+function chatToolChoice(toolChoice) {
+  if (typeof toolChoice === "string" || toolChoice === void 0) {
+    return toolChoice;
   }
-  if (options.stream) {
-    return (0, import_pino.default)(pinoOptions, options.stream);
+  const record = asRecord(toolChoice);
+  const type = contentToText(record.type);
+  if (type === "function" && typeof record.name === "string") {
+    return { function: { name: record.name }, type: "function" };
   }
-  return (0, import_pino.default)(pinoOptions);
+  unsupportedResponsesFeature(`tool_choice type "${type || "unknown"}"`);
 }
-function parseLogFormat(value) {
-  if (!value) {
-    return DEFAULT_LOG_FORMAT;
+function unsupportedResponsesFeature(feature) {
+  throw new OpenAICompatibilityError(
+    `Hoopilot Responses-to-chat compatibility does not support ${feature}.`
+  );
+}
+function outputItemsFromMessage(message) {
+  const output = [];
+  const text = contentToText(message.content);
+  if (text) {
+    output.push(messageOutputItem(text));
   }
-  if (isLogFormat(value)) {
-    return value;
+  const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+  for (const toolCall of toolCalls) {
+    const record = asRecord(toolCall);
+    const fn = asRecord(record.function);
+    output.push(
+      functionCallItem({
+        arguments: contentToText(fn.arguments),
+        id: contentToText(record.id) || `call_${randomId()}`,
+        index: output.length,
+        name: contentToText(fn.name)
+      })
+    );
   }
-  throw new Error(`Invalid log format: ${value}. Expected one of: ${LOG_FORMATS.join(", ")}.`);
+  return output;
 }
-function parseLogLevel(value) {
-  if (!value) {
-    return DEFAULT_LOG_LEVEL;
+function messageOutputItem(text, id = `msg_${randomId()}`) {
+  return {
+    content: [
+      {
+        annotations: [],
+        text,
+        type: "output_text"
+      }
+    ],
+    id,
+    role: "assistant",
+    status: "completed",
+    type: "message"
+  };
+}
+function functionCallItem(tool, status = "completed") {
+  return {
+    arguments: tool.arguments,
+    call_id: tool.id,
+    id: tool.itemId ?? `fc_${randomId()}`,
+    name: tool.name,
+    status,
+    type: "function_call"
+  };
+}
+function outputText(output) {
+  return output.flatMap((item) => {
+    const content = item.content;
+    return Array.isArray(content) ? content : [];
+  }).map((part) => contentToText(asRecord(part).text)).filter(Boolean).join("");
+}
+function responseUsage(usage) {
+  const record = asRecord(usage);
+  if (Object.keys(record).length === 0) {
+    return null;
   }
-  if (isLogLevel(value)) {
-    return value;
+  const inputTokens = record.prompt_tokens;
+  const outputTokens = record.completion_tokens;
+  return removeUndefined({
+    input_tokens: inputTokens,
+    input_tokens_details: responseUsageDetails(record.prompt_tokens_details, inputTokens, {
+      cached_tokens: 0
+    }),
+    output_tokens: outputTokens,
+    output_tokens_details: responseUsageDetails(record.completion_tokens_details, outputTokens, {
+      reasoning_tokens: 0
+    }),
+    total_tokens: record.total_tokens
+  });
+}
+function responseUsageDetails(value, tokenCount, fallback) {
+  const record = asRecord(value);
+  if (Object.keys(record).length > 0) {
+    return record;
   }
-  throw new Error(`Invalid log level: ${value}. Expected one of: ${LOG_LEVELS.join(", ")}.`);
+  return typeof tokenCount === "number" && Number.isFinite(tokenCount) ? fallback : void 0;
 }
-function shouldCreateLogger(options) {
-  return Boolean(
-    options.logger || options.logFormat || options.logLevel || envValue(options.env?.HOOPILOT_LOG_FORMAT) || envValue(options.env?.HOOPILOT_LOG_LEVEL)
+function extractTokenUsage(usage) {
+  const record = asRecord(usage);
+  const prompt = firstNumber(record.prompt_tokens, record.input_tokens);
+  const completion = firstNumber(record.completion_tokens, record.output_tokens);
+  const total = firstNumber(record.total_tokens);
+  if (prompt === void 0 && completion === void 0 && total === void 0) {
+    return void 0;
+  }
+  const promptTokens = prompt ?? 0;
+  const completionTokens = completion ?? 0;
+  const reasoning = firstNumber(
+    asRecord(record.completion_tokens_details).reasoning_tokens,
+    asRecord(record.output_tokens_details).reasoning_tokens
+  );
+  const cached = firstNumber(
+    asRecord(record.prompt_tokens_details).cached_tokens,
+    asRecord(record.input_tokens_details).cached_tokens
   );
+  return removeUndefined({
+    cachedTokens: cached,
+    completionTokens,
+    promptTokens,
+    reasoningTokens: reasoning,
+    totalTokens: total ?? promptTokens + completionTokens
+  });
 }
-function errorDetails(error) {
-  if (error instanceof Error) {
-    return {
-      message: error.message,
-      name: error.name,
-      stack: error.stack
-    };
+function firstNumber(...values) {
+  for (const value of values) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return value;
+    }
   }
-  return { message: String(error) };
+  return void 0;
 }
-function isLogFormat(value) {
-  return LOG_FORMATS.includes(value);
+function firstChoice(completion) {
+  return completionChoices(completion)[0] ?? {};
 }
-function isLogLevel(value) {
-  return LOG_LEVELS.includes(value);
+function completionChoices(completion) {
+  const choices = Array.isArray(completion.choices) ? completion.choices : [];
+  return choices.map((choice) => asRecord(choice));
 }
-
-// src/openai.ts
-var DEFAULT_MODEL = "gpt-4.1";
-var OpenAICompatibilityError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "OpenAICompatibilityError";
+function processCompletionSseBlock(block, enqueue, markTerminal) {
+  let event = "message";
+  const dataLines = [];
+  for (const line of block.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("event:")) {
+      event = trimmed.slice("event:".length).trim() || event;
+    } else if (trimmed.startsWith("data:")) {
+      dataLines.push(trimmed.slice("data:".length).trim());
+    }
   }
-};
-function responsesRequestToChatCompletion(request) {
-  const messages = [];
-  const instructions = contentToText(request.instructions);
-  if (instructions) {
-    messages.push({ content: instructions, role: "system" });
+  const data = dataLines.join("\n");
+  if (!data) {
+    return;
   }
-  for (const message of inputToMessages(request.input)) {
-    messages.push(message);
+  if (data === "[DONE]") {
+    markTerminal();
+    enqueue("[DONE]");
+    return;
   }
-  return removeUndefined({
-    frequency_penalty: request.frequency_penalty,
-    max_tokens: request.max_output_tokens ?? request.max_tokens,
-    messages,
-    metadata: request.metadata,
-    model: normalizeRequestedModel(request.model),
-    presence_penalty: request.presence_penalty,
-    reasoning_effort: asRecord(request.reasoning).effort,
-    response_format: asRecord(request.text).format,
-    seed: request.seed,
-    stream: request.stream === true,
-    temperature: request.temperature,
-    tool_choice: chatToolChoice(request.tool_choice),
-    tools: chatTools(request.tools),
-    top_p: request.top_p
-  });
-}
-function normalizeChatCompletionRequest(request) {
-  return removeUndefined({
-    ...request,
-    model: normalizeRequestedModel(request.model)
-  });
-}
-function completionsRequestToChatCompletion(request) {
-  assertSupportedLegacyCompletionRequest(request);
-  return removeUndefined({
-    frequency_penalty: request.frequency_penalty,
-    logit_bias: request.logit_bias,
-    max_tokens: request.max_tokens,
-    messages: [{ content: legacyPromptToText(request.prompt), role: "user" }],
-    model: normalizeRequestedModel(request.model),
-    n: request.n,
-    presence_penalty: request.presence_penalty,
-    seed: request.seed,
-    stop: request.stop,
-    stream: request.stream === true,
-    stream_options: request.stream_options,
-    temperature: request.temperature,
-    top_p: request.top_p,
-    user: request.user
-  });
+  const parsed = parseJson(data);
+  if (!parsed) {
+    return;
+  }
+  const error = completionStreamError(event, parsed);
+  if (error) {
+    markTerminal();
+    enqueue({ error });
+    return;
+  }
+  const choices = completionChoices(parsed).map((choice, index) => {
+    const delta = asRecord(choice.delta);
+    const text = contentToText(delta.content);
+    const finishReason = choice.finish_reason ?? null;
+    if (!text && finishReason === null) {
+      return void 0;
+    }
+    return {
+      finish_reason: finishReason,
+      index: typeof choice.index === "number" ? choice.index : index,
+      logprobs: choice.logprobs ?? null,
+      text
+    };
+  }).filter((choice) => choice !== void 0);
+  const usage = asRecord(parsed.usage);
+  const hasUsage = Object.keys(usage).length > 0;
+  if (choices.length === 0 && !hasUsage) {
+    return;
+  }
+  enqueue(
+    removeUndefined({
+      choices,
+      created: typeof parsed.created === "number" ? parsed.created : epochSeconds(),
+      id: contentToText(parsed.id) || `cmpl_${randomId()}`,
+      model: contentToText(parsed.model) || DEFAULT_MODEL,
+      object: "text_completion",
+      usage: hasUsage ? usage : void 0
+    })
+  );
 }
-function normalizeRequestedModel(model) {
-  const requested = contentToText(model).trim();
-  return requested || DEFAULT_MODEL;
+function completionStreamError(event, parsed) {
+  const responseError = asRecord(asRecord(parsed.response).error);
+  const directError = asRecord(parsed.error);
+  const error = Object.keys(directError).length > 0 ? directError : Object.keys(responseError).length > 0 ? responseError : void 0;
+  if (error) {
+    return error;
+  }
+  if (event === "error" || parsed.type === "response.failed") {
+    return removeUndefined({
+      code: contentToText(parsed.code) || void 0,
+      message: contentToText(parsed.message) || "Upstream streaming request failed.",
+      type: contentToText(parsed.type) || "upstream_stream_error"
+    });
+  }
+  return void 0;
 }
-function chatCompletionToResponse(completion, responseId) {
-  const id = responseId ?? `resp_${randomId()}`;
-  const choice = firstChoice(completion);
-  const message = asRecord(choice.message);
-  const model = contentToText(completion.model) || DEFAULT_MODEL;
-  const output = outputItemsFromMessage(message);
-  const usage = responseUsage(completion.usage);
-  return removeUndefined({
-    created_at: epochSeconds(),
+function processChatSseLine(line, handlers) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("data:")) {
+    return;
+  }
+  const data = trimmed.slice("data:".length).trim();
+  if (!data || data === "[DONE]") {
+    return;
+  }
+  const parsed = parseJson(data);
+  if (!parsed) {
+    return;
+  }
+  const choice = firstChoice(parsed);
+  const delta = asRecord(choice.delta);
+  const content = contentToText(delta.content);
+  if (content) {
+    handlers.appendText(content);
+  }
+  const toolCalls = Array.isArray(delta.tool_calls) ? delta.tool_calls : [];
+  for (const toolCall of toolCalls) {
+    handlers.appendToolCall(asRecord(toolCall));
+  }
+}
+function baseStreamResponse(id, model, createdAt, status, output) {
+  return {
+    created_at: createdAt,
     error: null,
     id,
     incomplete_details: null,
@@ -756,206 +910,106 @@ function chatCompletionToResponse(completion, responseId) {
     model,
     object: "response",
     output,
-    output_text: outputText(output),
     parallel_tool_calls: true,
-    status: "completed",
+    status,
     temperature: null,
     tool_choice: "auto",
-    tools: [],
-    top_p: null,
-    usage
-  });
-}
-function chatCompletionToCompletion(completion) {
-  return removeUndefined({
-    choices: completionChoices(completion).map((choice, index) => {
-      const message = asRecord(choice.message);
-      return {
-        finish_reason: choice.finish_reason ?? "stop",
-        index: typeof choice.index === "number" ? choice.index : index,
-        logprobs: choice.logprobs ?? null,
-        text: contentToText(choice.text) || contentToText(message.content)
-      };
-    }),
-    created: completion.created ?? epochSeconds(),
-    id: completion.id ?? `cmpl_${randomId()}`,
-    model: completion.model ?? DEFAULT_MODEL,
-    object: "text_completion",
-    system_fingerprint: completion.system_fingerprint,
-    usage: completion.usage
-  });
-}
-function completionStreamFromChatStream(chatStream) {
-  const encoder = new TextEncoder();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  let sawTerminalEvent = false;
-  return new ReadableStream({
-    async start(controller) {
-      const enqueue = (data) => {
-        controller.enqueue(encoder.encode(encodeDataSse(data)));
-      };
-      const markTerminal = () => {
-        sawTerminalEvent = true;
-      };
-      const reader = chatStream.getReader();
-      try {
-        while (true) {
-          const result = await reader.read();
-          if (result.done) {
-            break;
-          }
-          buffer += decoder.decode(result.value, { stream: true });
-          const blocks = buffer.split(/\r?\n\r?\n/);
-          buffer = blocks.pop() ?? "";
-          for (const block of blocks) {
-            processCompletionSseBlock(block, enqueue, markTerminal);
-          }
-        }
-        const tail = `${buffer}${decoder.decode()}`;
-        if (tail.trim()) {
-          processCompletionSseBlock(tail, enqueue, markTerminal);
-        }
-        if (!sawTerminalEvent) {
-          enqueue("[DONE]");
-        }
-        controller.close();
-      } catch (error) {
-        await reader.cancel(error).catch(() => {
-        });
-        controller.error(error);
-      } finally {
-        reader.releaseLock();
-      }
-    }
-  });
-}
-function normalizeModelsResponse(upstream) {
-  const record = asRecord(upstream);
-  const data = Array.isArray(record.data) ? record.data : Array.isArray(upstream) ? upstream : [];
-  const models = data.map((model) => asRecord(model)).filter((model) => typeof model.id === "string").map((model) => ({
-    created: model.created ?? 0,
-    id: model.id,
-    object: "model",
-    owned_by: model.owned_by ?? "github-copilot"
-  }));
-  return {
-    data: models.length > 0 ? models : fallbackModels(),
-    object: "list"
-  };
-}
-function fallbackModels() {
-  return [
-    {
-      created: 0,
-      id: DEFAULT_MODEL,
-      object: "model",
-      owned_by: "github-copilot"
-    }
-  ];
-}
-function responsesStreamFromChatStream(chatStream, options) {
-  const encoder = new TextEncoder();
-  const decoder = new TextDecoder();
-  const responseId = options.responseId ?? `resp_${randomId()}`;
-  const messageId = `msg_${randomId()}`;
-  const createdAt = epochSeconds();
-  let buffer = "";
-  let text = "";
-  let messageOutputIndex;
-  let nextOutputIndex = 0;
-  let sequenceNumber = 0;
-  const tools = /* @__PURE__ */ new Map();
-  return new ReadableStream({
-    async start(controller) {
-      const enqueue = (event, data) => {
-        controller.enqueue(
-          encoder.encode(
-            encodeSse(
-              event,
-              data === "[DONE]" ? data : { ...data, sequence_number: sequenceNumber++ }
-            )
-          )
-        );
-      };
-      enqueue("response.created", {
-        response: baseStreamResponse(responseId, options.model, createdAt, "in_progress", []),
-        type: "response.created"
-      });
-      const ensureMessageStarted = () => {
-        if (messageOutputIndex !== void 0) {
-          return;
-        }
-        messageOutputIndex = nextOutputIndex++;
-        enqueue("response.output_item.added", {
-          item: {
-            content: [],
-            id: messageId,
-            role: "assistant",
-            status: "in_progress",
-            type: "message"
-          },
-          output_index: messageOutputIndex,
-          type: "response.output_item.added"
-        });
-        enqueue("response.content_part.added", {
-          content_index: 0,
-          item_id: messageId,
-          output_index: messageOutputIndex,
-          part: {
-            annotations: [],
-            text: "",
-            type: "output_text"
-          },
-          type: "response.content_part.added"
-        });
-      };
-      const appendText = (delta) => {
-        ensureMessageStarted();
-        text += delta;
-        enqueue("response.output_text.delta", {
-          content_index: 0,
-          delta,
-          item_id: messageId,
-          output_index: messageOutputIndex ?? 0,
-          type: "response.output_text.delta"
-        });
-      };
-      const appendToolCall = (toolCall) => {
-        const fn = asRecord(toolCall.function);
-        const index = typeof toolCall.index === "number" ? toolCall.index : tools.size;
-        let existing = tools.get(index);
-        const isNew = !existing;
-        existing ??= {
-          arguments: "",
-          id: contentToText(toolCall.id) || `call_${randomId()}`,
-          index,
-          itemId: `fc_${randomId()}`,
-          name: "",
-          outputIndex: nextOutputIndex++
-        };
-        existing.id = contentToText(toolCall.id) || existing.id;
-        existing.name += contentToText(fn.name);
-        tools.set(index, existing);
-        if (isNew) {
-          enqueue("response.output_item.added", {
-            item: functionCallItem(existing, "in_progress"),
-            output_index: existing.outputIndex ?? 0,
-            type: "response.output_item.added"
-          });
-        }
-        const argumentDelta = contentToText(fn.arguments);
-        if (argumentDelta) {
-          existing.arguments += argumentDelta;
-          enqueue("response.function_call_arguments.delta", {
-            delta: argumentDelta,
-            item_id: existing.itemId,
-            output_index: existing.outputIndex ?? 0,
-            type: "response.function_call_arguments.delta"
-          });
-        }
+    tools: [],
+    top_p: null
+  };
+}
+function encodeSse(event, data) {
+  if (data === "[DONE]") {
+    return "data: [DONE]\n\n";
+  }
+  return `event: ${event}
+data: ${JSON.stringify(data)}
+
+`;
+}
+function encodeDataSse(data) {
+  if (data === "[DONE]") {
+    return "data: [DONE]\n\n";
+  }
+  return `data: ${JSON.stringify(data)}
+
+`;
+}
+function parseJson(data) {
+  try {
+    return asRecord(JSON.parse(data));
+  } catch {
+    return void 0;
+  }
+}
+function removeUndefined(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== void 0));
+}
+function randomId() {
+  return crypto.randomUUID().replaceAll("-", "");
+}
+function epochSeconds() {
+  return Math.floor(Date.now() / 1e3);
+}
+
+// src/anthropic.ts
+var AnthropicCompatibilityError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AnthropicCompatibilityError";
+  }
+};
+function anthropicMessagesToResponsesRequest(request) {
+  return removeUndefined2({
+    input: anthropicMessagesToResponsesInput(request.messages),
+    instructions: anthropicSystemToInstructions(request.system),
+    max_output_tokens: typeof request.max_tokens === "number" && Number.isFinite(request.max_tokens) ? request.max_tokens : void 0,
+    metadata: request.metadata,
+    model: normalizeRequestedModel(request.model),
+    parallel_tool_calls: true,
+    reasoning: anthropicThinkingToReasoning(request.thinking),
+    stop: anthropicStopSequences(request.stop_sequences),
+    stream: request.stream === true,
+    temperature: request.temperature,
+    tool_choice: anthropicToolChoice(request.tool_choice),
+    tools: anthropicTools(request.tools),
+    top_p: request.top_p
+  });
+}
+function responsesResponseToAnthropicMessage(response, fallbackModel) {
+  const content = anthropicContentFromResponsesOutput(response);
+  const usage = anthropicUsage(response.usage);
+  return {
+    content,
+    id: textValue(response.id) || `msg_${randomId2()}`,
+    model: textValue(response.model) || fallbackModel,
+    role: "assistant",
+    stop_reason: anthropicStopReason(response, content),
+    stop_sequence: null,
+    type: "message",
+    usage
+  };
+}
+function responsesStreamToAnthropicStream(stream, options) {
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  let buffer = "";
+  const state = {
+    blocks: /* @__PURE__ */ new Map(),
+    completed: false,
+    messageId: options.messageId ?? `msg_${randomId2()}`,
+    model: options.model,
+    nextBlockIndex: 0,
+    sawToolUse: false,
+    started: false,
+    usage: anthropicUsage(void 0)
+  };
+  return new ReadableStream({
+    async start(controller) {
+      const enqueue = (event, data) => {
+        controller.enqueue(encoder.encode(encodeSse2(event, data)));
       };
-      const reader = chatStream.getReader();
+      const reader = stream.getReader();
       try {
         while (true) {
           const result = await reader.read();
@@ -963,67 +1017,17 @@ function responsesStreamFromChatStream(chatStream, options) {
             break;
           }
           buffer += decoder.decode(result.value, { stream: true });
-          const lines = buffer.split(/\r?\n/);
-          buffer = lines.pop() ?? "";
-          for (const line of lines) {
-            processChatSseLine(line, { appendText, appendToolCall });
+          const blocks = buffer.split(/\r?\n\r?\n/);
+          buffer = blocks.pop() ?? "";
+          for (const block of blocks) {
+            processResponsesSseBlock(block, state, enqueue);
           }
         }
-        if (buffer) {
-          processChatSseLine(buffer, { appendText, appendToolCall });
-        }
-        const outputEntries = [];
-        if (messageOutputIndex !== void 0) {
-          const item = messageOutputItem(text, messageId);
-          outputEntries.push([messageOutputIndex, item]);
-          enqueue("response.output_text.done", {
-            content_index: 0,
-            item_id: messageId,
-            output_index: messageOutputIndex,
-            text,
-            type: "response.output_text.done"
-          });
-          enqueue("response.content_part.done", {
-            content_index: 0,
-            item_id: messageId,
-            output_index: messageOutputIndex,
-            part: {
-              annotations: [],
-              text,
-              type: "output_text"
-            },
-            type: "response.content_part.done"
-          });
-          enqueue("response.output_item.done", {
-            item,
-            output_index: messageOutputIndex,
-            type: "response.output_item.done"
-          });
-        }
-        for (const tool of [...tools.values()].sort(
-          (a, b) => (a.outputIndex ?? 0) - (b.outputIndex ?? 0)
-        )) {
-          const item = functionCallItem(tool);
-          const outputIndex = tool.outputIndex ?? 0;
-          outputEntries.push([outputIndex, item]);
-          enqueue("response.function_call_arguments.done", {
-            arguments: tool.arguments,
-            item_id: item.id,
-            output_index: outputIndex,
-            type: "response.function_call_arguments.done"
-          });
-          enqueue("response.output_item.done", {
-            item,
-            output_index: outputIndex,
-            type: "response.output_item.done"
-          });
+        const tail = `${buffer}${decoder.decode()}`;
+        if (tail.trim()) {
+          processResponsesSseBlock(tail, state, enqueue);
         }
-        const output = outputEntries.sort(([left], [right]) => left - right).map(([, item]) => item);
-        enqueue("response.completed", {
-          response: baseStreamResponse(responseId, options.model, createdAt, "completed", output),
-          type: "response.completed"
-        });
-        enqueue("done", "[DONE]");
+        finishAnthropicStream(state, enqueue);
         controller.close();
       } catch (error) {
         await reader.cancel(error).catch(() => {
@@ -1035,475 +1039,1129 @@ function responsesStreamFromChatStream(chatStream, options) {
     }
   });
 }
-function inputToMessages(input) {
-  if (typeof input === "string") {
-    return [{ content: input, role: "user" }];
+function estimateAnthropicMessageTokens(request) {
+  const chars = estimatedTextSize(request.system) + estimatedTextSize(request.messages) + estimatedTextSize(request.tools) + estimatedTextSize(request.tool_choice) + estimatedTextSize(request.thinking);
+  const messageCount = Array.isArray(request.messages) ? request.messages.length : 1;
+  const toolCount = Array.isArray(request.tools) ? request.tools.length : 0;
+  const inputTokens = Math.max(1, Math.ceil(chars / 4) + messageCount * 4 + toolCount * 16);
+  return {
+    input_tokens: inputTokens,
+    total_tokens: inputTokens
+  };
+}
+function anthropicMessagesToResponsesInput(messages) {
+  if (!Array.isArray(messages)) {
+    throw new AnthropicCompatibilityError("Anthropic Messages requests require messages[].");
+  }
+  const input = [];
+  for (const message of messages) {
+    const record = asRecord(message);
+    const role = anthropicRole(record.role);
+    const parts = anthropicContentParts(record.content);
+    const messageParts = [];
+    const flushMessage = () => {
+      if (messageParts.length === 0) {
+        return;
+      }
+      input.push({
+        content: [...messageParts],
+        role,
+        type: "message"
+      });
+      messageParts.length = 0;
+    };
+    for (const part of parts) {
+      const type = textValue(part.type) || "text";
+      if (type === "text") {
+        const text = textValue(part.text);
+        if (text) {
+          messageParts.push({
+            text,
+            type: role === "assistant" ? "output_text" : "input_text"
+          });
+        }
+        continue;
+      }
+      if (type === "image") {
+        if (role !== "user") {
+          throw new AnthropicCompatibilityError(
+            "Anthropic image content is only supported for user messages."
+          );
+        }
+        messageParts.push(anthropicImageToResponsesPart(part));
+        continue;
+      }
+      if (type === "tool_use") {
+        flushMessage();
+        input.push({
+          arguments: JSON.stringify(asRecord(part.input)),
+          call_id: textValue(part.id) || `call_${randomId2()}`,
+          name: textValue(part.name),
+          type: "function_call"
+        });
+        continue;
+      }
+      if (type === "tool_result") {
+        flushMessage();
+        input.push({
+          call_id: textValue(part.tool_use_id),
+          output: anthropicToolResultOutput(part.content),
+          type: "function_call_output"
+        });
+        continue;
+      }
+      if (type === "thinking" || type === "redacted_thinking") {
+        continue;
+      }
+      throw new AnthropicCompatibilityError(
+        `Anthropic content block type "${type}" is not supported.`
+      );
+    }
+    flushMessage();
   }
-  if (!Array.isArray(input)) {
+  return input;
+}
+function anthropicRole(value) {
+  const role = textValue(value);
+  if (role === "assistant" || role === "user") {
+    return role;
+  }
+  if (!role) {
+    return "user";
+  }
+  throw new AnthropicCompatibilityError(`Anthropic message role "${role}" is not supported.`);
+}
+function anthropicContentParts(content) {
+  if (typeof content === "string") {
+    return [{ text: content, type: "text" }];
+  }
+  if (Array.isArray(content)) {
+    return content.map(
+      (part) => typeof part === "string" ? { text: part, type: "text" } : asRecord(part)
+    );
+  }
+  if (content === void 0 || content === null) {
     return [];
   }
-  const messages = [];
-  for (const item of input) {
+  return [asRecord(content)];
+}
+function anthropicImageToResponsesPart(part) {
+  const source = asRecord(part.source);
+  const sourceType = textValue(source.type);
+  if (sourceType === "base64") {
+    const mediaType = textValue(source.media_type) || "image/png";
+    const data = textValue(source.data);
+    if (!data) {
+      throw new AnthropicCompatibilityError("Anthropic base64 image content requires source.data.");
+    }
+    return {
+      detail: "auto",
+      image_url: `data:${mediaType};base64,${data}`,
+      type: "input_image"
+    };
+  }
+  if (sourceType === "url") {
+    const url = textValue(source.url);
+    if (!url) {
+      throw new AnthropicCompatibilityError("Anthropic URL image content requires source.url.");
+    }
+    return {
+      detail: "auto",
+      image_url: url,
+      type: "input_image"
+    };
+  }
+  throw new AnthropicCompatibilityError(
+    `Anthropic image source type "${sourceType || "unknown"}" is not supported.`
+  );
+}
+function anthropicToolResultOutput(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    return content.map((part) => {
+      const record = asRecord(part);
+      return textValue(record.text) || textValue(record.content) || JSON.stringify(part);
+    }).filter(Boolean).join("\n");
+  }
+  if (content === void 0 || content === null) {
+    return "";
+  }
+  return typeof content === "object" ? JSON.stringify(content) : String(content);
+}
+function anthropicSystemToInstructions(system) {
+  if (typeof system === "string") {
+    return system || void 0;
+  }
+  if (!Array.isArray(system)) {
+    return void 0;
+  }
+  const text = system.map((part) => textValue(asRecord(part).text) || textValue(part)).filter(Boolean).join("\n");
+  return text || void 0;
+}
+function anthropicTools(tools) {
+  if (!Array.isArray(tools)) {
+    return void 0;
+  }
+  const converted = tools.map((tool) => {
+    const record = asRecord(tool);
+    return removeUndefined2({
+      description: record.description,
+      name: record.name,
+      parameters: record.input_schema,
+      strict: record.strict,
+      type: "function"
+    });
+  });
+  return converted.length > 0 ? converted : void 0;
+}
+function anthropicToolChoice(toolChoice) {
+  if (toolChoice === void 0 || toolChoice === null) {
+    return void 0;
+  }
+  const record = asRecord(toolChoice);
+  const type = textValue(record.type);
+  if (type === "auto") {
+    return "auto";
+  }
+  if (type === "any") {
+    return "required";
+  }
+  if (type === "none") {
+    return "none";
+  }
+  if (type === "tool") {
+    return { name: textValue(record.name), type: "function" };
+  }
+  throw new AnthropicCompatibilityError(
+    `Anthropic tool_choice type "${type || "unknown"}" is not supported.`
+  );
+}
+function anthropicThinkingToReasoning(thinking) {
+  const record = asRecord(thinking);
+  if (Object.keys(record).length === 0) {
+    return void 0;
+  }
+  const type = textValue(record.type);
+  if (type && type !== "enabled") {
+    return void 0;
+  }
+  const budget = typeof record.budget_tokens === "number" ? record.budget_tokens : 0;
+  return {
+    effort: budget >= 16e3 ? "high" : budget >= 4e3 ? "medium" : "low"
+  };
+}
+function anthropicStopSequences(stopSequences) {
+  if (!Array.isArray(stopSequences) || stopSequences.length === 0) {
+    return void 0;
+  }
+  return stopSequences.map((sequence) => textValue(sequence)).filter(Boolean);
+}
+function anthropicContentFromResponsesOutput(response) {
+  const content = [];
+  const output = Array.isArray(response.output) ? response.output : [];
+  for (const item of output) {
     const record = asRecord(item);
-    const type = contentToText(record.type);
-    if (type === "function_call_output") {
-      messages.push({
-        content: contentToText(record.output),
-        role: "tool",
-        tool_call_id: contentToText(record.call_id)
+    const type = textValue(record.type);
+    if (type === "message") {
+      const parts = Array.isArray(record.content) ? record.content : [];
+      for (const part of parts) {
+        const partRecord = asRecord(part);
+        const text = textValue(partRecord.text) || textValue(partRecord.output_text);
+        if (text) {
+          content.push({ text, type: "text" });
+        }
+      }
+      continue;
+    }
+    if (type === "function_call") {
+      content.push({
+        id: textValue(record.call_id) || textValue(record.id) || `call_${randomId2()}`,
+        input: parseToolInput(textValue(record.arguments)),
+        name: textValue(record.name),
+        type: "tool_use"
+      });
+    }
+  }
+  if (content.length === 0) {
+    const outputText2 = textValue(response.output_text);
+    if (outputText2) {
+      content.push({ text: outputText2, type: "text" });
+    }
+  }
+  return content;
+}
+function anthropicStopReason(response, content) {
+  if (content.some((part) => part.type === "tool_use")) {
+    return "tool_use";
+  }
+  const incompleteReason = textValue(asRecord(response.incomplete_details).reason);
+  if (textValue(response.status) === "incomplete" || incompleteReason === "max_output_tokens") {
+    return "max_tokens";
+  }
+  return "end_turn";
+}
+function anthropicUsage(usage) {
+  const record = asRecord(usage);
+  const inputTokens = firstNumber2(record.input_tokens, record.prompt_tokens) ?? 0;
+  const outputTokens = firstNumber2(record.output_tokens, record.completion_tokens) ?? 0;
+  const details = asRecord(record.input_tokens_details);
+  return removeUndefined2({
+    cache_creation_input_tokens: firstNumber2(record.cache_creation_input_tokens),
+    cache_read_input_tokens: firstNumber2(record.cache_read_input_tokens, details.cached_tokens) ?? void 0,
+    input_tokens: inputTokens,
+    output_tokens: outputTokens
+  });
+}
+function processResponsesSseBlock(block, state, enqueue) {
+  const { data, event } = parseSseBlock(block);
+  if (!data || data === "[DONE]") {
+    return;
+  }
+  const parsed = parseJsonObject(data);
+  if (!parsed) {
+    return;
+  }
+  const type = textValue(parsed.type) || event;
+  if (type === "response.created") {
+    const response = asRecord(parsed.response);
+    state.messageId = textValue(response.id) || state.messageId;
+    state.model = textValue(response.model) || state.model;
+    startAnthropicMessage(state, enqueue);
+    return;
+  }
+  if (type === "response.output_item.added") {
+    const item = asRecord(parsed.item);
+    if (textValue(item.type) === "function_call") {
+      ensureToolBlock(state, parsed, item, enqueue);
+    }
+    return;
+  }
+  if (type === "response.output_text.delta") {
+    const blockState = ensureTextBlock(state, parsed, enqueue);
+    const delta = textValue(parsed.delta);
+    if (delta) {
+      blockState.sentText += delta;
+      enqueue("content_block_delta", {
+        delta: { text: delta, type: "text_delta" },
+        index: blockState.index,
+        type: "content_block_delta"
+      });
+    }
+    return;
+  }
+  if (type === "response.output_text.done" || type === "response.content_part.done") {
+    const blockState = ensureTextBlock(state, parsed, enqueue);
+    const text = textValue(parsed.text) || textValue(asRecord(parsed.part).text);
+    if (text && !blockState.sentText) {
+      blockState.sentText = text;
+      enqueue("content_block_delta", {
+        delta: { text, type: "text_delta" },
+        index: blockState.index,
+        type: "content_block_delta"
       });
-      continue;
     }
-    if (type === "function_call") {
-      messages.push({
-        role: "assistant",
-        tool_calls: [
-          {
-            function: {
-              arguments: contentToText(record.arguments),
-              name: contentToText(record.name)
-            },
-            id: contentToText(record.call_id) || contentToText(record.id),
-            type: "function"
-          }
-        ]
+    stopBlock(blockState, enqueue);
+    return;
+  }
+  if (type === "response.function_call_arguments.delta") {
+    const blockState = ensureToolBlock(state, parsed, {}, enqueue);
+    const delta = textValue(parsed.delta);
+    if (delta) {
+      blockState.sentText += delta;
+      enqueue("content_block_delta", {
+        delta: { partial_json: delta, type: "input_json_delta" },
+        index: blockState.index,
+        type: "content_block_delta"
       });
-      continue;
     }
-    if (type && type !== "message") {
-      unsupportedResponsesFeature(`input item type "${type}"`);
+    return;
+  }
+  if (type === "response.function_call_arguments.done") {
+    const blockState = ensureToolBlock(state, parsed, {}, enqueue);
+    const args = textValue(parsed.arguments);
+    if (args && !blockState.sentText) {
+      blockState.sentText = args;
+      enqueue("content_block_delta", {
+        delta: { partial_json: args, type: "input_json_delta" },
+        index: blockState.index,
+        type: "content_block_delta"
+      });
     }
-    const role = responsesRoleToChatRole(contentToText(record.role));
-    const content = chatMessageContent(record.content);
-    if (role && content !== void 0) {
-      messages.push({ content, role });
+    stopBlock(blockState, enqueue);
+    return;
+  }
+  if (type === "response.output_item.done") {
+    const item = asRecord(parsed.item);
+    if (textValue(item.type) === "function_call") {
+      const blockState = ensureToolBlock(state, parsed, item, enqueue);
+      const args = textValue(item.arguments);
+      if (args && !blockState.sentText) {
+        blockState.sentText = args;
+        enqueue("content_block_delta", {
+          delta: { partial_json: args, type: "input_json_delta" },
+          index: blockState.index,
+          type: "content_block_delta"
+        });
+      }
+      stopBlock(blockState, enqueue);
     }
+    return;
+  }
+  if (type === "response.completed") {
+    const response = asRecord(parsed.response);
+    state.model = textValue(response.model) || state.model;
+    state.usage = anthropicUsage(response.usage);
+    finishAnthropicStream(state, enqueue);
+    return;
+  }
+  if (type === "response.failed" || event === "error") {
+    const error = asRecord(asRecord(parsed.response).error);
+    enqueue("error", {
+      error: {
+        message: textValue(error.message) || textValue(parsed.message) || "Upstream stream failed.",
+        type: textValue(error.type) || "api_error"
+      },
+      type: "error"
+    });
+    state.completed = true;
   }
-  return messages;
 }
-function chatMessageContent(content) {
-  if (typeof content === "string") {
-    return content;
+function startAnthropicMessage(state, enqueue) {
+  if (state.started) {
+    return;
   }
-  if (!Array.isArray(content)) {
-    if (content === void 0 || content === null) {
-      return void 0;
-    }
-    unsupportedResponsesFeature("non-array message content objects");
+  state.started = true;
+  enqueue("message_start", {
+    message: {
+      content: [],
+      id: state.messageId,
+      model: state.model,
+      role: "assistant",
+      stop_reason: null,
+      stop_sequence: null,
+      type: "message",
+      usage: anthropicUsage(void 0)
+    },
+    type: "message_start"
+  });
+}
+function finishAnthropicStream(state, enqueue) {
+  if (state.completed) {
+    return;
   }
-  const parts = [];
-  for (const part of content) {
-    const record = asRecord(part);
-    const type = contentToText(record.type);
-    if (type === "input_text" || type === "output_text" || type === "text") {
-      parts.push({ text: contentToText(record.text), type: "text" });
-      continue;
-    }
-    if (type === "input_image") {
-      if (contentToText(record.file_id)) {
-        unsupportedResponsesFeature("input_image file_id parts");
-      }
-      const imageUrl = contentToText(record.image_url);
-      if (!imageUrl) {
-        unsupportedResponsesFeature("input_image parts without image_url");
-      }
-      const image = { url: imageUrl };
-      const detail = contentToText(record.detail);
-      if (detail) {
-        image.detail = detail;
-      }
-      parts.push({ image_url: image, type: "image_url" });
-      continue;
-    }
-    if (type === "input_file") {
-      unsupportedResponsesFeature("input_file parts");
-    }
-    if (type === "input_audio") {
-      unsupportedResponsesFeature("input_audio parts");
+  startAnthropicMessage(state, enqueue);
+  for (const block of [...state.blocks.values()].sort((left, right) => left.index - right.index)) {
+    stopBlock(block, enqueue);
+  }
+  enqueue("message_delta", {
+    delta: {
+      stop_reason: state.sawToolUse ? "tool_use" : "end_turn",
+      stop_sequence: null
+    },
+    type: "message_delta",
+    usage: state.usage
+  });
+  enqueue("message_stop", { type: "message_stop" });
+  state.completed = true;
+}
+function ensureTextBlock(state, payload, enqueue) {
+  startAnthropicMessage(state, enqueue);
+  const key = `text:${indexValue(payload.output_index)}:${indexValue(payload.content_index)}`;
+  let block = state.blocks.get(key);
+  if (!block) {
+    block = { index: state.nextBlockIndex++, sentText: "", stopped: false, type: "text" };
+    state.blocks.set(key, block);
+    enqueue("content_block_start", {
+      content_block: { text: "", type: "text" },
+      index: block.index,
+      type: "content_block_start"
+    });
+  }
+  return block;
+}
+function ensureToolBlock(state, payload, item, enqueue) {
+  startAnthropicMessage(state, enqueue);
+  state.sawToolUse = true;
+  const key = `tool:${indexValue(payload.output_index)}`;
+  let block = state.blocks.get(key);
+  if (!block) {
+    block = { index: state.nextBlockIndex++, sentText: "", stopped: false, type: "tool_use" };
+    state.blocks.set(key, block);
+    enqueue("content_block_start", {
+      content_block: {
+        id: textValue(item.call_id) || textValue(item.id) || `call_${randomId2()}`,
+        input: {},
+        name: textValue(item.name),
+        type: "tool_use"
+      },
+      index: block.index,
+      type: "content_block_start"
+    });
+  }
+  return block;
+}
+function stopBlock(block, enqueue) {
+  if (block.stopped) {
+    return;
+  }
+  block.stopped = true;
+  enqueue("content_block_stop", {
+    index: block.index,
+    type: "content_block_stop"
+  });
+}
+function parseSseBlock(block) {
+  let event = "message";
+  const data = [];
+  for (const line of block.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("event:")) {
+      event = trimmed.slice("event:".length).trim() || event;
+    } else if (trimmed.startsWith("data:")) {
+      data.push(trimmed.slice("data:".length).trim());
     }
-    unsupportedResponsesFeature(`content part type "${type || "unknown"}"`);
   }
-  if (parts.length === 0) {
+  return { data: data.join("\n"), event };
+}
+function parseJsonObject(text) {
+  try {
+    return asRecord(JSON.parse(text));
+  } catch {
     return void 0;
   }
-  if (parts.every((part) => part.type === "text")) {
-    return parts.map((part) => contentToText(part.text)).join("\n");
+}
+function parseToolInput(argumentsText) {
+  const parsed = parseJsonObject(argumentsText);
+  return parsed ?? {};
+}
+function estimatedTextSize(value) {
+  if (value === void 0 || value === null) {
+    return 0;
   }
-  return parts;
+  if (typeof value === "string") {
+    return value.length;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value).length;
+  }
+  if (Array.isArray(value)) {
+    return value.reduce((sum, item) => sum + estimatedTextSize(item), 0);
+  }
+  if (typeof value === "object") {
+    return Object.values(value).reduce((sum, item) => sum + estimatedTextSize(item), 0);
+  }
+  return 0;
 }
-function legacyPromptToText(prompt) {
-  if (typeof prompt === "string") {
-    return prompt;
+function textValue(value) {
+  if (typeof value === "string") {
+    return value;
   }
-  if (Array.isArray(prompt) && prompt.length === 1 && typeof prompt[0] === "string") {
-    return prompt[0];
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
   }
-  throw new OpenAICompatibilityError(
-    "Hoopilot legacy completions compatibility supports exactly one string prompt per request."
-  );
+  return "";
 }
-function assertSupportedLegacyCompletionRequest(request) {
-  if (request.echo === true) {
-    throw new OpenAICompatibilityError(
-      "Hoopilot legacy completions compatibility does not support echo=true."
-    );
+function firstNumber2(...values) {
+  for (const value of values) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return value;
+    }
   }
-  if (typeof request.best_of === "number" && request.best_of > 1) {
-    throw new OpenAICompatibilityError(
-      "Hoopilot legacy completions compatibility does not support best_of greater than 1."
+  return void 0;
+}
+function indexValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function removeUndefined2(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== void 0));
+}
+function encodeSse2(event, data) {
+  return `event: ${event}
+data: ${JSON.stringify(data)}
+
+`;
+}
+function randomId2() {
+  return crypto.randomUUID().replaceAll("-", "");
+}
+
+// src/auth-store.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var StoredCopilotAuthError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "StoredCopilotAuthError";
+  }
+};
+function authStorePath(env = process.env) {
+  const explicit = envValue(env.HOOPILOT_AUTH_FILE);
+  if (explicit) {
+    return explicit;
+  }
+  const xdg = envValue(env.XDG_CONFIG_HOME);
+  if (xdg) {
+    return (0, import_node_path.join)(xdg, "hoopilot", "auth.json");
+  }
+  const appdata = envValue(env.APPDATA);
+  if (appdata) {
+    return (0, import_node_path.join)(appdata, "hoopilot", "auth.json");
+  }
+  const home = envValue(env.HOME);
+  if (!home) {
+    throw new StoredCopilotAuthError(
+      "Cannot resolve Hoopilot auth file path without HOOPILOT_AUTH_FILE, XDG_CONFIG_HOME, APPDATA, or HOME."
     );
   }
-  if (typeof request.logprobs === "number" && request.logprobs > 0) {
-    throw new OpenAICompatibilityError(
-      "Hoopilot legacy completions compatibility does not support legacy logprobs."
+  const base = (0, import_node_path.join)(home, ".config");
+  return (0, import_node_path.join)(base, "hoopilot", "auth.json");
+}
+function readStoredCopilotAuth(path = authStorePath()) {
+  let text;
+  try {
+    text = (0, import_node_fs.readFileSync)(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return void 0;
+    }
+    throw new StoredCopilotAuthError(`Could not read Hoopilot auth file at ${path}.`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    throw new StoredCopilotAuthError(
+      `Hoopilot auth file at ${path} is not valid JSON. Run \`hoopilot login\` to replace it.`
     );
   }
-  if (contentToText(request.suffix)) {
-    throw new OpenAICompatibilityError(
-      "Hoopilot legacy completions compatibility does not support suffix."
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new StoredCopilotAuthError(`Hoopilot auth file at ${path} must contain a JSON object.`);
+  }
+  const record = parsed;
+  const token = typeof record.token === "string" ? record.token.trim() : "";
+  if (!token) {
+    throw new StoredCopilotAuthError(`Hoopilot auth file at ${path} does not contain a token.`);
+  }
+  return {
+    apiBaseUrl: typeof record.apiBaseUrl === "string" ? record.apiBaseUrl : void 0,
+    createdAt: typeof record.createdAt === "string" ? record.createdAt : void 0,
+    githubDomain: typeof record.githubDomain === "string" ? record.githubDomain : void 0,
+    source: typeof record.source === "string" ? record.source : void 0,
+    token
+  };
+}
+function writeStoredCopilotAuth(auth, path = authStorePath()) {
+  (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(path), { recursive: true });
+  const data = `${JSON.stringify(
+    {
+      ...auth,
+      createdAt: auth.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+    },
+    null,
+    2
+  )}
+`;
+  const tmpPath = `${path}.${process.pid}.tmp`;
+  (0, import_node_fs.writeFileSync)(tmpPath, data, { mode: 384 });
+  (0, import_node_fs.renameSync)(tmpPath, path);
+  try {
+    (0, import_node_fs.chmodSync)(path, 384);
+  } catch {
+  }
+}
+
+// src/auth.ts
+var DEFAULT_COPILOT_API_BASE_URL = "https://api.githubcopilot.com";
+var REFRESH_SKEW_MS = 6e4;
+var STORED_TOKEN_TTL_MS = 10 * 6e4;
+var CopilotAuthError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CopilotAuthError";
+  }
+};
+var CopilotAuth = class {
+  #authStorePath;
+  #copilotApiBaseUrl;
+  #hasCopilotApiBaseUrlOverride;
+  #cachedAccess;
+  constructor(options = {}) {
+    const envAuthStorePath = envValue(options.env?.HOOPILOT_AUTH_FILE);
+    const envCopilotApiBaseUrl = envValue(options.env?.COPILOT_API_BASE_URL);
+    this.#authStorePath = options.authStorePath ?? envAuthStorePath;
+    this.#hasCopilotApiBaseUrlOverride = Boolean(options.copilotApiBaseUrl ?? envCopilotApiBaseUrl);
+    this.#copilotApiBaseUrl = trimTrailingSlash(
+      options.copilotApiBaseUrl ?? envCopilotApiBaseUrl ?? DEFAULT_COPILOT_API_BASE_URL
     );
   }
-}
-function contentToText(content) {
-  if (typeof content === "string") {
-    return content;
-  }
-  if (typeof content === "number" || typeof content === "boolean") {
-    return String(content);
-  }
-  if (Array.isArray(content)) {
-    return content.map((item) => contentToText(item)).filter(Boolean).join("\n");
-  }
-  if (content && typeof content === "object") {
-    const record = content;
-    if (typeof record.text === "string") {
-      return record.text;
+  async getAccess() {
+    if (this.#cachedAccess && this.#cachedAccess.expiresAtMs - REFRESH_SKEW_MS > Date.now()) {
+      return this.#cachedAccess;
     }
-    if (typeof record.output_text === "string") {
-      return record.output_text;
+    let stored;
+    try {
+      stored = readStoredCopilotAuth(this.#authStorePath);
+    } catch (error) {
+      if (error instanceof StoredCopilotAuthError) {
+        throw new CopilotAuthError(error.message);
+      }
+      throw error;
     }
-    return JSON.stringify(content);
-  }
-  return "";
-}
-function responsesRoleToChatRole(role) {
-  if (!role) {
-    return "user";
+    if (stored) {
+      return this.#cacheAccess({
+        apiBaseUrl: trimTrailingSlash(
+          this.#hasCopilotApiBaseUrlOverride ? this.#copilotApiBaseUrl : stored.apiBaseUrl ?? this.#copilotApiBaseUrl
+        ),
+        expiresAtMs: Date.now() + STORED_TOKEN_TTL_MS,
+        source: "github-copilot-oauth",
+        token: stored.token
+      });
+    }
+    throw new CopilotAuthError(
+      "No GitHub Copilot OAuth credential found. Run `hoopilot login` to sign in through your browser."
+    );
   }
-  if (role === "assistant" || role === "developer" || role === "system" || role === "tool" || role === "user") {
-    return role === "developer" ? "system" : role;
+  #cacheAccess(access) {
+    this.#cachedAccess = access;
+    return access;
   }
-  unsupportedResponsesFeature(`message role "${role}"`);
+};
+
+// src/copilot.ts
+var DEFAULT_GITHUB_API_BASE_URL = "https://api.github.com";
+var ALLOWED_COPILOT_API_HOSTS = ["api.githubcopilot.com"];
+var ALLOWED_GITHUB_API_HOSTS = ["api.github.com"];
+var COPILOT_USAGE_API_VERSION = "2025-04-01";
+function applyCopilotHeaders(headers, token) {
+  headers.set("accept", headers.get("accept") ?? "application/json");
+  headers.set("authorization", `Bearer ${token}`);
+  headers.set("copilot-integration-id", "vscode-chat");
+  headers.set("editor-plugin-version", "hoopilot/0.1.0");
+  headers.set("editor-version", "Hoopilot/0.1.0");
+  headers.set("openai-intent", "conversation-panel");
+  headers.set("user-agent", "hoopilot/0.1.0");
+  headers.set("x-github-api-version", "2026-06-01");
+  return headers;
 }
-function chatTools(tools) {
-  if (!Array.isArray(tools)) {
-    return void 0;
+function applyGithubApiHeaders(headers, token) {
+  headers.set("accept", headers.get("accept") ?? "application/json");
+  headers.set("authorization", `token ${token}`);
+  headers.set("editor-plugin-version", "hoopilot/0.1.0");
+  headers.set("editor-version", "Hoopilot/0.1.0");
+  headers.set("user-agent", "hoopilot/0.1.0");
+  headers.set("x-github-api-version", COPILOT_USAGE_API_VERSION);
+  return headers;
+}
+var CopilotClient = class {
+  #auth;
+  #allowUnsafeUpstream;
+  #fetch;
+  #githubApiBaseUrl;
+  constructor(options = {}) {
+    this.#auth = new CopilotAuth(options);
+    this.#allowUnsafeUpstream = envValue(options.env?.HOOPILOT_ALLOW_UNSAFE_UPSTREAM) === "1";
+    this.#fetch = options.fetch ?? fetch;
+    this.#githubApiBaseUrl = trimTrailingSlash(
+      options.githubApiBaseUrl ?? envValue(options.env?.HOOPILOT_GITHUB_API_BASE_URL) ?? DEFAULT_GITHUB_API_BASE_URL
+    );
   }
-  const converted = tools.map((tool) => {
-    const record = asRecord(tool);
-    const type = contentToText(record.type);
-    if (type !== "function") {
-      unsupportedResponsesFeature(`tool type "${type || "unknown"}"`);
+  /**
+   * Fetch the Copilot account's quota / premium-request usage from the GitHub
+   * REST `copilot_internal/user` endpoint. The stored device-flow OAuth token is
+   * accepted directly here — no Copilot token exchange is required to read quota.
+   */
+  async usage(signal) {
+    if (!isTrustedTokenBaseUrl(
+      this.#githubApiBaseUrl,
+      ALLOWED_GITHUB_API_HOSTS,
+      this.#allowUnsafeUpstream
+    )) {
+      throw new Error(
+        `Refusing to send the GitHub OAuth token to an untrusted GitHub API host: ${this.#githubApiBaseUrl}`
+      );
     }
-    return {
-      function: removeUndefined({
-        description: record.description,
-        name: record.name,
-        parameters: record.parameters,
-        strict: record.strict
-      }),
-      type: "function"
-    };
-  });
-  return converted.length > 0 ? converted : void 0;
-}
-function chatToolChoice(toolChoice) {
-  if (typeof toolChoice === "string" || toolChoice === void 0) {
-    return toolChoice;
+    const access = await this.#auth.getAccess();
+    const headers = applyGithubApiHeaders(new Headers(), access.token);
+    return this.#fetch(`${this.#githubApiBaseUrl}/copilot_internal/user`, {
+      headers,
+      method: "GET",
+      signal
+    });
   }
-  const record = asRecord(toolChoice);
-  const type = contentToText(record.type);
-  if (type === "function" && typeof record.name === "string") {
-    return { function: { name: record.name }, type: "function" };
+  async chatCompletions(body, signal) {
+    return this.fetchCopilot("/chat/completions", {
+      body: JSON.stringify(body),
+      headers: {
+        "content-type": "application/json"
+      },
+      method: "POST",
+      signal
+    });
   }
-  unsupportedResponsesFeature(`tool_choice type "${type || "unknown"}"`);
-}
-function unsupportedResponsesFeature(feature) {
-  throw new OpenAICompatibilityError(
-    `Hoopilot Responses-to-chat compatibility does not support ${feature}.`
-  );
-}
-function outputItemsFromMessage(message) {
-  const output = [];
-  const text = contentToText(message.content);
-  if (text) {
-    output.push(messageOutputItem(text));
+  async responses(body, signal) {
+    return this.fetchCopilot("/responses", {
+      body,
+      headers: {
+        "content-type": "application/json"
+      },
+      method: "POST",
+      signal
+    });
   }
-  const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
-  for (const toolCall of toolCalls) {
-    const record = asRecord(toolCall);
-    const fn = asRecord(record.function);
-    output.push(
-      functionCallItem({
-        arguments: contentToText(fn.arguments),
-        id: contentToText(record.id) || `call_${randomId()}`,
-        index: output.length,
-        name: contentToText(fn.name)
-      })
-    );
+  async models(signal) {
+    return this.fetchCopilot("/models", {
+      headers: {
+        accept: "application/json"
+      },
+      method: "GET",
+      signal
+    });
   }
-  return output;
-}
-function messageOutputItem(text, id = `msg_${randomId()}`) {
-  return {
-    content: [
-      {
-        annotations: [],
-        text,
-        type: "output_text"
-      }
-    ],
-    id,
-    role: "assistant",
-    status: "completed",
-    type: "message"
-  };
-}
-function functionCallItem(tool, status = "completed") {
-  return {
-    arguments: tool.arguments,
-    call_id: tool.id,
-    id: tool.itemId ?? `fc_${randomId()}`,
-    name: tool.name,
-    status,
-    type: "function_call"
-  };
-}
-function outputText(output) {
-  return output.flatMap((item) => {
-    const content = item.content;
-    return Array.isArray(content) ? content : [];
-  }).map((part) => contentToText(asRecord(part).text)).filter(Boolean).join("");
-}
-function responseUsage(usage) {
-  const record = asRecord(usage);
-  if (Object.keys(record).length === 0) {
-    return null;
+  async fetchCopilot(path, init) {
+    const access = await this.#auth.getAccess();
+    if (!isTrustedTokenBaseUrl(
+      access.apiBaseUrl,
+      ALLOWED_COPILOT_API_HOSTS,
+      this.#allowUnsafeUpstream
+    )) {
+      throw new Error(
+        `Refusing to send the GitHub OAuth token to an untrusted Copilot API host: ${access.apiBaseUrl}`
+      );
+    }
+    const headers = applyCopilotHeaders(new Headers(init.headers), access.token);
+    return this.#fetch(`${access.apiBaseUrl}${path}`, {
+      ...init,
+      headers
+    });
+  }
+};
+function normalizeCopilotUsage(body) {
+  const record = asRecord(body);
+  const quotas = {};
+  const snapshots = asRecord(record.quota_snapshots);
+  for (const [category, detail] of Object.entries(snapshots)) {
+    quotas[category] = normalizeQuotaDetail(asRecord(detail));
+  }
+  if (Object.keys(quotas).length === 0) {
+    const remaining = asRecord(record.limited_user_quotas);
+    const monthly = asRecord(record.monthly_quotas);
+    for (const category of /* @__PURE__ */ new Set([...Object.keys(remaining), ...Object.keys(monthly)])) {
+      const entitlement = numberOrUndefined(monthly[category]);
+      const left = numberOrUndefined(remaining[category]);
+      quotas[category] = removeUndefinedQuota({
+        entitlement,
+        percentRemaining: entitlement !== void 0 && entitlement > 0 && left !== void 0 ? left / entitlement * 100 : void 0,
+        remaining: left,
+        used: usedFrom(entitlement, left)
+      });
+    }
   }
-  const inputTokens = record.prompt_tokens;
-  const outputTokens = record.completion_tokens;
-  return removeUndefined({
-    input_tokens: inputTokens,
-    input_tokens_details: responseUsageDetails(record.prompt_tokens_details, inputTokens, {
-      cached_tokens: 0
-    }),
-    output_tokens: outputTokens,
-    output_tokens_details: responseUsageDetails(record.completion_tokens_details, outputTokens, {
-      reasoning_tokens: 0
-    }),
-    total_tokens: record.total_tokens
+  return removeUndefinedUsage({
+    accessTypeSku: stringOrUndefined(record.access_type_sku),
+    chatEnabled: typeof record.chat_enabled === "boolean" ? record.chat_enabled : void 0,
+    plan: stringOrUndefined(record.copilot_plan),
+    quotaResetDate: stringOrUndefined(record.quota_reset_date) ?? stringOrUndefined(record.quota_reset_date_utc) ?? stringOrUndefined(record.limited_user_reset_date),
+    quotas
   });
 }
-function responseUsageDetails(value, tokenCount, fallback) {
-  const record = asRecord(value);
-  if (Object.keys(record).length > 0) {
-    return record;
-  }
-  return typeof tokenCount === "number" && Number.isFinite(tokenCount) ? fallback : void 0;
+function normalizeQuotaDetail(detail) {
+  const entitlement = numberOrUndefined(detail.entitlement);
+  const overageCount = numberOrUndefined(detail.overage_count);
+  const remaining = numberOrUndefined(detail.remaining) ?? numberOrUndefined(detail.quota_remaining);
+  return removeUndefinedQuota({
+    entitlement,
+    hasQuota: typeof detail.has_quota === "boolean" ? detail.has_quota : void 0,
+    overageCount,
+    overageEntitlement: numberOrUndefined(detail.overage_entitlement),
+    overagePermitted: typeof detail.overage_permitted === "boolean" ? detail.overage_permitted : void 0,
+    percentRemaining: numberOrUndefined(detail.percent_remaining),
+    quotaId: stringOrUndefined(detail.quota_id),
+    quotaResetAt: stringOrUndefined(detail.quota_reset_at),
+    remaining,
+    timestampUtc: stringOrUndefined(detail.timestamp_utc),
+    tokenBasedBilling: typeof detail.token_based_billing === "boolean" ? detail.token_based_billing : void 0,
+    unlimited: typeof detail.unlimited === "boolean" ? detail.unlimited : void 0,
+    used: usedFrom(entitlement, remaining, overageCount)
+  });
 }
-function extractTokenUsage(usage) {
-  const record = asRecord(usage);
-  const prompt = firstNumber(record.prompt_tokens, record.input_tokens);
-  const completion = firstNumber(record.completion_tokens, record.output_tokens);
-  const total = firstNumber(record.total_tokens);
-  if (prompt === void 0 && completion === void 0 && total === void 0) {
+function usedFrom(entitlement, remaining, overageCount) {
+  if (entitlement === void 0 || remaining === void 0) {
     return void 0;
   }
-  const promptTokens = prompt ?? 0;
-  const completionTokens = completion ?? 0;
-  const reasoning = firstNumber(
-    asRecord(record.completion_tokens_details).reasoning_tokens,
-    asRecord(record.output_tokens_details).reasoning_tokens
-  );
-  const cached = firstNumber(
-    asRecord(record.prompt_tokens_details).cached_tokens,
-    asRecord(record.input_tokens_details).cached_tokens
-  );
-  return removeUndefined({
-    cachedTokens: cached,
-    completionTokens,
-    promptTokens,
-    reasoningTokens: reasoning,
-    totalTokens: total ?? promptTokens + completionTokens
-  });
+  const base = entitlement - remaining;
+  const overage = remaining === 0 ? overageCount ?? 0 : 0;
+  return Math.max(0, base + overage);
 }
-function firstNumber(...values) {
-  for (const value of values) {
-    if (typeof value === "number" && Number.isFinite(value)) {
-      return value;
-    }
-  }
-  return void 0;
+function numberOrUndefined(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
-function firstChoice(completion) {
-  return completionChoices(completion)[0] ?? {};
+function stringOrUndefined(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
 }
-function completionChoices(completion) {
-  const choices = Array.isArray(completion.choices) ? completion.choices : [];
-  return choices.map((choice) => asRecord(choice));
+function removeUndefinedQuota(quota) {
+  return Object.fromEntries(
+    Object.entries(quota).filter(([, value]) => value !== void 0)
+  );
 }
-function processCompletionSseBlock(block, enqueue, markTerminal) {
-  let event = "message";
-  const dataLines = [];
-  for (const line of block.split(/\r?\n/)) {
-    const trimmed = line.trim();
-    if (trimmed.startsWith("event:")) {
-      event = trimmed.slice("event:".length).trim() || event;
-    } else if (trimmed.startsWith("data:")) {
-      dataLines.push(trimmed.slice("data:".length).trim());
-    }
-  }
-  const data = dataLines.join("\n");
-  if (!data) {
-    return;
-  }
-  if (data === "[DONE]") {
-    markTerminal();
-    enqueue("[DONE]");
-    return;
-  }
-  const parsed = parseJson(data);
-  if (!parsed) {
-    return;
-  }
-  const error = completionStreamError(event, parsed);
-  if (error) {
-    markTerminal();
-    enqueue({ error });
-    return;
-  }
-  const choices = completionChoices(parsed).map((choice, index) => {
-    const delta = asRecord(choice.delta);
-    const text = contentToText(delta.content);
-    const finishReason = choice.finish_reason ?? null;
-    if (!text && finishReason === null) {
-      return void 0;
-    }
-    return {
-      finish_reason: finishReason,
-      index: typeof choice.index === "number" ? choice.index : index,
-      logprobs: choice.logprobs ?? null,
-      text
-    };
-  }).filter((choice) => choice !== void 0);
-  const usage = asRecord(parsed.usage);
-  const hasUsage = Object.keys(usage).length > 0;
-  if (choices.length === 0 && !hasUsage) {
-    return;
+function removeUndefinedUsage(usage) {
+  const entries = Object.entries(usage).filter(([, value]) => value !== void 0);
+  return Object.fromEntries(entries);
+}
+
+// src/github-device.ts
+var import_promises = require("timers/promises");
+var DEFAULT_GITHUB_COPILOT_CLIENT_ID = "Ov23li8tweQw6odWQebz";
+var DEFAULT_GITHUB_DOMAIN = "github.com";
+var DEVICE_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:device_code";
+var POLLING_SAFETY_MARGIN_MS = 3e3;
+var REQUEST_TIMEOUT_MS = 15e3;
+async function githubCopilotDeviceLogin(options = {}) {
+  const env = options.env ?? process.env;
+  const fetcher = options.fetch ?? fetch;
+  const sleeper = options.sleep ?? import_promises.setTimeout;
+  const domain = normalizeDomain(
+    options.domain ?? envValue(env.HOOPILOT_GITHUB_DOMAIN) ?? DEFAULT_GITHUB_DOMAIN
+  );
+  const clientId = options.clientId ?? envValue(env.HOOPILOT_GITHUB_CLIENT_ID) ?? envValue(env.COPILOT_GITHUB_CLIENT_ID) ?? DEFAULT_GITHUB_COPILOT_CLIENT_ID;
+  const device = await requestDeviceCode(fetcher, domain, clientId);
+  const verificationUrl = device.verification_uri;
+  const userCode = device.user_code;
+  const deviceCode = device.device_code;
+  if (!verificationUrl || !userCode || !deviceCode) {
+    throw new Error("GitHub device authorization response is missing required fields.");
   }
-  enqueue(
-    removeUndefined({
-      choices,
-      created: typeof parsed.created === "number" ? parsed.created : epochSeconds(),
-      id: contentToText(parsed.id) || `cmpl_${randomId()}`,
-      model: contentToText(parsed.model) || DEFAULT_MODEL,
-      object: "text_completion",
-      usage: hasUsage ? usage : void 0
+  options.logger?.info(`First copy your one-time code: ${userCode}`);
+  options.logger?.info(`Open ${verificationUrl} in your browser to authorize Hoopilot.`);
+  await options.openBrowser?.(verificationUrl);
+  return {
+    domain,
+    token: await pollForAccessToken(fetcher, sleeper, domain, clientId, {
+      deviceCode,
+      expiresIn: positiveSeconds(device.expires_in, 900),
+      interval: positiveSeconds(device.interval, 5)
     })
-  );
+  };
 }
-function completionStreamError(event, parsed) {
-  const responseError = asRecord(asRecord(parsed.response).error);
-  const directError = asRecord(parsed.error);
-  const error = Object.keys(directError).length > 0 ? directError : Object.keys(responseError).length > 0 ? responseError : void 0;
-  if (error) {
-    return error;
+async function requestDeviceCode(fetcher, domain, clientId) {
+  const response = await fetcher(`https://${domain}/login/device/code`, {
+    body: JSON.stringify({
+      client_id: clientId,
+      scope: "read:user"
+    }),
+    headers: oauthHeaders(),
+    method: "POST",
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+  });
+  if (!response.ok) {
+    throw new Error(
+      `GitHub device authorization failed with ${response.status}: ${await truncatedResponseText(
+        response
+      )}`
+    );
   }
-  if (event === "error" || parsed.type === "response.failed") {
-    return removeUndefined({
-      code: contentToText(parsed.code) || void 0,
-      message: contentToText(parsed.message) || "Upstream streaming request failed.",
-      type: contentToText(parsed.type) || "upstream_stream_error"
+  return parseJsonResponse(
+    response,
+    "GitHub device authorization response was not valid JSON"
+  );
+}
+async function pollForAccessToken(fetcher, sleeper, domain, clientId, device) {
+  let intervalMs = device.interval * 1e3 + POLLING_SAFETY_MARGIN_MS;
+  const deadline = Date.now() + device.expiresIn * 1e3;
+  while (Date.now() < deadline) {
+    await sleeper(intervalMs);
+    const response = await fetcher(`https://${domain}/login/oauth/access_token`, {
+      body: JSON.stringify({
+        client_id: clientId,
+        device_code: device.deviceCode,
+        grant_type: DEVICE_GRANT_TYPE
+      }),
+      headers: oauthHeaders(),
+      method: "POST",
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
     });
+    if (!response.ok) {
+      throw new Error(
+        `GitHub device token exchange failed with ${response.status}: ${await truncatedResponseText(
+          response
+        )}`
+      );
+    }
+    const data = await parseJsonResponse(
+      response,
+      "GitHub device token response was not valid JSON"
+    );
+    if (data.access_token) {
+      return data.access_token;
+    }
+    if (data.error === "authorization_pending") {
+      continue;
+    }
+    if (data.error === "slow_down") {
+      intervalMs = positiveSeconds(data.interval, device.interval + 5) * 1e3 + POLLING_SAFETY_MARGIN_MS;
+      continue;
+    }
+    if (data.error === "expired_token") {
+      throw new Error("GitHub device login expired. Run `hoopilot login` again.");
+    }
+    if (data.error === "access_denied") {
+      throw new Error("GitHub device login was cancelled.");
+    }
+    if (data.error) {
+      throw new Error(data.error_description || `GitHub device login failed: ${data.error}`);
+    }
   }
-  return void 0;
+  throw new Error("GitHub device login timed out. Run `hoopilot login` again.");
 }
-function processChatSseLine(line, handlers) {
-  const trimmed = line.trim();
-  if (!trimmed.startsWith("data:")) {
-    return;
-  }
-  const data = trimmed.slice("data:".length).trim();
-  if (!data || data === "[DONE]") {
-    return;
-  }
-  const parsed = parseJson(data);
-  if (!parsed) {
-    return;
-  }
-  const choice = firstChoice(parsed);
-  const delta = asRecord(choice.delta);
-  const content = contentToText(delta.content);
-  if (content) {
-    handlers.appendText(content);
+function oauthHeaders() {
+  const headers = new Headers();
+  headers.set("accept", "application/json");
+  headers.set("content-type", "application/json");
+  headers.set("user-agent", "hoopilot");
+  return headers;
+}
+function normalizeDomain(value) {
+  const raw = value.trim();
+  const withScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(raw) ? raw : `https://${raw}`;
+  let url;
+  try {
+    url = new URL(withScheme);
+  } catch {
+    throw new Error(`Invalid GitHub domain: ${value}.`);
   }
-  const toolCalls = Array.isArray(delta.tool_calls) ? delta.tool_calls : [];
-  for (const toolCall of toolCalls) {
-    handlers.appendToolCall(asRecord(toolCall));
+  if (url.protocol !== "https:" && url.protocol !== "http:" || url.username || url.password || !url.hostname || url.pathname !== "" && url.pathname !== "/" || url.search || url.hash) {
+    throw new Error(`Invalid GitHub domain: ${value}. Provide only a hostname.`);
   }
+  return url.host;
 }
-function baseStreamResponse(id, model, createdAt, status, output) {
-  return {
-    created_at: createdAt,
-    error: null,
-    id,
-    incomplete_details: null,
-    instructions: null,
-    max_output_tokens: null,
-    metadata: {},
-    model,
-    object: "response",
-    output,
-    parallel_tool_calls: true,
-    status,
-    temperature: null,
-    tool_choice: "auto",
-    tools: [],
-    top_p: null
-  };
+function positiveSeconds(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
 }
-function encodeSse(event, data) {
-  if (data === "[DONE]") {
-    return "data: [DONE]\n\n";
+async function parseJsonResponse(response, context) {
+  const text = await response.text();
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error(`${context}: ${text.slice(0, 500)}`);
   }
-  return `event: ${event}
-data: ${JSON.stringify(data)}
+}
 
-`;
+// src/logger.ts
+var import_pino = __toESM(require("pino"), 1);
+var import_pino_pretty = __toESM(require("pino-pretty"), 1);
+var DEFAULT_LOG_FORMAT = "pretty";
+var DEFAULT_LOG_LEVEL = "info";
+var LOG_FORMATS = ["json", "pretty"];
+var LOG_LEVELS = ["trace", "debug", "info", "warn", "error", "fatal", "silent"];
+var REDACT_PATHS = [
+  "apiKey",
+  "authorization",
+  "cookie",
+  "headers.authorization",
+  "headers.Authorization",
+  "headers.cookie",
+  "headers.Cookie",
+  "headers.x-api-key",
+  "headers.X-Api-Key",
+  "token",
+  "*.apiKey",
+  "*.authorization",
+  "*.cookie",
+  "*.token",
+  "*.headers.authorization",
+  "*.headers.Authorization",
+  "*.headers.cookie",
+  "*.headers.Cookie",
+  "*.headers.x-api-key",
+  "*.headers.X-Api-Key"
+];
+var noopLogger = {
+  child: () => noopLogger,
+  debug: () => {
+  },
+  error: () => {
+  },
+  fatal: () => {
+  },
+  info: () => {
+  },
+  trace: () => {
+  },
+  warn: () => {
+  }
+};
+function createHoopilotLogger(options = {}) {
+  const env = options.env ?? process.env;
+  const level = parseLogLevel(options.level ?? envValue(env.HOOPILOT_LOG_LEVEL));
+  const format = parseLogFormat(options.format ?? envValue(env.HOOPILOT_LOG_FORMAT));
+  const pinoOptions = {
+    base: {
+      service: "hoopilot",
+      ...options.base
+    },
+    level,
+    redact: {
+      censor: "[Redacted]",
+      paths: REDACT_PATHS
+    },
+    timestamp: import_pino.default.stdTimeFunctions.isoTime
+  };
+  if (format === "pretty") {
+    return (0, import_pino.default)(
+      pinoOptions,
+      (0, import_pino_pretty.default)({
+        colorize: options.colorize ?? process.stderr.isTTY,
+        destination: options.stream ?? 1,
+        ignore: "pid,hostname",
+        singleLine: true,
+        translateTime: "SYS:standard"
+      })
+    );
+  }
+  if (options.stream) {
+    return (0, import_pino.default)(pinoOptions, options.stream);
+  }
+  return (0, import_pino.default)(pinoOptions);
 }
-function encodeDataSse(data) {
-  if (data === "[DONE]") {
-    return "data: [DONE]\n\n";
+function parseLogFormat(value) {
+  if (!value) {
+    return DEFAULT_LOG_FORMAT;
   }
-  return `data: ${JSON.stringify(data)}
-
-`;
+  if (isLogFormat(value)) {
+    return value;
+  }
+  throw new Error(`Invalid log format: ${value}. Expected one of: ${LOG_FORMATS.join(", ")}.`);
 }
-function parseJson(data) {
-  try {
-    return asRecord(JSON.parse(data));
-  } catch {
-    return void 0;
+function parseLogLevel(value) {
+  if (!value) {
+    return DEFAULT_LOG_LEVEL;
+  }
+  if (isLogLevel(value)) {
+    return value;
   }
+  throw new Error(`Invalid log level: ${value}. Expected one of: ${LOG_LEVELS.join(", ")}.`);
 }
-function removeUndefined(record) {
-  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== void 0));
+function shouldCreateLogger(options) {
+  return Boolean(
+    options.logger || options.logFormat || options.logLevel || envValue(options.env?.HOOPILOT_LOG_FORMAT) || envValue(options.env?.HOOPILOT_LOG_LEVEL)
+  );
 }
-function randomId() {
-  return crypto.randomUUID().replaceAll("-", "");
+function errorDetails(error) {
+  if (error instanceof Error) {
+    return {
+      message: error.message,
+      name: error.name,
+      stack: error.stack
+    };
+  }
+  return { message: String(error) };
 }
-function epochSeconds() {
-  return Math.floor(Date.now() / 1e3);
+function isLogFormat(value) {
+  return LOG_FORMATS.includes(value);
+}
+function isLogLevel(value) {
+  return LOG_LEVELS.includes(value);
 }
 
 // src/metrics.ts
@@ -1712,11 +2370,43 @@ var MetricsRegistry = class {
     gauge("remaining", "Remaining quota for the Copilot category.", (q) => q.remaining);
     gauge("entitlement", "Quota entitlement for the Copilot category.", (q) => q.entitlement);
     gauge("used", "Used quota (entitlement minus remaining) for the category.", (q) => q.used);
+    gauge("overage_count", "Overage count for the Copilot category.", (q) => q.overageCount);
+    gauge(
+      "overage_entitlement",
+      "Overage entitlement for the Copilot category.",
+      (q) => q.overageEntitlement
+    );
     gauge(
       "percent_remaining",
       "Percent of quota remaining for the Copilot category.",
       (q) => q.percentRemaining
     );
+    booleanGauge(
+      "unlimited",
+      "Whether the Copilot quota category is unlimited.",
+      (q) => q.unlimited
+    );
+    booleanGauge(
+      "overage_permitted",
+      "Whether overage is permitted for the Copilot category.",
+      (q) => q.overagePermitted
+    );
+    booleanGauge("has_quota", "Whether the Copilot quota category has a quota.", (q) => q.hasQuota);
+    booleanGauge(
+      "token_based_billing",
+      "Whether the Copilot quota category uses token-based billing.",
+      (q) => q.tokenBasedBilling
+    );
+    dateGauge(
+      "category_reset_timestamp_seconds",
+      "Unix epoch of the Copilot category-specific quota reset.",
+      (q) => q.quotaResetAt
+    );
+    dateGauge(
+      "category_snapshot_timestamp_seconds",
+      "Unix epoch of the Copilot category quota snapshot.",
+      (q) => q.timestampUtc
+    );
     const resetMs = usage.quotaResetDate ? Date.parse(usage.quotaResetDate) : Number.NaN;
     if (Number.isFinite(resetMs)) {
       lines.push(
@@ -1735,6 +2425,30 @@ var MetricsRegistry = class {
         })} 1`
       );
     }
+    function booleanGauge(suffix, help, pick) {
+      const present = categories.filter(([, quota]) => pick(quota) !== void 0);
+      if (present.length === 0) {
+        return;
+      }
+      lines.push(`# HELP hoopilot_copilot_quota_${suffix} ${help}`);
+      lines.push(`# TYPE hoopilot_copilot_quota_${suffix} gauge`);
+      for (const [category, quota] of present) {
+        lines.push(
+          `hoopilot_copilot_quota_${suffix}${labels({ category })} ${pick(quota) ? 1 : 0}`
+        );
+      }
+    }
+    function dateGauge(suffix, help, pick) {
+      const present = categories.map(([category, quota]) => [category, Date.parse(pick(quota) ?? "")]).filter(([, timestamp]) => Number.isFinite(timestamp));
+      if (present.length === 0) {
+        return;
+      }
+      lines.push(`# HELP hoopilot_copilot_quota_${suffix} ${help}`);
+      lines.push(`# TYPE hoopilot_copilot_quota_${suffix} gauge`);
+      for (const [category, timestamp] of present) {
+        lines.push(`hoopilot_copilot_quota_${suffix}${labels({ category })} ${timestamp / 1e3}`);
+      }
+    }
   }
 };
 function observeResponseUsage(response, fallbackModel, onUsage, signal) {
@@ -1877,6 +2591,7 @@ var DEFAULT_HOST = "127.0.0.1";
 var DEFAULT_PORT = 4141;
 var FORBIDDEN_BROWSER_ORIGIN_MESSAGE = "Browser-origin requests require HOOPILOT_API_KEY unless the Origin is loopback.";
 var INVALID_JSON_MESSAGE = "Request body must be valid JSON.";
+var JSON_OBJECT_MESSAGE = "Request body must be a JSON object.";
 var MAX_REQUEST_BODY_BYTES = 16 * 1024 * 1024;
 var REQUEST_ID_PATTERN = /^[A-Za-z0-9._:-]{1,128}$/;
 var REQUEST_TOO_LARGE_MESSAGE = `Request body must be ${MAX_REQUEST_BODY_BYTES} bytes or smaller.`;
@@ -1946,6 +2661,14 @@ function createHoopilotHandler(options = {}) {
       if (request.method === "GET" && apiPath === "/v1/models") {
         return finish(await handleModels(client, metrics, request.signal, requestLogger));
       }
+      if (request.method === "POST" && apiPath === "/v1/messages") {
+        return finish(
+          await handleAnthropicMessages(client, metrics, recordTokens, request, requestLogger)
+        );
+      }
+      if (request.method === "POST" && apiPath === "/v1/messages/count_tokens") {
+        return finish(handleAnthropicCountTokens(await readJson(request)));
+      }
       if (request.method === "POST" && apiPath === "/v1/chat/completions") {
         return finish(
           await handleChatCompletions(client, metrics, recordTokens, request, requestLogger)
@@ -1969,16 +2692,16 @@ function createHoopilotHandler(options = {}) {
         return finish(jsonError(401, "copilot_auth_error", error.message));
       }
       const message = errorMessage(error);
-      if (message === INVALID_JSON_MESSAGE) {
+      if (message === INVALID_JSON_MESSAGE || message === JSON_OBJECT_MESSAGE) {
         requestLogger.warn(
           { err: errorDetails(error), event: "http.request.failed" },
-          "request body was invalid json"
+          "request body was not usable json"
         );
         return finish(jsonError(400, "invalid_request_error", message));
-      } else if (error instanceof OpenAICompatibilityError) {
+      } else if (error instanceof OpenAICompatibilityError || error instanceof AnthropicCompatibilityError) {
         requestLogger.warn(
           { err: errorDetails(error), event: "http.request.failed" },
-          "request body used unsupported OpenAI compatibility fields"
+          "request body used unsupported compatibility fields"
         );
         return finish(jsonError(400, "invalid_request_error", message));
       } else if (error instanceof RequestBodyTooLargeError) {
@@ -2022,6 +2745,40 @@ function startHoopilotServer(options = {}) {
     url: `http://${urlHost(host)}:${server.port}`
   };
 }
+async function handleAnthropicMessages(client, metrics, recordTokens, request, logger) {
+  const anthropicRequest = await readJson(request);
+  const responsesRequest = anthropicMessagesToResponsesRequest(anthropicRequest);
+  const upstream = await client.responses(JSON.stringify(responsesRequest), request.signal);
+  metrics.recordUpstream("/responses", upstream.ok);
+  if (!upstream.ok) {
+    return proxyError(upstream, logger);
+  }
+  logUpstreamSuccess(logger, "/responses", upstream.status);
+  const model = normalizeRequestedModel(responsesRequest.model);
+  if (isStreamingResponse(upstream) && upstream.body) {
+    const observed = observeResponseUsage(upstream, model, recordTokens, request.signal);
+    if (!observed.body) {
+      return proxyResponse(observed);
+    }
+    return proxyResponse(
+      new Response(responsesStreamToAnthropicStream(observed.body, { model }), {
+        headers: observed.headers,
+        status: observed.status,
+        statusText: observed.statusText
+      })
+    );
+  }
+  const body = asRecord(await upstream.json());
+  const usage = extractTokenUsage(body.usage);
+  if (usage) {
+    const responseModel = typeof body.model === "string" ? body.model.trim() : "";
+    recordTokens(responseModel || model, usage);
+  }
+  return jsonResponse(responsesResponseToAnthropicMessage(body, model));
+}
+function handleAnthropicCountTokens(body) {
+  return jsonResponse(estimateAnthropicMessageTokens(body));
+}
 async function handleModels(client, metrics, signal, logger) {
   const upstream = await client.models(signal);
   metrics.recordUpstream("/models", upstream.ok);
@@ -2129,20 +2886,24 @@ function proxyResponse(upstream) {
 }
 async function readJson(request) {
   const text = await readRequestText(request);
+  return parseJsonObject2(text);
+}
+function parseJsonObject2(text) {
+  let parsed;
   try {
-    return asRecord(JSON.parse(text));
+    parsed = JSON.parse(text);
   } catch {
     throw new Error(INVALID_JSON_MESSAGE);
   }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(JSON_OBJECT_MESSAGE);
+  }
+  return parsed;
 }
 async function readJsonText(request) {
   const text = await readRequestText(request);
-  try {
-    JSON.parse(text);
-    return text;
-  } catch {
-    throw new Error(INVALID_JSON_MESSAGE);
-  }
+  parseJsonObject2(text);
+  return text;
 }
 async function readRequestText(request) {
   const contentLength = request.headers.get("content-length");
@@ -2217,9 +2978,10 @@ function websocketUnsupportedResponse() {
 }
 function corsHeaders() {
   return {
-    "access-control-allow-headers": "authorization, content-type, x-api-key",
+    "access-control-allow-headers": "anthropic-beta, anthropic-dangerous-direct-browser-access, anthropic-version, authorization, content-type, x-api-key, x-request-id",
     "access-control-allow-methods": "GET, POST, OPTIONS",
-    "access-control-allow-origin": "*"
+    "access-control-allow-origin": "*",
+    "access-control-expose-headers": "x-request-id"
   };
 }
 function isAuthorized(request, apiKey) {
@@ -2371,6 +3133,10 @@ function canonicalApiPath(path) {
       return "/v1/chat/completions";
     case "/completions":
       return "/v1/completions";
+    case "/messages":
+      return "/v1/messages";
+    case "/messages/count_tokens":
+      return "/v1/messages/count_tokens";
     case "/responses":
       return "/v1/responses";
     case "/usage":
@@ -2395,6 +3161,12 @@ function routeFor(method, path) {
   if (method === "GET" && path === "/v1/models") {
     return "models";
   }
+  if (method === "POST" && path === "/v1/messages") {
+    return "anthropic_messages";
+  }
+  if (method === "POST" && path === "/v1/messages/count_tokens") {
+    return "anthropic_count_tokens";
+  }
   if (method === "POST" && path === "/v1/chat/completions") {
     return "chat_completions";
   }
@@ -2432,8 +3204,8 @@ function metricsResponse(metrics) {
   });
 }
 async function handleUsage(metrics, readUsage, signal) {
-  const proxy = metrics.snapshot();
   const { copilot, error } = await readUsage(signal);
+  const proxy = metrics.snapshot();
   const body = { copilot: copilot ?? null, object: "usage", proxy };
   if (error) {
     body.copilot_error = error;
@@ -2458,10 +3230,10 @@ function createUsageReader(client, metrics, now = Date.now, ttlMs = USAGE_CACHE_
       metrics.recordCopilotQuota(value);
       return { copilot: value };
     } catch (error) {
-      metrics.recordUpstream(usagePath, false);
       if (error instanceof CopilotAuthError) {
         return { error: error.message };
       }
+      metrics.recordUpstream(usagePath, false);
       return { error: errorMessage(error) };
     }
   };
@@ -2475,6 +3247,7 @@ function safeParseJson(text) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AnthropicCompatibilityError,
   COPILOT_USAGE_API_VERSION,
   CopilotAuth,
   CopilotAuthError,
@@ -2485,6 +3258,7 @@ function safeParseJson(text) {
   DEFAULT_MODEL,
   MetricsRegistry,
   PROMETHEUS_CONTENT_TYPE,
+  anthropicMessagesToResponsesRequest,
   applyCopilotHeaders,
   applyGithubApiHeaders,
   authStorePath,
@@ -2494,6 +3268,7 @@ function safeParseJson(text) {
   completionsRequestToChatCompletion,
   createHoopilotHandler,
   createHoopilotLogger,
+  estimateAnthropicMessageTokens,
   extractTokenUsage,
   fallbackModels,
   githubCopilotDeviceLogin,
@@ -2507,7 +3282,9 @@ function safeParseJson(text) {
   parseLogLevel,
   readStoredCopilotAuth,
   responsesRequestToChatCompletion,
+  responsesResponseToAnthropicMessage,
   responsesStreamFromChatStream,
+  responsesStreamToAnthropicStream,
   startHoopilotServer,
   writeStoredCopilotAuth
 });