privateer-agent 0.15.4 → 0.15.6

package/dist-boot/c-I54OKQHW.mjs

@@ -0,0 +1,387 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+import {
+  mcpNamespace,
+  require_proper_lockfile,
+  validateMcpServerConfig
+} from "./c-E4Z3Y5B5.mjs";
+import {
+  CONFIG_DIR_NAME,
+  canonicalizePath,
+  projectConfigDirCandidates,
+  resolvePath,
+  stripBom
+} from "./c-PTN4S6G2.mjs";
+import {
+  __name,
+  __toESM
+} from "./c-CN77DCGF.mjs";
+
+// node_modules/@earendil-works/pi-coding-agent/dist/core/trust-manager.js
+var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+var TRUST_REQUIRING_PROJECT_CONFIG_RESOURCES = [
+  "settings.json",
+  "mcp.json",
+  "extensions",
+  "skills",
+  "prompts",
+  "themes",
+  "SYSTEM.md",
+  "APPEND_SYSTEM.md"
+];
+function normalizeCwd(cwd) {
+  return canonicalizePath(resolvePath(cwd));
+}
+__name(normalizeCwd, "normalizeCwd");
+function findNearestTrustEntry(data, cwd) {
+  let currentDir = normalizeCwd(cwd);
+  while (true) {
+    const value = data[currentDir];
+    if (value === true || value === false) {
+      return { path: currentDir, decision: value };
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+__name(findNearestTrustEntry, "findNearestTrustEntry");
+function getProjectTrustParentPath(cwd) {
+  const trustPath = normalizeCwd(cwd);
+  const parentDir = dirname(trustPath);
+  return parentDir === trustPath ? void 0 : parentDir;
+}
+__name(getProjectTrustParentPath, "getProjectTrustParentPath");
+function getProjectTrustOptions(cwd, options) {
+  const trustPath = normalizeCwd(cwd);
+  const trustOptions = [
+    { label: "Trust", trusted: true, updates: [{ path: trustPath, decision: true }], savedPath: trustPath }
+  ];
+  const parentPath = getProjectTrustParentPath(cwd);
+  if (parentPath !== void 0) {
+    trustOptions.push({
+      label: `Trust parent folder (${parentPath})`,
+      trusted: true,
+      updates: [
+        { path: parentPath, decision: true },
+        { path: trustPath, decision: null }
+      ],
+      savedPath: parentPath
+    });
+  }
+  if (options?.includeSessionOnly) {
+    trustOptions.push({ label: "Trust (this session only)", trusted: true, updates: [] });
+  }
+  trustOptions.push({
+    label: "Do not trust",
+    trusted: false,
+    updates: [{ path: trustPath, decision: false }],
+    savedPath: trustPath
+  });
+  if (options?.includeSessionOnly) {
+    trustOptions.push({ label: "Do not trust (this session only)", trusted: false, updates: [] });
+  }
+  return trustOptions;
+}
+__name(getProjectTrustOptions, "getProjectTrustOptions");
+function readTrustFile(path) {
+  if (!existsSync(path)) {
+    return {};
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(stripBom(readFileSync(path, "utf-8")));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to read trust store ${path}: ${message}`);
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error(`Invalid trust store ${path}: expected an object`);
+  }
+  const data = {};
+  for (const [key, value] of Object.entries(parsed)) {
+    if (value !== true && value !== false && value !== null) {
+      throw new Error(`Invalid trust store ${path}: value for ${JSON.stringify(key)} must be true, false, or null`);
+    }
+    data[key] = value;
+  }
+  return data;
+}
+__name(readTrustFile, "readTrustFile");
+function writeTrustFile(path, data) {
+  const sorted = {};
+  for (const key of Object.keys(data).sort()) {
+    const value = data[key];
+    if (value === true || value === false || value === null) {
+      sorted[key] = value;
+    }
+  }
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(sorted, null, 2)}
+`, "utf-8");
+}
+__name(writeTrustFile, "writeTrustFile");
+function acquireTrustLockSync(path) {
+  const trustDir = dirname(path);
+  mkdirSync(trustDir, { recursive: true });
+  const maxAttempts = 10;
+  const delayMs = 20;
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return import_proper_lockfile.default.lockSync(trustDir, { realpath: false, lockfilePath: `${path}.lock` });
+    } catch (error) {
+      const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : void 0;
+      if (code !== "ELOCKED" || attempt === maxAttempts) {
+        throw error;
+      }
+      lastError = error;
+      const start = Date.now();
+      while (Date.now() - start < delayMs) {
+      }
+    }
+  }
+  if (lastError instanceof Error) {
+    throw lastError;
+  }
+  throw new Error("Failed to acquire trust store lock");
+}
+__name(acquireTrustLockSync, "acquireTrustLockSync");
+function withTrustFileLock(path, fn) {
+  const release = acquireTrustLockSync(path);
+  try {
+    return fn();
+  } finally {
+    release();
+  }
+}
+__name(withTrustFileLock, "withTrustFileLock");
+function hasTrustRequiringProjectResources(cwd) {
+  const homeDir = canonicalizePath(resolvePath(process.env.HOME || homedir()));
+  const userAgentsSkillsDir = join(homeDir, ".agents", "skills");
+  let currentDir = canonicalizePath(resolvePath(cwd));
+  for (const configDir of projectConfigDirCandidates(currentDir)) {
+    if (TRUST_REQUIRING_PROJECT_CONFIG_RESOURCES.some((entry) => existsSync(join(configDir, entry)))) {
+      return true;
+    }
+  }
+  while (true) {
+    const agentsSkillsDir = join(currentDir, ".agents", "skills");
+    if (agentsSkillsDir !== userAgentsSkillsDir && existsSync(agentsSkillsDir)) {
+      return true;
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      return false;
+    }
+    currentDir = parentDir;
+  }
+}
+__name(hasTrustRequiringProjectResources, "hasTrustRequiringProjectResources");
+var ProjectTrustStore = class {
+  static {
+    __name(this, "ProjectTrustStore");
+  }
+  trustPath;
+  constructor(agentDir) {
+    this.trustPath = join(resolvePath(agentDir), "trust.json");
+  }
+  get(cwd) {
+    return this.getEntry(cwd)?.decision ?? null;
+  }
+  getEntry(cwd) {
+    return withTrustFileLock(this.trustPath, () => {
+      const data = readTrustFile(this.trustPath);
+      return findNearestTrustEntry(data, cwd);
+    });
+  }
+  set(cwd, decision) {
+    this.setMany([{ path: cwd, decision }]);
+  }
+  setMany(decisions) {
+    withTrustFileLock(this.trustPath, () => {
+      const data = readTrustFile(this.trustPath);
+      for (const { path, decision } of decisions) {
+        const key = normalizeCwd(path);
+        if (decision === null) {
+          delete data[key];
+        } else {
+          data[key] = decision;
+        }
+      }
+      writeTrustFile(this.trustPath, data);
+    });
+  }
+};
+
+// node_modules/@earendil-works/pi-coding-agent/dist/utils/open-browser.js
+import { spawn } from "node:child_process";
+function openBrowser(target) {
+  const [cmd, args] = process.platform === "darwin" ? ["open", [target]] : process.platform === "win32" ? ["rundll32", ["url.dll,FileProtocolHandler", target]] : ["xdg-open", [target]];
+  spawn(cmd, args, { stdio: "ignore", detached: true }).on("error", () => {
+  }).unref();
+}
+__name(openBrowser, "openBrowser");
+
+// node_modules/@earendil-works/pi-coding-agent/dist/extensions/mcp/config.js
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2, join as join2 } from "node:path";
+var OVERRIDE_KEYS = ["enabled", "exposure", "toolExposure"];
+function isOverride(value) {
+  return value.command === void 0 && value.url === void 0 && value.type === void 0;
+}
+__name(isOverride, "isOverride");
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+function readConfigFile(path, scope, state) {
+  const { servers, errors } = state;
+  if (!existsSync2(path))
+    return;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync2(path, "utf8"));
+  } catch (error) {
+    errors.push(`${path}: ${error instanceof Error ? error.message : String(error)}`);
+    return;
+  }
+  if (!isRecord(parsed) || parsed.mcpServers !== void 0 && !isRecord(parsed.mcpServers)) {
+    errors.push(`${path}: expected an object with an "mcpServers" object`);
+    return;
+  }
+  if (typeof parsed.autoEnableCodemode === "boolean")
+    state.autoEnableCodemode = parsed.autoEnableCodemode;
+  else if (parsed.autoEnableCodemode !== void 0)
+    errors.push(`${path}: autoEnableCodemode must be a boolean`);
+  for (const [name, value] of Object.entries(parsed.mcpServers ?? {})) {
+    if (scope === "project" && isRecord(value) && isOverride(value)) {
+      const base = servers.get(name);
+      const extra = Object.keys(value).filter((key) => !OVERRIDE_KEYS.includes(key));
+      if (!base) {
+        errors.push(`${path}: server "${name}" needs "command" or "url", or a global server to override`);
+      } else if (extra.length > 0) {
+        errors.push(`${path}: server "${name}": an override can only set ${OVERRIDE_KEYS.join(", ")}`);
+      } else {
+        const config2 = validateMcpServerConfig(name, { ...base.config, ...value });
+        if (typeof config2 === "string")
+          errors.push(`${path}: ${config2}`);
+        else
+          servers.set(name, { ...base, config: config2, override: path });
+      }
+      continue;
+    }
+    const config = validateMcpServerConfig(name, value);
+    if (typeof config === "string") {
+      errors.push(`${path}: ${config}`);
+      continue;
+    }
+    const clash = [...servers.keys()].find((other) => other !== name && mcpNamespace(other) === mcpNamespace(name));
+    if (clash) {
+      errors.push(`${path}: server "${name}" conflicts with "${clash}"`);
+      continue;
+    }
+    if (scope === "project" && "url" in config && config.auth) {
+      errors.push(`${path}: server "${name}": auth is only allowed in the global mcp.json`);
+      continue;
+    }
+    servers.set(name, { name, config, source: path, scope });
+  }
+}
+__name(readConfigFile, "readConfigFile");
+function loadMcpConfig(options) {
+  const state = { servers: /* @__PURE__ */ new Map(), errors: [] };
+  readConfigFile(join2(options.agentDir, "mcp.json"), "global", state);
+  const projectConfig = options.projectTrusted ? join2(options.cwd, CONFIG_DIR_NAME, "mcp.json") : void 0;
+  if (projectConfig)
+    readConfigFile(projectConfig, "project", state);
+  return {
+    servers: [...state.servers.values()],
+    ...state.autoEnableCodemode === void 0 ? {} : { autoEnableCodemode: state.autoEnableCodemode },
+    errors: state.errors,
+    ...projectConfig ? { projectConfig } : {}
+  };
+}
+__name(loadMcpConfig, "loadMcpConfig");
+function updateMcpServerConfig(path, name, patch, options = {}) {
+  editMcpServers(path, (servers, parsed) => {
+    let server = servers?.[name];
+    if (server === void 0 && options.override) {
+      server = {};
+      parsed.mcpServers = { ...servers, [name]: server };
+    }
+    if (!isRecord(server))
+      throw new Error(`${path} does not define MCP server "${name}"`);
+    const keepDefaults = isOverride(server);
+    if (patch.enabled !== void 0) {
+      if (patch.enabled && !keepDefaults)
+        delete server.enabled;
+      else
+        server.enabled = patch.enabled;
+    }
+    if (patch.exposure !== void 0) {
+      if (patch.exposure === "codemode" && !keepDefaults)
+        delete server.exposure;
+      else
+        server.exposure = patch.exposure;
+    }
+    return true;
+  });
+}
+__name(updateMcpServerConfig, "updateMcpServerConfig");
+function addMcpServerConfig(path, name, config) {
+  let replaced = false;
+  editMcpServers(path, (servers, parsed) => {
+    const target = servers ?? {};
+    replaced = target[name] !== void 0;
+    target[name] = config;
+    parsed.mcpServers = target;
+    return true;
+  });
+  return replaced;
+}
+__name(addMcpServerConfig, "addMcpServerConfig");
+function removeMcpServerConfig(path, name) {
+  if (!existsSync2(path))
+    return false;
+  let removed = false;
+  editMcpServers(path, (servers) => {
+    if (!servers || servers[name] === void 0)
+      return false;
+    delete servers[name];
+    removed = true;
+    return true;
+  });
+  return removed;
+}
+__name(removeMcpServerConfig, "removeMcpServerConfig");
+function editMcpServers(path, edit) {
+  const text = existsSync2(path) ? readFileSync2(path, "utf8") : void 0;
+  const parsed = text === void 0 ? {} : JSON.parse(text);
+  if (!isRecord(parsed) || parsed.mcpServers !== void 0 && !isRecord(parsed.mcpServers)) {
+    throw new Error(`${path}: expected an object with an "mcpServers" object`);
+  }
+  const servers = isRecord(parsed.mcpServers) ? parsed.mcpServers : void 0;
+  if (!edit(servers, parsed))
+    return;
+  const indent = text && /^([ \t]+)\S/m.exec(text)?.[1] || "  ";
+  mkdirSync2(dirname2(path), { recursive: true });
+  writeFileSync2(path, `${JSON.stringify(parsed, null, indent)}
+`);
+}
+__name(editMcpServers, "editMcpServers");
+
+export {
+  getProjectTrustOptions,
+  hasTrustRequiringProjectResources,
+  ProjectTrustStore,
+  openBrowser,
+  loadMcpConfig,
+  updateMcpServerConfig,
+  addMcpServerConfig,
+  removeMcpServerConfig
+};

package/dist-boot/c-IFSP3R4D.mjs

@@ -0,0 +1,80 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+import {
+  __name
+} from "./c-CN77DCGF.mjs";
+
+// node_modules/pi-background-tasks/src/core/delegate/types.ts?ext=pi-background-tasks
+var DELEGATE_SEED_SCHEMA_VERSION = "pi-background-tasks.delegate-seed.v2";
+var DELEGATE_LEDGER_SCHEMA_VERSION = "pi-background-tasks.delegate-ledger.v1";
+var DELEGATE_RESULT_PACKAGE_SCHEMA_VERSION = "pi-background-tasks.delegate-result.v1";
+var DELEGATE_RECEIPT_SCHEMA_VERSION = "pi-background-tasks.delegate-receipt.v1";
+var DELEGATE_BUDGET_PLAN_SCHEMA_VERSION = "pi-background-tasks.delegate-budget-plan.v3";
+var DELEGATE_MANIFEST_SCHEMA_VERSION = "pi-background-tasks.delegate-manifest.v2";
+var DELEGATE_CONTEXT_POLICY_ID = "delegate-inspect-v1";
+var DELEGATE_BRANCH_FILTER_ID = "exclude-active-delegate-batch-v1";
+var DELEGATE_TOOL_NAME = "bg_delegate";
+var DELEGATE_RESULT_TOOL_NAME = "bg_result";
+var DELEGATE_CAPABILITIES = ["inspect"];
+var DELEGATE_EXTENSION_MODES = ["isolated", "ambient"];
+var DELEGATE_AUTO_DELIVER_MODES = ["never", "when_small", "always"];
+var DelegateError = class extends Error {
+  static {
+    __name(this, "DelegateError");
+  }
+  code;
+  childCreated;
+  taskId;
+  artifactDir;
+  budget;
+  preserved;
+  remediation;
+  constructor(message, details) {
+    super(message);
+    this.name = "DelegateError";
+    this.code = details.code;
+    this.childCreated = details.childCreated ?? false;
+    this.taskId = details.taskId;
+    this.artifactDir = details.artifactDir;
+    this.budget = details.budget;
+    this.preserved = details.preserved ?? [];
+    this.remediation = details.remediation ?? [];
+  }
+  /** Operator-facing rendering: cause, preserved evidence, and next action. */
+  describe() {
+    const lines = [`[${this.code}] ${this.message}`];
+    lines.push(`Child process created: ${this.childCreated ? "yes" : "no"}`);
+    if (this.artifactDir !== void 0) lines.push(`Artifacts: ${this.artifactDir}`);
+    lines.push(
+      this.preserved.length > 0 ? `Preserved: ${this.preserved.join(", ")}` : "Preserved: nothing was written for this failure"
+    );
+    if (this.remediation.length > 0) lines.push(`Remediation: ${this.remediation.join(" ")}`);
+    return lines.join("\n");
+  }
+};
+
+// node_modules/pi-background-tasks/src/core/delegate/facade-contract.ts?ext=pi-background-tasks
+var DELEGATE_DEFAULT_MAX_TURNS = 24;
+var DELEGATE_DEFAULT_MAX_TOOL_CALLS = 120;
+var DELEGATE_DEFAULT_TIMEOUT_SECONDS = 1200;
+var DELEGATE_INLINE_ANSWER_BYTES = 48 * 1024;
+
+export {
+  DELEGATE_SEED_SCHEMA_VERSION,
+  DELEGATE_LEDGER_SCHEMA_VERSION,
+  DELEGATE_RESULT_PACKAGE_SCHEMA_VERSION,
+  DELEGATE_RECEIPT_SCHEMA_VERSION,
+  DELEGATE_BUDGET_PLAN_SCHEMA_VERSION,
+  DELEGATE_MANIFEST_SCHEMA_VERSION,
+  DELEGATE_CONTEXT_POLICY_ID,
+  DELEGATE_BRANCH_FILTER_ID,
+  DELEGATE_TOOL_NAME,
+  DELEGATE_RESULT_TOOL_NAME,
+  DELEGATE_CAPABILITIES,
+  DELEGATE_EXTENSION_MODES,
+  DELEGATE_AUTO_DELIVER_MODES,
+  DelegateError,
+  DELEGATE_DEFAULT_MAX_TURNS,
+  DELEGATE_DEFAULT_MAX_TOOL_CALLS,
+  DELEGATE_DEFAULT_TIMEOUT_SECONDS,
+  DELEGATE_INLINE_ANSWER_BYTES
+};

package/dist-boot/c-IZK77VB7.mjs

@@ -0,0 +1,171 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+import {
+  isRecord,
+  parseClassifierUsage,
+  postClassifierRequest,
+  requiredNumber
+} from "./c-WETGB2CF.mjs";
+import {
+  formatProviderError,
+  normalizeProviderError
+} from "./c-ZWUVHKMK.mjs";
+import "./c-EYZGSAJU.mjs";
+import "./c-ZJYLGIC3.mjs";
+import "./c-WO3QSZUU.mjs";
+import "./c-S2RVHR3M.mjs";
+import {
+  __name
+} from "./c-CN77DCGF.mjs";
+
+// node_modules/@earendil-works/pi-ai/dist/api/openai-decisions.js
+var LABEL = "OpenAI Decisions";
+var MAX_IMAGES = 128;
+function predicateInstructions(question) {
+  const meanings = [
+    question.criteria.true ? `True means: ${question.criteria.true}` : "",
+    question.criteria.false ? `False means: ${question.criteria.false}` : ""
+  ].filter(Boolean);
+  return meanings.length > 0 ? `${question.instructions}
+
+${meanings.join("\n")}` : question.instructions;
+}
+__name(predicateInstructions, "predicateInstructions");
+function wireQuestion(name, question) {
+  if (question.type === "choice") {
+    return {
+      type: "choice",
+      name,
+      instructions: question.instructions,
+      choices: Object.entries(question.criteria).map(([value, description]) => description ? { value, description } : { value })
+    };
+  }
+  if (question.type === "score") {
+    return {
+      type: "score",
+      name,
+      instructions: question.instructions,
+      levels: question.criteria.map((label) => ({ label }))
+    };
+  }
+  return { type: "predicate", name, instructions: predicateInstructions(question) };
+}
+__name(wireQuestion, "wireQuestion");
+function wireInput(context) {
+  const state = JSON.stringify(context.state);
+  const images = context.images ?? [];
+  if (images.length === 0)
+    return state;
+  if (images.length > MAX_IMAGES) {
+    throw new Error(`${LABEL} accepts at most ${MAX_IMAGES} images, got ${images.length}`);
+  }
+  return [
+    {
+      role: "user",
+      content: [
+        { type: "input_text", text: state },
+        ...images.map((image) => ({
+          type: "input_image",
+          image_url: `data:${image.mimeType};base64,${image.data}`
+        }))
+      ]
+    }
+  ];
+}
+__name(wireInput, "wireInput");
+function choiceProbabilities(value, id) {
+  if (!Array.isArray(value))
+    throw new Error(`${LABEL} returned invalid probabilities for ${id}`);
+  return Object.fromEntries(value.map((entry) => {
+    if (!isRecord(entry) || typeof entry.value !== "string") {
+      throw new Error(`${LABEL} returned invalid probabilities for ${id}`);
+    }
+    return [entry.value, requiredNumber(LABEL, entry.probability, `probability for ${id}.${entry.value}`)];
+  }));
+}
+__name(choiceProbabilities, "choiceProbabilities");
+function parseAnswer(id, question, answer) {
+  if (answer.type === "refusal")
+    throw new Error(`${LABEL} refused to answer ${id}`);
+  if (question.type === "choice") {
+    if (answer.type !== "choice" || typeof answer.choice !== "string") {
+      throw new Error(`${LABEL} did not return a choice answer for ${id}`);
+    }
+    return {
+      type: "choice",
+      choice: answer.choice,
+      probabilities: choiceProbabilities(answer.probabilities, id),
+      confidence: requiredNumber(LABEL, answer.confidence, `confidence for ${id}`)
+    };
+  }
+  if (question.type === "score") {
+    if (answer.type !== "score")
+      throw new Error(`${LABEL} did not return a score answer for ${id}`);
+    return {
+      type: "score",
+      score: requiredNumber(LABEL, answer.score, `score for ${id}`),
+      confidence: requiredNumber(LABEL, answer.confidence, `confidence for ${id}`)
+    };
+  }
+  if (answer.type !== "predicate")
+    throw new Error(`${LABEL} did not return a predicate answer for ${id}`);
+  return { type: "bool", probability: requiredNumber(LABEL, answer.probability, `probability for ${id}`) };
+}
+__name(parseAnswer, "parseAnswer");
+function parseAnswers(value, context) {
+  if (!Array.isArray(value))
+    throw new Error(`${LABEL} returned an unexpected response`);
+  const byName = /* @__PURE__ */ new Map();
+  for (const answer of value) {
+    if (isRecord(answer) && typeof answer.name === "string")
+      byName.set(answer.name, answer);
+  }
+  return Object.fromEntries(Object.entries(context.questions).map(([id, question]) => {
+    const answer = byName.get(id);
+    if (!answer)
+      throw new Error(`${LABEL} did not return an answer for ${id}`);
+    return [id, parseAnswer(id, question, answer)];
+  }));
+}
+__name(parseAnswers, "parseAnswers");
+var NO_RETRY_STATUSES = [504];
+function errorMessage(error) {
+  if (error.status === 504) {
+    return `${LABEL} error (504): the request timed out at the gateway. Very large inputs (above roughly 600K tokens) currently exceed its time limit.`;
+  }
+  return formatProviderError(normalizeProviderError(error), `${LABEL} error`);
+}
+__name(errorMessage, "errorMessage");
+var classify = /* @__PURE__ */ __name(async (model, context, options) => {
+  const output = {
+    api: model.api,
+    provider: model.provider,
+    model: model.id,
+    answers: {},
+    stopReason: "stop",
+    timestamp: Date.now()
+  };
+  try {
+    if (model.api !== "openai-decisions")
+      throw new Error(`Unsupported classifier API: ${model.api}`);
+    const body = await postClassifierRequest(LABEL, new URL("decisions", `${model.baseUrl.replace(/\/+$/u, "")}/`), model, {
+      model: model.id,
+      input: wireInput(context),
+      questions: Object.entries(context.questions).map(([id, question]) => wireQuestion(id, question))
+    }, options, NO_RETRY_STATUSES);
+    if (!isRecord(body))
+      throw new Error(`${LABEL} returned an unexpected response`);
+    const usage = parseClassifierUsage(body.usage, model);
+    if (usage)
+      output.usage = usage;
+    output.answers = parseAnswers(body.answers, context);
+    return output;
+  } catch (error) {
+    output.answers = {};
+    output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+    output.errorMessage = errorMessage(error);
+    return output;
+  }
+}, "classify");
+export {
+  classify
+};

package/dist-boot/c-J3Y25UGE.mjs

@@ -0,0 +1,54 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+import {
+  classifySystemOne
+} from "./c-TT6BCUJD.mjs";
+import {
+  isRecord
+} from "./c-WETGB2CF.mjs";
+import "./c-ZWUVHKMK.mjs";
+import "./c-EYZGSAJU.mjs";
+import "./c-ZJYLGIC3.mjs";
+import "./c-WO3QSZUU.mjs";
+import "./c-S2RVHR3M.mjs";
+import {
+  __name
+} from "./c-CN77DCGF.mjs";
+
+// node_modules/@earendil-works/pi-ai/dist/api/cloudflare-workers-ai-system-one.js
+var LABEL = "Cloudflare Workers AI";
+function cloudflareErrorMessage(errors) {
+  if (Array.isArray(errors)) {
+    const messages = errors.map((error) => isRecord(error) && typeof error.message === "string" ? error.message : void 0).filter((message) => message !== void 0);
+    if (messages.length > 0)
+      return `${LABEL} error: ${messages.join("; ")}`;
+  }
+  return `${LABEL} request failed`;
+}
+__name(cloudflareErrorMessage, "cloudflareErrorMessage");
+var transport = {
+  api: "cloudflare-workers-ai-system-one",
+  label: LABEL,
+  url: /* @__PURE__ */ __name((model) => new URL("run", `${model.baseUrl.replace(/\/+$/u, "")}/`), "url"),
+  payload: /* @__PURE__ */ __name((model, request) => ({ model: model.id, input: request }), "payload"),
+  output: /* @__PURE__ */ __name((body) => {
+    if (!isRecord(body))
+      throw new Error(`${LABEL} returned an unexpected response`);
+    if (body.success === false)
+      throw new Error(cloudflareErrorMessage(body.errors));
+    const result = body.result;
+    if (!isRecord(result))
+      throw new Error(`${LABEL} returned an unexpected response`);
+    if ("answers" in result)
+      return result;
+    if (result.state !== "Completed") {
+      throw new Error(`${LABEL} run did not complete (state: ${String(result.state)})`);
+    }
+    if (!isRecord(result.result))
+      throw new Error(`${LABEL} returned an unexpected response`);
+    return result.result;
+  }, "output")
+};
+var classify = /* @__PURE__ */ __name((model, context, options) => classifySystemOne(transport, model, context, options), "classify");
+export {
+  classify
+};