@tekmidian/pai 0.36.2 → 0.38.0

package/dist/hooks/worker-proxy.mjs

@@ -0,0 +1,858 @@
+// src/workers/standalone/proxy.ts
+import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "node:fs";
+
+// src/workers/config.ts
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
+
+// src/config/json-store.ts
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  copyFileSync,
+  renameSync,
+  unlinkSync,
+  mkdirSync
+} from "node:fs";
+function readJsonStrict(path, label = path) {
+  if (!existsSync(path)) return {};
+  let raw;
+  try {
+    raw = readFileSync(path, "utf8");
+  } catch (e) {
+    throw new Error(
+      `Could not read ${label}: ${e instanceof Error ? e.message : String(e)}
+Refusing to continue \u2014 writing now would replace its contents with ours alone.`
+    );
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (e) {
+    throw new Error(
+      `${label} exists but is not valid JSON: ${e instanceof Error ? e.message : String(e)}
+Refusing to continue \u2014 overwriting it would destroy whatever it holds.
+Repair the file, or move it aside and re-run this command.`
+    );
+  }
+}
+
+// src/daemon/config.ts
+import { homedir, userInfo } from "node:os";
+import { join } from "node:path";
+
+// src/notifications/types.ts
+var DEFAULT_ROUTING = {
+  error: ["whatsapp", "macos", "ntfy", "cli"],
+  completion: ["whatsapp", "macos", "ntfy", "cli"],
+  info: ["cli"],
+  progress: ["cli"],
+  debug: []
+};
+var DEFAULT_CHANNELS = {
+  ntfy: {
+    enabled: false,
+    url: void 0,
+    priority: "default"
+  },
+  whatsapp: {
+    enabled: true,
+    recipient: void 0
+  },
+  macos: {
+    enabled: true
+  },
+  voice: {
+    enabled: false,
+    voiceName: "bm_george"
+  },
+  cli: {
+    enabled: true
+  }
+};
+var DEFAULT_NOTIFICATION_CONFIG = {
+  mode: "auto",
+  channels: DEFAULT_CHANNELS,
+  routing: DEFAULT_ROUTING
+};
+
+// src/tasks/types.ts
+var DEFAULT_TASK_CONFIG = {
+  enabled: false,
+  providers: {
+    todoist: {
+      enabled: false
+    }
+  },
+  autoDispatch: false
+};
+
+// src/runtime-paths.ts
+function paiSocketPath() {
+  return process.env.PAI_SOCKET_PATH ?? "/tmp/pai.sock";
+}
+
+// src/daemon/config.ts
+function perUserDbName() {
+  const username = userInfo().username;
+  const safe = username.replace(/[^a-zA-Z0-9_]/g, "_").toLowerCase();
+  return `pai_${safe}`;
+}
+function perUserConnectionString() {
+  const db = perUserDbName();
+  return `postgresql://pai:pai@localhost:5432/${db}`;
+}
+var DEFAULTS = {
+  socketPath: paiSocketPath(),
+  indexIntervalSecs: 300,
+  embedIntervalSecs: 600,
+  embedOnStartup: false,
+  storageBackend: "sqlite",
+  postgres: {
+    connectionString: perUserConnectionString(),
+    maxConnections: 5,
+    connectionTimeoutMs: 5e3
+  },
+  embeddingModel: "Snowflake/snowflake-arctic-embed-m-v1.5",
+  logLevel: "info",
+  notifications: DEFAULT_NOTIFICATION_CONFIG,
+  tasks: DEFAULT_TASK_CONFIG,
+  // Deliberately empty. An install must not guess who the user is: a wrong
+  // guess here is an address that can be mailed without review.
+  identity: { selfEmails: [] },
+  search: {
+    mode: "keyword",
+    rerank: true,
+    recencyBoostDays: 90,
+    defaultLimit: 10,
+    snippetLength: 200
+  }
+};
+var CONFIG_DIR = join(homedir(), ".config", "pai");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+
+// src/workers/config.ts
+var PROVIDER_TAGS = [
+  "code",
+  "vision",
+  "image-gen",
+  "long-context",
+  "fast",
+  "reasoning"
+];
+var DEFAULT_LOG_DIR = "~/.claude/logs/workers";
+var DEFAULT_PANE = {
+  enabled: true,
+  fontSize: 13,
+  autoExitSecs: 60
+};
+var DEFAULT_ROUTING2 = {
+  order: [],
+  cooldownMinutes: 30,
+  retryOnQuota: true
+};
+function defaultWorkersConfig() {
+  return {
+    enabled: false,
+    active: null,
+    providers: {},
+    classes: {},
+    mcpSets: {},
+    pane: { ...DEFAULT_PANE },
+    logDir: DEFAULT_LOG_DIR,
+    routing: { ...DEFAULT_ROUTING2, order: [] }
+  };
+}
+var WorkersConfigError = class extends Error {
+};
+function bad(path, why) {
+  throw new WorkersConfigError(`workers${path}: ${why}`);
+}
+function str(v) {
+  return typeof v === "string" ? v : "";
+}
+function parseProvider(name, raw) {
+  if (typeof raw !== "object" || raw === null) bad(`.providers.${name}`, "must be an object");
+  const p = raw;
+  const protocol = p.protocol === void 0 ? "anthropic" : str(p.protocol);
+  if (protocol !== "anthropic" && protocol !== "openai") {
+    bad(`.providers.${name}.protocol`, `"${str(p.protocol)}" is neither "anthropic" nor "openai"`);
+  }
+  const engine = p.engine === void 0 ? "claude" : str(p.engine);
+  if (engine !== "claude" && engine !== "codex") {
+    bad(`.providers.${name}.engine`, `"${str(p.engine)}" is neither "claude" nor "codex"`);
+  }
+  const baseUrl = str(p.baseUrl);
+  if (!baseUrl && protocol !== "openai") bad(`.providers.${name}.baseUrl`, "is required");
+  const keyFile = p.keyFile === void 0 || p.keyFile === null || str(p.keyFile) === "" ? null : str(p.keyFile);
+  const modelsRaw = p.models === void 0 ? {} : p.models;
+  if (typeof modelsRaw !== "object" || modelsRaw === null) {
+    bad(`.providers.${name}.models`, "must be an object");
+  }
+  const m = modelsRaw;
+  const defaultModel = str(m.default);
+  if (!defaultModel) bad(`.providers.${name}.models.default`, "is required");
+  const fast = m.fast === void 0 ? void 0 : str(m.fast);
+  const env = {};
+  if (p.env !== void 0) {
+    if (typeof p.env !== "object" || p.env === null || Array.isArray(p.env)) {
+      bad(`.providers.${name}.env`, "must be an object of string values");
+    }
+    for (const [k, v] of Object.entries(p.env)) {
+      if (typeof v !== "string") bad(`.providers.${name}.env.${k}`, "must be a string");
+      env[k] = v;
+    }
+  }
+  const quotaSkipAt = p.quotaSkipAt === void 0 ? void 0 : p.quotaSkipAt;
+  if (quotaSkipAt !== void 0) {
+    if (typeof quotaSkipAt !== "number" || quotaSkipAt < 0 || quotaSkipAt > 100) {
+      bad(`.providers.${name}.quotaSkipAt`, "must be a number between 0 and 100");
+    }
+  }
+  const contextWindow = p.contextWindow === void 0 ? void 0 : p.contextWindow;
+  if (contextWindow !== void 0) {
+    if (typeof contextWindow !== "number" || contextWindow <= 0) {
+      bad(`.providers.${name}.contextWindow`, "must be a positive number of tokens");
+    }
+  }
+  const upstreamUrl = str(p.upstreamUrl);
+  if (protocol === "openai" && !upstreamUrl) {
+    bad(`.providers.${name}.upstreamUrl`, `is required for protocol "openai" (the Chat Completions base, e.g. "https://api.openai.com/v1")`);
+  }
+  const costTier = p.costTier === void 0 ? void 0 : p.costTier;
+  if (costTier !== void 0) {
+    if (typeof costTier !== "number" || !Number.isInteger(costTier) || costTier < 1 || costTier > 5) {
+      bad(`.providers.${name}.costTier`, "must be an integer 1 (cheapest) \u2026 5 (most expensive)");
+    }
+  }
+  let tags;
+  if (p.tags !== void 0) {
+    if (!Array.isArray(p.tags) || p.tags.some((x) => typeof x !== "string")) {
+      bad(`.providers.${name}.tags`, `must be an array of tags from: ${PROVIDER_TAGS.join(", ")}`);
+    }
+    for (const t of p.tags) {
+      if (!PROVIDER_TAGS.includes(t)) {
+        bad(`.providers.${name}.tags`, `"${t}" is not a tag (from: ${PROVIDER_TAGS.join(", ")})`);
+      }
+    }
+    tags = p.tags;
+  }
+  return {
+    enabled: p.enabled === void 0 ? true : p.enabled === true,
+    protocol,
+    baseUrl,
+    keyFile,
+    models: fast ? { default: defaultModel, fast } : { default: defaultModel },
+    env,
+    ...str(p.note) ? { note: str(p.note) } : {},
+    ...upstreamUrl ? { upstreamUrl } : {},
+    ...engine !== "claude" ? { engine } : {},
+    ...str(p.quotaProbe) ? { quotaProbe: str(p.quotaProbe) } : {},
+    ...quotaSkipAt !== void 0 ? { quotaSkipAt } : {},
+    ...contextWindow !== void 0 ? { contextWindow } : {},
+    ...costTier !== void 0 ? { costTier } : {},
+    ...tags ? { tags } : {}
+  };
+}
+function parseWorkersConfig(raw) {
+  const d = defaultWorkersConfig();
+  if (raw === void 0 || raw === null) return d;
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    bad("", "section must be an object");
+  }
+  const w = raw;
+  const providers = {};
+  if (w.providers !== void 0) {
+    if (typeof w.providers !== "object" || w.providers === null || Array.isArray(w.providers)) {
+      bad(".providers", "must be an object keyed by provider name");
+    }
+    for (const [name, p] of Object.entries(w.providers)) {
+      providers[name] = parseProvider(name, p);
+    }
+  }
+  const classes = {};
+  const classesRaw = w.classes !== void 0 ? w.classes : w.roles;
+  if (classesRaw !== void 0) {
+    if (typeof classesRaw !== "object" || classesRaw === null || Array.isArray(classesRaw)) {
+      bad(w.classes !== void 0 ? ".classes" : ".roles", "must be an object of class \u2192 provider[/alias] or {provider, mcp, maxCostTier, requireTags, order}");
+    }
+    for (const [cls, target] of Object.entries(classesRaw)) {
+      if (typeof target === "object" && target !== null && !Array.isArray(target)) {
+        const o = target;
+        const provider = str(o.provider);
+        if (o.provider !== void 0 && (!provider || provider.includes(" "))) {
+          bad(`.classes.${cls}.provider`, `invalid provider "${provider}"`);
+        }
+        let mcp;
+        if (o.mcp !== void 0) {
+          if (!Array.isArray(o.mcp) || o.mcp.some((x) => typeof x !== "string")) {
+            bad(`.classes.${cls}.mcp`, "must be an array of MCP server or set names");
+          }
+          mcp = o.mcp;
+        }
+        let maxCostTier;
+        if (o.maxCostTier !== void 0) {
+          if (typeof o.maxCostTier !== "number" || !Number.isInteger(o.maxCostTier) || o.maxCostTier < 1 || o.maxCostTier > 5) {
+            bad(`.classes.${cls}.maxCostTier`, "must be an integer 1 \u2026 5");
+          }
+          maxCostTier = o.maxCostTier;
+        }
+        let requireTags;
+        if (o.requireTags !== void 0) {
+          if (!Array.isArray(o.requireTags) || o.requireTags.some((x) => typeof x !== "string")) {
+            bad(`.classes.${cls}.requireTags`, `must be an array of tags from: ${PROVIDER_TAGS.join(", ")}`);
+          }
+          for (const t of o.requireTags) {
+            if (!PROVIDER_TAGS.includes(t)) {
+              bad(`.classes.${cls}.requireTags`, `"${t}" is not a tag (from: ${PROVIDER_TAGS.join(", ")})`);
+            }
+          }
+          requireTags = o.requireTags;
+        }
+        let order;
+        if (o.order !== void 0) {
+          if (!Array.isArray(o.order) || o.order.some((x) => typeof x !== "string")) {
+            bad(`.classes.${cls}.order`, "must be an array of provider names");
+          }
+          order = o.order;
+        }
+        const obj = {
+          ...provider ? { provider } : {},
+          ...mcp ? { mcp } : {},
+          ...maxCostTier !== void 0 ? { maxCostTier } : {},
+          ...requireTags ? { requireTags } : {},
+          ...order ? { order } : {}
+        };
+        classes[cls] = Object.keys(obj).length ? obj : {};
+      } else {
+        const t = str(target);
+        if (!t || t.includes(" ")) bad(`.classes.${cls}`, `invalid target "${t}"`);
+        classes[cls] = t;
+      }
+    }
+  }
+  const mcpSets = {};
+  if (w.mcpSets !== void 0) {
+    if (typeof w.mcpSets !== "object" || w.mcpSets === null || Array.isArray(w.mcpSets)) {
+      bad(".mcpSets", "must be an object of set name \u2192 [server names]");
+    }
+    for (const [setName, servers] of Object.entries(w.mcpSets)) {
+      if (!Array.isArray(servers) || servers.some((x) => typeof x !== "string")) {
+        bad(`.mcpSets.${setName}`, "must be an array of MCP server names");
+      }
+      mcpSets[setName] = servers;
+    }
+  }
+  let pane = { ...DEFAULT_PANE };
+  if (w.pane !== void 0) {
+    if (typeof w.pane !== "object" || w.pane === null) bad(".pane", "must be an object");
+    const pc = w.pane;
+    if (pc.enabled !== void 0 && typeof pc.enabled !== "boolean") bad(".pane.enabled", "must be boolean");
+    if (pc.fontSize !== void 0 && (typeof pc.fontSize !== "number" || pc.fontSize <= 0)) {
+      bad(".pane.fontSize", "must be a positive number of points");
+    }
+    if (pc.autoExitSecs !== void 0 && typeof pc.autoExitSecs !== "number") {
+      bad(".pane.autoExitSecs", "must be a number");
+    }
+    pane = {
+      enabled: pc.enabled === void 0 ? DEFAULT_PANE.enabled : pc.enabled === true,
+      fontSize: pc.fontSize === void 0 ? DEFAULT_PANE.fontSize : pc.fontSize,
+      autoExitSecs: pc.autoExitSecs === void 0 ? DEFAULT_PANE.autoExitSecs : pc.autoExitSecs
+    };
+  }
+  let routing = { ...DEFAULT_ROUTING2, order: [] };
+  if (w.routing !== void 0) {
+    if (typeof w.routing !== "object" || w.routing === null) bad(".routing", "must be an object");
+    const r = w.routing;
+    if (r.order !== void 0) {
+      if (!Array.isArray(r.order) || r.order.some((x) => typeof x !== "string")) {
+        bad(".routing.order", "must be an array of provider names");
+      }
+      routing.order = r.order;
+    }
+    if (r.cooldownMinutes !== void 0 && typeof r.cooldownMinutes !== "number") {
+      bad(".routing.cooldownMinutes", "must be a number");
+    }
+    if (r.retryOnQuota !== void 0 && typeof r.retryOnQuota !== "boolean") {
+      bad(".routing.retryOnQuota", "must be boolean");
+    }
+    routing = {
+      order: routing.order,
+      cooldownMinutes: r.cooldownMinutes === void 0 ? DEFAULT_ROUTING2.cooldownMinutes : r.cooldownMinutes,
+      retryOnQuota: r.retryOnQuota === void 0 ? DEFAULT_ROUTING2.retryOnQuota : r.retryOnQuota === true
+    };
+  }
+  const active = w.active === void 0 || w.active === null ? null : str(w.active);
+  if (active !== null && active !== "auto" && !(active in providers)) {
+  }
+  return {
+    enabled: w.enabled === void 0 ? d.enabled : w.enabled === true,
+    active,
+    providers,
+    classes,
+    mcpSets,
+    pane,
+    logDir: str(w.logDir) || d.logDir,
+    routing
+  };
+}
+function readWorkersSection() {
+  const raw = readJsonStrict(CONFIG_FILE, "~/.config/pai/config.json");
+  return { raw, workers: parseWorkersConfig(raw.workers) };
+}
+function expandHome(p) {
+  if (p === "~" || p.startsWith("~/")) return join2(homedir2(), p.slice(1));
+  return p;
+}
+function providerKeyPath(p) {
+  return p.keyFile ? expandHome(p.keyFile) : null;
+}
+
+// src/workers/paths.ts
+function workersLogDir(config) {
+  return expandHome(config.logDir);
+}
+
+// src/workers/proxy/server.ts
+import { createServer } from "node:http";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, unlinkSync as unlinkSync2 } from "node:fs";
+import { dirname, join as join3 } from "node:path";
+
+// src/workers/proxy/translate.ts
+function systemText(system) {
+  if (typeof system === "string") return system;
+  if (!Array.isArray(system)) return "";
+  return system.filter((b) => b.type === "text").map((b) => b.text ?? "").join("\n").trim();
+}
+function toolCallFromBlock(b) {
+  return {
+    id: b.id ?? "",
+    type: "function",
+    function: { name: b.name ?? "", arguments: JSON.stringify(b.input ?? {}) }
+  };
+}
+function toolResultText(b) {
+  if (typeof b.content === "string") return b.content;
+  if (Array.isArray(b.content)) {
+    return b.content.map((x) => typeof x === "object" && x !== null && "text" in x ? String(x.text ?? "") : "").join("\n");
+  }
+  return "";
+}
+function anthropicToOpenAi(req, model) {
+  const messages = [];
+  const sys = systemText(req.system);
+  if (sys) messages.push({ role: "system", content: sys });
+  for (const m of req.messages ?? []) {
+    const blocks = typeof m.content === "string" ? [{ type: "text", text: m.content }] : m.content;
+    if (m.role === "assistant") {
+      const text = (blocks ?? []).filter((b) => b.type === "text").map((b) => b.text ?? "").join("");
+      const calls = (blocks ?? []).filter((b) => b.type === "tool_use").map(toolCallFromBlock);
+      const msg = { role: "assistant", content: text || null };
+      if (calls.length) msg.tool_calls = calls;
+      messages.push(msg);
+    } else {
+      const texts = [];
+      for (const b of blocks ?? []) {
+        if (b.type === "tool_result") {
+          messages.push({
+            role: "tool",
+            tool_call_id: b.tool_use_id ?? "",
+            content: toolResultText(b)
+          });
+        } else if (b.type === "text" && (b.text ?? "").trim()) {
+          texts.push(b.text ?? "");
+        }
+      }
+      if (texts.length) messages.push({ role: "user", content: texts.join("\n") });
+    }
+  }
+  const out = {
+    model,
+    max_tokens: req.max_tokens ?? 8192,
+    messages
+  };
+  if (req.temperature !== void 0) out.temperature = req.temperature;
+  if (req.stop_sequences?.length) out.stop = req.stop_sequences;
+  if (req.stream) {
+    out.stream = true;
+    out.stream_options = { include_usage: true };
+  }
+  if (req.tools?.length) {
+    out.tools = req.tools.map((t) => ({
+      type: "function",
+      function: {
+        name: t.name ?? "",
+        description: t.description ?? "",
+        parameters: t.input_schema ?? { type: "object", properties: {} }
+      }
+    }));
+  }
+  return out;
+}
+function stopReasonFrom(finish) {
+  switch (finish) {
+    case "tool_calls":
+      return "tool_use";
+    case "length":
+      return "max_tokens";
+    case "stop":
+      return "stop_sequence";
+    default:
+      return "end_turn";
+  }
+}
+function openAiToAnthropic(res, model) {
+  const choice = res.choices?.[0];
+  const msg = choice?.message;
+  const content = [];
+  if (msg?.content) content.push({ type: "text", text: msg.content });
+  for (const call of msg?.tool_calls ?? []) {
+    let input = {};
+    try {
+      input = JSON.parse(call.function?.arguments || "{}");
+    } catch {
+      input = { _raw: call.function?.arguments ?? "" };
+    }
+    content.push({ type: "tool_use", id: call.id ?? "", name: call.function?.name ?? "", input });
+  }
+  return {
+    id: `msg_${res.id ?? Date.now().toString(36)}`,
+    type: "message",
+    role: "assistant",
+    model: res.model ?? model,
+    content,
+    stop_reason: stopReasonFrom(choice?.finish_reason),
+    stop_sequence: null,
+    usage: {
+      input_tokens: res.usage?.prompt_tokens ?? 0,
+      output_tokens: res.usage?.completion_tokens ?? 0
+    }
+  };
+}
+function anthropicError(status, upstreamBody) {
+  let message = upstreamBody.slice(0, 2e3);
+  let upstreamType = "";
+  try {
+    const parsed = JSON.parse(upstreamBody);
+    message = parsed.error?.message ?? parsed.message ?? message;
+    upstreamType = parsed.error?.type ?? "";
+  } catch {
+  }
+  let type;
+  if (status === 429) type = "rate_limit_error";
+  else if (status === 401 || status === 403) type = "authentication_error";
+  else if (status === 400 || status === 404 || status === 422) type = "invalid_request_error";
+  else if (status === 402 || status >= 500) type = "api_error";
+  else if (upstreamType) type = upstreamType;
+  else type = "api_error";
+  return { type: "error", error: { type, message } };
+}
+var OpenAiStreamTranslator = class _OpenAiStreamTranslator {
+  messageStarted = false;
+  openBlock = null;
+  toolCalls = /* @__PURE__ */ new Map();
+  nextBlockIndex = 0;
+  outputTokens = 0;
+  stopReason = "end_turn";
+  finished = false;
+  model;
+  id;
+  constructor(model, id = `msg_${Date.now().toString(36)}`) {
+    this.model = model;
+    this.id = id;
+  }
+  /** SSE wire form of one Anthropic stream event. */
+  static sse(event, data) {
+    return `event: ${event}
+data: ${JSON.stringify(data)}
+
+`;
+  }
+  /** Consume one parsed OpenAI chunk; returns SSE text to forward (may be ""). */
+  feed(chunk) {
+    if (this.finished) return "";
+    const out = [];
+    if (!this.messageStarted) {
+      this.messageStarted = true;
+      out.push(
+        _OpenAiStreamTranslator.sse("message_start", {
+          type: "message_start",
+          message: {
+            id: this.id,
+            type: "message",
+            role: "assistant",
+            model: this.model,
+            content: [],
+            stop_reason: null,
+            stop_sequence: null,
+            usage: { input_tokens: chunk.usage?.prompt_tokens ?? 0, output_tokens: 0 }
+          }
+        })
+      );
+    }
+    if (chunk.usage?.completion_tokens) this.outputTokens = chunk.usage.completion_tokens;
+    const choice = chunk.choices?.[0];
+    if (choice) {
+      const text = choice.delta?.content;
+      if (typeof text === "string" && text) {
+        if (!this.openBlock) {
+          this.openBlock = { index: this.nextBlockIndex++, kind: "text" };
+          out.push(
+            _OpenAiStreamTranslator.sse("content_block_start", {
+              type: "content_block_start",
+              index: this.openBlock.index,
+              content_block: { type: "text", text: "" }
+            })
+          );
+        }
+        out.push(
+          _OpenAiStreamTranslator.sse("content_block_delta", {
+            type: "content_block_delta",
+            index: this.openBlock.index,
+            delta: { type: "text_delta", text }
+          })
+        );
+      }
+      for (const call of choice.delta?.tool_calls ?? []) {
+        const idx = call.index ?? 0;
+        let acc = this.toolCalls.get(idx);
+        if (!acc) {
+          acc = { id: call.id ?? "", name: "", args: "", blockIndex: null };
+          this.toolCalls.set(idx, acc);
+        }
+        if (call.id) acc.id = call.id;
+        if (call.function?.name) acc.name += call.function.name;
+        if (call.function?.arguments) acc.args += call.function.arguments;
+        if (acc.blockIndex === null && (acc.id || acc.name)) {
+          this.closeTextBlock(out);
+          acc.blockIndex = this.nextBlockIndex++;
+          out.push(
+            _OpenAiStreamTranslator.sse("content_block_start", {
+              type: "content_block_start",
+              index: acc.blockIndex,
+              content_block: { type: "tool_use", id: acc.id, name: acc.name, input: {} }
+            })
+          );
+        }
+        if (acc.blockIndex !== null && call.function?.arguments) {
+          out.push(
+            _OpenAiStreamTranslator.sse("content_block_delta", {
+              type: "content_block_delta",
+              index: acc.blockIndex,
+              delta: { type: "input_json_delta", partial_json: call.function.arguments }
+            })
+          );
+        }
+      }
+      if (choice.finish_reason) this.stopReason = stopReasonFrom(choice.finish_reason);
+    }
+    return out.join("");
+  }
+  closeTextBlock(out) {
+    if (!this.openBlock) return;
+    out.push(
+      _OpenAiStreamTranslator.sse("content_block_stop", {
+        type: "content_block_stop",
+        index: this.openBlock.index
+      })
+    );
+    this.openBlock = null;
+  }
+  /** Close everything and emit the tail events. Single call at stream end. */
+  finish() {
+    if (this.finished) return "";
+    this.finished = true;
+    const out = [];
+    this.closeTextBlock(out);
+    for (const acc of [...this.toolCalls.values()].sort((a, b) => (a.blockIndex ?? 0) - (b.blockIndex ?? 0))) {
+      if (acc.blockIndex === null) continue;
+      out.push(
+        _OpenAiStreamTranslator.sse("content_block_stop", {
+          type: "content_block_stop",
+          index: acc.blockIndex
+        })
+      );
+    }
+    out.push(
+      _OpenAiStreamTranslator.sse("message_delta", {
+        type: "message_delta",
+        delta: { stop_reason: this.stopReason, stop_sequence: null },
+        usage: { output_tokens: this.outputTokens }
+      })
+    );
+    out.push(_OpenAiStreamTranslator.sse("message_stop", { type: "message_stop" }));
+    return out.join("");
+  }
+};
+
+// src/workers/proxy/server.ts
+var DEFAULT_PROXY_PORT = 8797;
+var HOST = "127.0.0.1";
+var configProviders = () => readWorkersSection().workers.providers;
+function proxyPidPath(logDir2) {
+  return join3(logDir2, "proxy.pid");
+}
+function createProxyServer(opts = {}) {
+  const resolveProvider = opts.resolveProvider ?? configProviders;
+  return createServer((req, res) => {
+    const url = new URL(req.url ?? "/", `http://${HOST}`);
+    if (req.method === "GET" && url.pathname === "/healthz") {
+      res.writeHead(200, { "content-type": "text/plain" });
+      res.end("ok");
+      return;
+    }
+    const m = url.pathname.match(/^\/([a-zA-Z0-9_-]+)\/(v1\/)?messages$/);
+    if (req.method !== "POST" || !m) {
+      res.writeHead(404, { "content-type": "application/json" });
+      res.end(JSON.stringify(anthropicError(404, `no such route: ${req.method} ${url.pathname}`)));
+      return;
+    }
+    const providerName = m[1];
+    const chunks = [];
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () => {
+      void handleMessages(providerName, Buffer.concat(chunks).toString("utf8"), resolveProvider, res, opts);
+    });
+    req.on("error", () => {
+      res.writeHead(400, { "content-type": "application/json" });
+      res.end(JSON.stringify(anthropicError(400, "request body read failed")));
+    });
+  });
+}
+async function handleMessages(providerName, bodyText, resolveProvider, res, opts) {
+  const fail = (status, message) => {
+    res.writeHead(status, { "content-type": "application/json" });
+    res.end(JSON.stringify(anthropicError(status, JSON.stringify({ message }))));
+  };
+  let reqBody;
+  try {
+    reqBody = JSON.parse(bodyText);
+  } catch {
+    fail(400, "request body is not valid JSON");
+    return;
+  }
+  const provider = resolveProvider()[providerName];
+  if (!provider) {
+    fail(404, `no worker provider named "${providerName}"`);
+    return;
+  }
+  if (provider.protocol !== "openai" || !provider.upstreamUrl) {
+    fail(400, `provider "${providerName}" is not an openai-protocol provider`);
+    return;
+  }
+  const model = provider.models.default;
+  const openaiBody = anthropicToOpenAi(reqBody, model);
+  opts.onUpstreamRequest?.(`${provider.upstreamUrl}/chat/completions`, openaiBody);
+  let upstream;
+  try {
+    const headers = { "content-type": "application/json" };
+    const keyPath = providerKeyPath(provider);
+    if (keyPath) {
+      try {
+        headers.authorization = `Bearer ${readFileSync2(keyPath, "utf8").trim()}`;
+      } catch {
+        fail(500, `key file not readable: ${keyPath}`);
+        return;
+      }
+    }
+    upstream = await fetch(`${provider.upstreamUrl}/chat/completions`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(openaiBody)
+    });
+  } catch (e) {
+    fail(502, `upstream unreachable: ${e instanceof Error ? e.message : String(e)}`);
+    return;
+  }
+  if (!upstream.ok) {
+    const text = await upstream.text().catch(() => "");
+    res.writeHead(upstream.status, { "content-type": "application/json" });
+    res.end(JSON.stringify(anthropicError(upstream.status, text)));
+    return;
+  }
+  if (reqBody.stream) {
+    res.writeHead(200, {
+      "content-type": "text/event-stream",
+      "cache-control": "no-cache",
+      connection: "keep-alive"
+    });
+    const translator = new OpenAiStreamTranslator(model);
+    let buf = "";
+    if (!upstream.body) {
+      res.end(translator.finish());
+      return;
+    }
+    const reader = upstream.body.getReader();
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buf += new TextDecoder().decode(value, { stream: true });
+        let nl;
+        while ((nl = buf.indexOf("\n")) >= 0) {
+          const line = buf.slice(0, nl).trim();
+          buf = buf.slice(nl + 1);
+          if (!line.startsWith("data:")) continue;
+          const payload = line.slice(5).trim();
+          if (payload === "[DONE]") {
+            res.write(translator.finish());
+          } else {
+            try {
+              res.write(translator.feed(JSON.parse(payload)));
+            } catch {
+            }
+          }
+        }
+      }
+    } finally {
+      res.write(translator.finish());
+      res.end();
+    }
+    return;
+  }
+  const json = await upstream.json().catch(() => null);
+  if (!json) {
+    fail(502, "upstream returned a non-JSON body");
+    return;
+  }
+  res.writeHead(200, { "content-type": "application/json" });
+  res.end(JSON.stringify(openAiToAnthropic(json, model)));
+}
+function listenProxy(server2, port2 = DEFAULT_PROXY_PORT) {
+  return new Promise((resolve, reject) => {
+    server2.once("error", reject);
+    server2.listen(port2, HOST, () => {
+      const addr = server2.address();
+      resolve(typeof addr === "object" && addr ? addr.port : port2);
+    });
+  });
+}
+
+// src/workers/standalone/proxy.ts
+var portFlag = process.argv.indexOf("--port");
+var port = portFlag > 0 ? parseInt(process.argv[portFlag + 1], 10) || DEFAULT_PROXY_PORT : DEFAULT_PROXY_PORT;
+var logDir = "";
+try {
+  logDir = workersLogDir(readWorkersSection().workers);
+} catch {
+  logDir = "";
+}
+var server = createProxyServer();
+listenProxy(server, port).then((bound) => {
+  if (logDir) {
+    mkdirSync3(logDir, { recursive: true });
+    writeFileSync3(proxyPidPath(logDir), `${process.pid}
+`, "utf8");
+  }
+  process.stderr.write(`pai worker proxy listening on http://127.0.0.1:${bound}
+`);
+}).catch((e) => {
+  process.stderr.write(`pai worker proxy: cannot listen on ${port}: ${String(e)}
+`);
+  process.exit(1);
+});
+process.once("SIGTERM", () => {
+  server.close(() => process.exit(0));
+  setTimeout(() => process.exit(0), 1500).unref();
+});
+//# sourceMappingURL=worker-proxy.mjs.map