@codeproxy/cli 0.1.0

package/README.md

@@ -0,0 +1,124 @@
+# @codeproxy/cli
+
+> **中文版** → [README.zh-CN.md](./README.zh-CN.md)
+
+**@codeproxy/cli** is a local proxy server that converts **any** Chat Completions or Anthropic Messages API into the **OpenAI Responses API** format. It lets Codex, Claude Code, or any Responses-API client use models from DeepSeek, GLM, Kimi, and more.
+
+Built on [@codeproxy/core](https://github.com/codeproxy-ai/core).
+
+## Quick Start
+
+```bash
+npx @codeproxy/cli --upstream-format openai-chat \
+  --base-url https://api.deepseek.com/v1 \
+  --apikey sk-your-key
+```
+
+Point your Responses-API client at `http://127.0.0.1:8787`:
+
+```bash
+curl -N http://127.0.0.1:8787/v1/responses \
+  -H 'content-type: application/json' \
+  -H "authorization: Bearer $API_KEY" \
+  -d '{"model":"deepseek-v4-pro","input":"Hello!","stream":true}'
+```
+
+
+### With config file
+
+```bash
+npx @codeproxy/cli --config config.json
+```
+
+See [config.example.json](./config.example.json) for a full example.
+
+#### Top-level fields
+
+| Field | Type | Description |
+|---|---|---|
+| `version` | `string` | Config format version (currently `"1.0"`) |
+| `currentUpstream` | `string` | Name of the upstream to use (must match a key in `upstreams`) |
+| `headers` | `object` | Default headers applied to **all** upstreams (merged with per-upstream headers; per-upstream wins) |
+| `reasoningEffort` | `string` | Default reasoning effort for all upstreams: `"low"`, `"medium"`, `"high"`, `"xhigh"` |
+| `thinking` | `object` `|` `null` | Default thinking config for all upstreams. Anthropic format: `{"type": "enabled", "budget_tokens": 16384}`. Set to `null` to disable |
+| `timeoutMs` | `number` | Default upstream request timeout in milliseconds |
+
+#### Per-upstream fields
+
+| Field | Type | Description |
+|---|---|---|
+| `format` | `"anthropic"` `|` `"openai-chat"` | Upstream API format. If omitted, inferred from `baseUrl` (path ending in `/messages` \u2192 `anthropic`, `/chat/completions` \u2192 `openai-chat`, otherwise falls back to `openai-chat`). The proper path suffix is appended automatically |
+| `baseUrl` | `string` | **Required.** Upstream endpoint URL |
+| `apiKey` | `string` | Upstream API key. Sent as `Authorization: Bearer <key>` (Anthropic: rewritten to `x-api-key`) |
+| `model` | `string` | Override the `model` field in all incoming requests |
+| `apiVersion` | `string` | Override `anthropic-version` header (Anthropic only) |
+| `headers` | `object` | Extra HTTP headers for this upstream. Merged on top of top-level `headers`, per-upstream wins |
+| `timeoutMs` | `number` | Request timeout for this upstream (overrides top-level `timeoutMs`) |
+| `dropImages` | `boolean` | When `true`, strip image/file parts from user messages (for text-only models). Use with `fallback` to auto-route image requests to a vision-capable upstream |
+| `fallback` | `string` | Name of another upstream to route to when `dropImages: true` and the request contains images |
+| `reasoningEffort` | `string` | Per-upstream reasoning effort override (`"low"`, `"medium"`, `"high"`, `"xhigh"`). Overrides top-level value |
+| `thinking` | `object` `|` `null` | Per-upstream thinking config. Overrides top-level value. Set to `null` to disable |
+
+#### Precedence
+
+```
+CLI flags > per-upstream fields > top-level fields > built-in defaults
+```
+
+#### Example: auto-fallback for text-only models
+
+When `deepseek` has `dropImages: true` and the user sends an image, the proxy
+automatically routes to `deepseek-vision` (which supports vision):
+
+```json
+{
+  "currentUpstream": "deepseek",
+  "upstreams": {
+    "deepseek": {
+      "baseUrl": "https://api.deepseek.com/v1",
+      "model": "deepseek-v4-pro",
+      "dropImages": true,
+      "fallback": "deepseek-vision"
+    },
+    "deepseek-vision": {
+      "baseUrl": "https://api.deepseek.com/v1",
+      "model": "deepseek-v4-vision"
+    }
+  }
+}
+```
+## Install
+
+```bash
+npm install -g @codeproxy/cli
+```
+
+## CLI Options
+
+| Flag | Default | Description |
+|---|---|---|
+| `--base-url <url>` | — | Upstream endpoint (required unless `--config`) |
+| `--upstream-format <fmt>` | inferred | `anthropic` or `openai-chat` |
+| `--config <file>` | — | JSON config file |
+| `--host <host>` | `127.0.0.1` | Bind host |
+| `-p, --port <port>` | `8787` | Bind port |
+| `--api-version <ver>` | `2023-06-01` | Override Anthropic version header |
+| `--apikey <key>` | — | Upstream API key |
+| `--model <name>` | — | Override model for all requests |
+| `--drop-images` | — | Strip images (text-only models) |
+
+## Programmatic usage
+
+```ts
+import { createResponsesFetch, startProxy } from '@codeproxy/cli';
+
+const proxy = await startProxy({
+  upstreamFormat: 'openai-chat',
+  baseUrl: 'https://api.deepseek.com/v1',
+  defaultHeaders: { authorization: 'Bearer sk-...' },
+});
+```
+
+## License
+
+MIT

package/README.zh-CN.md

@@ -0,0 +1,123 @@
+# @codeproxy/cli
+
+> **English** → [README.md](./README.md)
+
+**@codeproxy/cli** 是一个本地代理服务器，将**任何** Chat Completions 或 Anthropic Messages API **转换为 OpenAI Responses API 格式**。让 Codex、Claude Code 等 Responses-API 客户端能使用 DeepSeek、GLM、Kimi 等任意模型。
+
+基于 [@codeproxy/core](https://github.com/codeproxy-ai/core) 构建。
+
+## 快速开始
+
+```bash
+npx @codeproxy/cli --upstream-format openai-chat \
+  --base-url https://api.deepseek.com/v1 \
+  --apikey sk-your-key
+```
+
+将你的 Responses-API 客户端指向 `http://127.0.0.1:8787`：
+
+```bash
+curl -N http://127.0.0.1:8787/v1/responses \
+  -H 'content-type: application/json' \
+  -H "authorization: Bearer $API_KEY" \
+  -d '{"model":"deepseek-v4-pro","input":"Hello!","stream":true}'
+```
+
+
+### 使用配置文件
+
+```bash
+npx @codeproxy/cli --config config.json
+```
+
+完整的配置示例见 [config.example.json](./config.example.json)。
+
+#### 顶层字段
+
+| 字段 | 类型 | 说明 |
+|---|---|---|
+| `version` | `string` | 配置格式版本（当前为 `"1.0"`） |
+| `currentUpstream` | `string` | 当前使用的上游名称（必须是 `upstreams` 中的某个 key） |
+| `headers` | `object` | 应用到**所有**上游的默认请求头（与各上游的 headers 合并，上游级别优先） |
+| `reasoningEffort` | `string` | 所有上游的默认推理力度：`"low"`、`"medium"`、`"high"`、`"xhigh"` |
+| `thinking` | `object` `|` `null` | 所有上游的默认 thinking 配置。Anthropic 格式：`{"type": "enabled", "budget_tokens": 16384}`。设为 `null` 禁用 |
+| `timeoutMs` | `number` | 默认上游请求超时时间（毫秒） |
+
+#### 每个上游的字段
+
+| 字段 | 类型 | 说明 |
+|---|---|---|
+| `format` | `"anthropic"` `|` `"openai-chat"` | 上游 API 格式。省略时从 `baseUrl` 推断（路径结尾是 `/messages` \u2192 `anthropic`，`/chat/completions` \u2192 `openai-chat`，否则回退到 `openai-chat`）。路径后缀会自动补全 |
+| `baseUrl` | `string` | **必需。** 上游端点 URL |
+| `apiKey` | `string` | 上游 API 密钥。作为 `Authorization: Bearer <key>` 发送（Anthropic 会转为 `x-api-key`） |
+| `model` | `string` | 覆盖所有传入请求中的 `model` 字段 |
+| `apiVersion` | `string` | 覆盖 `anthropic-version` 请求头（仅 Anthropic） |
+| `headers` | `object` | 该上游的额外 HTTP 请求头。合并到顶层 `headers` 之上，上游级别优先 |
+| `timeoutMs` | `number` | 该上游的请求超时（覆盖顶层 `timeoutMs`） |
+| `dropImages` | `boolean` | 设为 `true` 时，从用户消息中移除图片/文件部分（用于纯文本模型）。配合 `fallback` 使用，含图片的请求会自动路由到支持视觉的上游 |
+| `fallback` | `string` | 另一个上游的名称。当当前上游设了 `dropImages: true` 且请求包含图片时，自动切换到该上游 |
+| `reasoningEffort` | `string` | 该上游的推理力度覆盖（`"low"`、`"medium"`、`"high"`、`"xhigh"`）。覆盖顶层值 |
+| `thinking` | `object` `|` `null` | 该上游的 thinking 配置。覆盖顶层值。设为 `null` 禁用 |
+
+#### 优先级
+
+```
+CLI 标志 > 每个上游的字段 > 顶层字段 > 内置默认值
+```
+
+#### 示例：纯文本模型的自动回退
+
+当 `deepseek` 设了 `dropImages: true` 且用户发送图片时，代理自动路由到 `deepseek-vision`（支持视觉）：
+
+```json
+{
+  "currentUpstream": "deepseek",
+  "upstreams": {
+    "deepseek": {
+      "baseUrl": "https://api.deepseek.com/v1",
+      "model": "deepseek-v4-pro",
+      "dropImages": true,
+      "fallback": "deepseek-vision"
+    },
+    "deepseek-vision": {
+      "baseUrl": "https://api.deepseek.com/v1",
+      "model": "deepseek-v4-vision"
+    }
+  }
+}
+```
+## 安装
+
+```bash
+npm install -g @codeproxy/cli
+```
+
+## CLI 选项
+
+| 参数 | 默认值 | 说明 |
+|---|---|---|
+| `--base-url <url>` | — | 上游端点（除非使用 `--config`，否则必需） |
+| `--upstream-format <fmt>` | 自动推断 | `anthropic` 或 `openai-chat` |
+| `--config <file>` | — | JSON 配置文件 |
+| `--host <host>` | `127.0.0.1` | 绑定地址 |
+| `-p, --port <port>` | `8787` | 绑定端口 |
+| `--api-version <ver>` | `2023-06-01` | 覆盖 Anthropic 版本头 |
+| `--apikey <key>` | — | 上游 API 密钥 |
+| `--model <name>` | — | 为所有请求覆盖模型 |
+| `--drop-images` | — | 移除图片部分（纯文本模型） |
+
+## 编程使用
+
+```ts
+import { createResponsesFetch, startProxy } from '@codeproxy/cli';
+
+const proxy = await startProxy({
+  upstreamFormat: 'openai-chat',
+  baseUrl: 'https://api.deepseek.com/v1',
+  defaultHeaders: { authorization: 'Bearer sk-...' },
+});
+```
+
+## 协议
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,431 @@
+'use strict';
+
+var core = require('@codeproxy/core');
+var http = require('http');
+var stream = require('stream');
+var fs = require('fs');
+var path = require('path');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var http__default = /*#__PURE__*/_interopDefault(http);
+
+// src/index.ts
+function fmtTime(date) {
+  return date.toLocaleTimeString("en-US", { hour12: false });
+}
+function fmtDuration(ms) {
+  if (ms < 1e3) {
+    return `${Math.round(ms)}ms`;
+  }
+  if (ms < 6e4) {
+    return `${(ms / 1e3).toFixed(1)}s`;
+  }
+  const minutes = Math.floor(ms / 6e4);
+  const seconds = Math.round(ms % 6e4 / 1e3);
+  return `${minutes}:${String(seconds).padStart(2, "0")}`;
+}
+async function startProxy(options) {
+  const host = options.host ?? "127.0.0.1";
+  const port = options.port ?? 8787;
+  const cors = options.cors ?? true;
+  const logger = options.logger === null ? null : options.logger ?? console;
+  const durationHistory = [];
+  function updateRollingAverage(ms) {
+    durationHistory.push(ms);
+    if (durationHistory.length > 50) {
+      durationHistory.shift();
+    }
+    return durationHistory.reduce((sum, val) => sum + val, 0) / durationHistory.length;
+  }
+  const activeRequests = /* @__PURE__ */ new Map();
+  let statusTimerId = null;
+  function drawStatusLine() {
+    if (activeRequests.size === 0) {
+      return;
+    }
+    const parts = Array.from(activeRequests.entries()).map(([, req]) => {
+      const elapsed = Date.now() - req.startTime;
+      return `[${fmtDuration(elapsed)}]`;
+    });
+    process.stdout.write(`\r\x1B[K\u23F3 ${parts.join(", ")}`);
+  }
+  const requestTracker = {
+    add(method, url) {
+      const id = `${Date.now()}:${Math.random().toString(36).slice(2, 8)}`;
+      activeRequests.set(id, { method, url, startTime: Date.now() });
+      drawStatusLine();
+      if (!statusTimerId) {
+        statusTimerId = setInterval(drawStatusLine, 150);
+      }
+      return id;
+    },
+    remove(id) {
+      activeRequests.delete(id);
+      if (activeRequests.size === 0) {
+        process.stdout.write("\r\x1B[K");
+        if (statusTimerId) {
+          clearInterval(statusTimerId);
+          statusTimerId = null;
+        }
+      }
+    }
+  };
+  const requestInfo = { method: "", url: "", startTime: 0, resultLog: "" };
+  const upstreamCapture = {};
+  const baseFetch = options.fetch ?? globalThis.fetch;
+  const capturingFetch = async (input, init) => {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+    const method = (init?.method ?? input?.method ?? "GET").toUpperCase();
+    const reqHeaders = headersInitToObject(init?.headers);
+    let reqBody = void 0;
+    if (init?.body != null) {
+      if (typeof init.body === "string") {
+        reqBody = tryParseJson(init.body);
+      } else if (init.body instanceof ArrayBuffer) {
+        reqBody = tryParseJson(new TextDecoder().decode(init.body));
+      } else if (ArrayBuffer.isView(init.body)) {
+        reqBody = tryParseJson(new TextDecoder().decode(init.body));
+      } else {
+        reqBody = String(init.body);
+      }
+    }
+    upstreamCapture.request = { url, method, headers: reqHeaders, body: reqBody };
+    const resp = await baseFetch(input, init);
+    if (!resp.ok) {
+      const clone = resp.clone();
+      const text = await clone.text().catch(() => "");
+      upstreamCapture.response = {
+        status: resp.status,
+        statusText: resp.statusText,
+        headers: headersToObject(resp.headers),
+        body: tryParseJson(text)
+      };
+    } else {
+      upstreamCapture.response = void 0;
+    }
+    return resp;
+  };
+  const apiFetch = core.createResponsesFetch({
+    upstreamFormat: options.upstreamFormat,
+    baseUrl: options.baseUrl,
+    apiVersion: options.apiVersion,
+    model: options.model,
+    defaultHeaders: options.defaultHeaders,
+    timeoutMs: options.timeoutMs,
+    dropImages: options.dropImages,
+    fallbackUpstream: options.fallbackUpstream,
+    fetch: capturingFetch,
+    passthroughFetch: async () => new Response(JSON.stringify({ error: { message: "Not found" } }), {
+      status: 404,
+      headers: { "content-type": "application/json" }
+    }),
+    onCacheStats: (stats) => {
+      const durationMs = requestInfo.startTime ? Date.now() - requestInfo.startTime : 0;
+      const billedTokens = stats.inputTokens + stats.outputTokens - stats.cachedTokens;
+      const parts = [
+        `total=${stats.totalTokens}`,
+        `input=${stats.inputTokens}`,
+        `output=${stats.outputTokens}`,
+        `cached=${stats.cachedTokens}`,
+        `billed=${billedTokens}`
+      ];
+      if (stats.cacheCreationTokens > 0) {
+        parts.push(`cache_creation=${stats.cacheCreationTokens}`);
+      }
+      const avg = updateRollingAverage(durationMs);
+      const ratio = avg > 0 ? durationMs / avg : 1;
+      const color = ratio < 0.8 ? "\x1B[32m" : ratio < 1.5 ? "\x1B[33m" : "\x1B[31m";
+      const reset = "\x1B[0m";
+      const logMsg = `[${fmtTime(/* @__PURE__ */ new Date())}] -> 200 (${color}${fmtDuration(durationMs)}${reset} avg=${fmtDuration(Math.round(avg))}) [${parts.join(", ")}]`;
+      requestInfo.resultLog = stats.cachedTokens < 1024 && billedTokens > 0 ? `\u26A0\uFE0F NO CACHE -- ${logMsg}` : logMsg;
+      if (options.onCacheStats) {
+        options.onCacheStats({
+          ...stats,
+          method: requestInfo.method || void 0,
+          url: requestInfo.url || void 0,
+          durationMs: durationMs || void 0
+        });
+      }
+    }
+  });
+  const server = http__default.default.createServer(async (req, res) => {
+    const start = Date.now();
+    requestInfo.method = req.method ?? "POST";
+    requestInfo.url = req.url ?? "/v1/responses";
+    requestInfo.startTime = start;
+    const timeoutMs = options.timeoutMs;
+    let timeoutTimer;
+    if (timeoutMs && timeoutMs > 0) {
+      timeoutTimer = setTimeout(() => {
+        logger?.warn(`[timeout] request exceeded ${timeoutMs}ms, aborting`);
+        res.destroy();
+        req.destroy();
+      }, timeoutMs);
+    }
+    try {
+      await handleRequest(req, res, {
+        apiFetch,
+        cors,
+        logger,
+        method: req.method ?? "POST",
+        url: req.url ?? "/",
+        upstreamCapture,
+        requestInfo,
+        requestTracker
+      });
+    } catch (err) {
+      logger?.error("[proxy-error]", err);
+      try {
+        if (!res.headersSent) {
+          res.writeHead(500, { "content-type": "application/json" });
+          res.end(JSON.stringify({ error: { message: "Internal server error" } }));
+        }
+      } catch {
+      }
+    } finally {
+      if (timeoutTimer) {
+        clearTimeout(timeoutTimer);
+      }
+    }
+  });
+  return new Promise((resolve2, reject) => {
+    server.listen(port, host, () => {
+      const actualPort = (() => {
+        const addr = server.address();
+        return addr.port;
+      })();
+      const url = `http://${host}:${actualPort}`;
+      logger?.log(`Proxy listening on ${url}`);
+      logger?.log(`Upstream format: ${options.upstreamFormat}`);
+      logger?.log(`Upstream URL: ${options.baseUrl}`);
+      resolve2({
+        host,
+        port: actualPort,
+        url,
+        server,
+        close: () => new Promise((res) => {
+          server.close((err) => {
+            if (err) {
+              logger?.warn("Error closing server:", err);
+            }
+            res();
+          });
+        })
+      });
+    });
+    server.once("error", reject);
+  });
+}
+async function handleRequest(req, res, opts) {
+  if (opts.cors) {
+    setCorsHeaders(res);
+  }
+  if (req.method === "OPTIONS") {
+    res.writeHead(204);
+    res.end();
+    return;
+  }
+  const method = req.method ?? "GET";
+  const urlPath = req.url ?? "/";
+  const headers = flattenIncomingHeaders(req.headers);
+  let body;
+  if (method !== "GET" && method !== "HEAD") {
+    body = await readIncomingBody(req);
+  }
+  if (!/^\/v1\/responses\/?(?:\?|$)/.test(urlPath)) {
+    res.writeHead(404, { "content-type": "application/json" });
+    res.end(JSON.stringify({ error: { message: `Not found: ${method} ${urlPath}` } }));
+    return;
+  }
+  const requestBodyText = body ? body.toString("utf8") : void 0;
+  const requestStart = Date.now();
+  const requestId = opts.requestTracker.add(method, urlPath);
+  try {
+    const response = await opts.apiFetch(`http://local${urlPath}`, {
+      method,
+      headers,
+      body: body ? new Uint8Array(body) : void 0
+    });
+    const responseBodyText = response.body ? await response.clone().text() : "";
+    opts.requestTracker.remove(requestId);
+    if (opts.logger) {
+      if (response.status >= 400) {
+        process.stdout.write(
+          `\r\x1B[K<-- ${response.status}  (${fmtDuration(Date.now() - requestStart)})
+`
+        );
+      } else if (opts.requestInfo.resultLog) {
+        process.stdout.write(`\r\x1B[K${opts.requestInfo.resultLog}
+`);
+      } else {
+        process.stdout.write(
+          `\r\x1B[K<-- ${response.status}  (${fmtDuration(Date.now() - requestStart)})
+`
+        );
+      }
+    }
+    if (response.status >= 400) {
+      try {
+        const filePath = saveErrorDump({
+          method: opts.method,
+          url: opts.url,
+          clientRequest: {
+            headers,
+            body: tryParseJson(requestBodyText ?? "")
+          },
+          upstreamRequest: opts.upstreamCapture.request,
+          upstreamResponse: opts.upstreamCapture.response,
+          proxyResponse: {
+            status: response.status,
+            headers: headersToObject(response.headers),
+            body: tryParseJson(responseBodyText)
+          }
+        });
+        opts.logger?.error(`[proxy-failure] full exchange saved to ${filePath}`);
+      } catch (dumpErr) {
+        opts.logger?.error("[proxy-failure] failed to persist error dump", dumpErr);
+      }
+    }
+    const outHeaders = {};
+    response.headers.forEach((value, key) => {
+      outHeaders[key] = value;
+    });
+    if (opts.cors) {
+      Object.assign(outHeaders, corsHeaders());
+    }
+    res.writeHead(response.status, outHeaders);
+    if (!response.body) {
+      res.end();
+      return;
+    }
+    const typedBody = response.body;
+    const nodeStream = stream.Readable.fromWeb(typedBody);
+    nodeStream.pipe(res);
+    await new Promise((resolve2, reject) => {
+      nodeStream.once("end", resolve2);
+      nodeStream.once("error", reject);
+      res.once("close", resolve2);
+    });
+  } catch (err) {
+    opts.requestTracker.remove(requestId);
+    throw err;
+  }
+}
+function readIncomingBody(req) {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => {
+      const buf = chunk;
+      chunks.push(buf);
+    });
+    req.on("end", () => resolve2(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}
+function flattenIncomingHeaders(headers) {
+  const out = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (value == null) {
+      continue;
+    }
+    out[key.toLowerCase()] = Array.isArray(value) ? value.join(", ") : String(value);
+  }
+  return out;
+}
+function headersToObject(headers) {
+  const out = {};
+  headers.forEach((value, key) => {
+    out[key] = value;
+  });
+  return out;
+}
+function setCorsHeaders(res) {
+  const headers = corsHeaders();
+  for (const [key, value] of Object.entries(headers)) {
+    res.setHeader(key, value);
+  }
+}
+function corsHeaders() {
+  return {
+    "access-control-allow-origin": "*",
+    "access-control-allow-methods": "GET,POST,OPTIONS",
+    "access-control-allow-headers": "authorization,content-type,x-api-key,anthropic-version,anthropic-beta,anthropic-dangerous-direct-browser-access",
+    "access-control-expose-headers": "content-type"
+  };
+}
+function tryParseJson(str) {
+  if (!str) {
+    return str ?? null;
+  }
+  try {
+    return JSON.parse(str);
+  } catch {
+    return str;
+  }
+}
+function headersInitToObject(headersInit) {
+  const out = {};
+  if (!headersInit) {
+    return out;
+  }
+  if (typeof Headers !== "undefined" && headersInit instanceof Headers) {
+    headersInit.forEach((value, key) => {
+      out[key.toLowerCase()] = value;
+    });
+    return out;
+  }
+  if (Array.isArray(headersInit)) {
+    for (const [key, value] of headersInit) {
+      out[String(key).toLowerCase()] = String(value);
+    }
+    return out;
+  }
+  for (const [key, value] of Object.entries(headersInit)) {
+    out[key.toLowerCase()] = String(value);
+  }
+  return out;
+}
+function saveErrorDump(dump) {
+  const dir = path.resolve(process.cwd(), "logs");
+  fs.mkdirSync(dir, { recursive: true });
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const status = dump.upstreamResponse?.status ?? dump.proxyResponse.status;
+  const filename = `proxy-error-${ts}-${status}.json`;
+  const filePath = path.join(dir, filename);
+  const payload = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    ...dump
+  };
+  redactAuth(payload.clientRequest?.headers);
+  redactAuth(payload.upstreamRequest?.headers);
+  fs.writeFileSync(filePath, JSON.stringify(payload, null, 2));
+  return filePath;
+}
+function redactAuth(headers) {
+  if (!headers) {
+    return;
+  }
+  for (const key of Object.keys(headers)) {
+    const lowerKey = key.toLowerCase();
+    if (lowerKey === "authorization" || lowerKey === "x-api-key" || lowerKey === "api-key" || lowerKey === "cookie") {
+      headers[key] = "[REDACTED]";
+    }
+  }
+}
+
+Object.defineProperty(exports, "createResponsesFetch", {
+  enumerable: true,
+  get: function () { return core.createResponsesFetch; }
+});
+Object.defineProperty(exports, "encodeSseEvent", {
+  enumerable: true,
+  get: function () { return core.encodeSseEvent; }
+});
+Object.defineProperty(exports, "parseSseStream", {
+  enumerable: true,
+  get: function () { return core.parseSseStream; }
+});
+exports.startProxy = startProxy;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map