@openhoo/hoopilot 0.7.5 → 0.8.0

package/dist/cli.js

@@ -447,7 +447,18 @@ function oauthHeaders() {
   return headers;
 }
 function normalizeDomain(value) {
-  return value.replace(/^https?:\/\//, "").replace(/\/+$/, "");
+  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}.`);
+  }
+  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 positiveSeconds(value, fallback) {
   return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
@@ -897,6 +908,641 @@ 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(encodeSse(event, data)));
+      };
+      const reader = stream.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) {
+            processResponsesSseBlock(block, state, enqueue);
+          }
+        }
+        const tail = `${buffer}${decoder.decode()}`;
+        if (tail.trim()) {
+          processResponsesSseBlock(tail, state, enqueue);
+        }
+        finishAnthropicStream(state, enqueue);
+        controller.close();
+      } catch (error) {
+        await reader.cancel(error).catch(() => {
+        });
+        controller.error(error);
+      } finally {
+        reader.releaseLock();
+      }
+    }
+  });
+}
+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();
+  }
+  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 [];
+  }
+  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 = 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 outputText = textValue(response.output_text);
+    if (outputText) {
+      content.push({ text: outputText, 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"
+      });
+    }
+    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"
+      });
+    }
+    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"
+      });
+    }
+    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;
+  }
+}
+function startAnthropicMessage(state, enqueue) {
+  if (state.started) {
+    return;
+  }
+  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;
+  }
+  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());
+    }
+  }
+  return { data: data.join("\n"), event };
+}
+function parseJsonObject(text) {
+  try {
+    return asRecord(JSON.parse(text));
+  } catch {
+    return void 0;
+  }
+}
+function parseToolInput(argumentsText) {
+  const parsed = parseJsonObject(argumentsText);
+  return parsed ?? {};
+}
+function estimatedTextSize(value) {
+  if (value === void 0 || value === null) {
+    return 0;
+  }
+  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 textValue(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  return "";
+}
+function firstNumber2(...values) {
+  for (const value of values) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return value;
+    }
+  }
+  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 encodeSse(event, data) {
+  return `event: ${event}
+data: ${JSON.stringify(data)}
+
+`;
+}
+function randomId2() {
+  return crypto.randomUUID().replaceAll("-", "");
+}
+
 // src/metrics.ts
 var PROMETHEUS_CONTENT_TYPE = "text/plain; version=0.0.4; charset=utf-8";
 var DURATION_BUCKETS_SECONDS = [0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10, 30, 60];
@@ -1324,6 +1970,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.`;
@@ -1393,6 +2040,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)
@@ -1416,16 +2071,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) {
@@ -1469,6 +2124,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);
@@ -1576,20 +2265,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");
@@ -1664,9 +2357,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) {
@@ -1818,6 +2512,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":
@@ -1842,6 +2540,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";
   }
@@ -2514,8 +3218,7 @@ async function main2(argv = Bun.argv.slice(2)) {
   const command = argv[0];
   if (command === "update" || command === "upgrade") {
     const args2 = withRuntimeEnv(parseArgs(argv.slice(1)));
-    if (args2.help) {
-      console.log(helpText(await getVersion()));
+    if (await printMetaOption(args2)) {
       return;
     }
     const logger2 = commandLogger(args2, command);
@@ -2528,8 +3231,7 @@ async function main2(argv = Bun.argv.slice(2)) {
   }
   if (command === "login") {
     const args2 = withRuntimeEnv(parseArgs(argv.slice(1)));
-    if (args2.help) {
-      console.log(helpText(await getVersion()));
+    if (await printMetaOption(args2)) {
       return;
     }
     args2.logger = commandLogger(args2, "login");
@@ -2538,8 +3240,7 @@ async function main2(argv = Bun.argv.slice(2)) {
   }
   if (command === "models") {
     const args2 = withRuntimeEnv(parseArgs(argv.slice(1)));
-    if (args2.help) {
-      console.log(helpText(await getVersion()));
+    if (await printMetaOption(args2)) {
       return;
     }
     args2.logger = commandLogger(args2, "models");
@@ -2548,8 +3249,7 @@ async function main2(argv = Bun.argv.slice(2)) {
   }
   if (command === "usage") {
     const args2 = withRuntimeEnv(parseArgs(argv.slice(1)));
-    if (args2.help) {
-      console.log(helpText(await getVersion()));
+    if (await printMetaOption(args2)) {
       return;
     }
     args2.logger = commandLogger(args2, "usage");
@@ -2557,12 +3257,7 @@ async function main2(argv = Bun.argv.slice(2)) {
     return;
   }
   const args = withRuntimeEnv(parseArgs(argv));
-  if (args.help) {
-    console.log(helpText(await getVersion()));
-    return;
-  }
-  if (args.version) {
-    console.log(await getVersion());
+  if (await printMetaOption(args)) {
     return;
   }
   const logger = commandLogger(args, "serve");
@@ -2584,6 +3279,17 @@ async function main2(argv = Bun.argv.slice(2)) {
     );
   }
 }
+async function printMetaOption(args) {
+  if (args.help) {
+    console.log(helpText(await getVersion()));
+    return true;
+  }
+  if (args.version) {
+    console.log(await getVersion());
+    return true;
+  }
+  return false;
+}
 function parseArgs(argv) {
   const args = {};
   const rest = [...argv];