@tokensize/agent-client 0.3.0-beta.0

package/dist/index.js

@@ -0,0 +1,1131 @@
+// src/index.ts
+import { createHash, createHmac, randomBytes, randomUUID as randomUUID2, timingSafeEqual } from "crypto";
+import { access as access3, mkdir as mkdir4, readFile as readFile4, rename as rename4, writeFile as writeFile4 } from "fs/promises";
+import { createServer } from "http";
+import path4 from "path";
+import { execFile } from "child_process";
+import {
+  AGENT_ROUTER_SCHEMA_VERSION,
+  agentRouteResponseSchema,
+  featurizeAgentTask,
+  runEventSchema
+} from "@tokensize/agent-router";
+
+// src/local/discovery.ts
+import { access, mkdir as mkdir2, readFile as readFile2, rename as rename2, writeFile as writeFile2 } from "fs/promises";
+import os2 from "os";
+import path2 from "path";
+
+// src/local/config.ts
+import { mkdir, readFile, rename, writeFile } from "fs/promises";
+import os from "os";
+import path from "path";
+import { randomUUID } from "crypto";
+function home() {
+  return process.env.TOKENSIZE_HOME ?? path.join(os.homedir(), ".tokensize");
+}
+async function saveApiKey(apiKey) {
+  const directory = home();
+  const file = path.join(directory, "credentials.json");
+  const temporary = `${file}.${process.pid}.${randomUUID()}.tmp`;
+  await mkdir(directory, { recursive: true, mode: 448 });
+  await writeFile(temporary, `${JSON.stringify({ apiKey }, null, 2)}
+`, { mode: 384 });
+  await rename(temporary, file);
+}
+async function readApiKey() {
+  try {
+    const value = JSON.parse(await readFile(path.join(home(), "credentials.json"), "utf8"));
+    return typeof value.apiKey === "string" && value.apiKey.length > 0 ? value.apiKey : null;
+  } catch {
+    return null;
+  }
+}
+async function installationId() {
+  const file = path.join(home(), "config.json");
+  try {
+    const data = JSON.parse(await readFile(file, "utf8"));
+    if (data.installationId) return data.installationId;
+  } catch {
+  }
+  const id = randomUUID();
+  const temporary = `${file}.${process.pid}.${randomUUID()}.tmp`;
+  await mkdir(home(), { recursive: true, mode: 448 });
+  await writeFile(temporary, `${JSON.stringify({ installationId: id }, null, 2)}
+`, { mode: 384 });
+  await rename(temporary, file);
+  return id;
+}
+var OBJECTIVES = ["quality", "balanced", "tokens", "latency"];
+var PERMISSIONS = ["inspect", "edit", "test", "network"];
+function policyFile() {
+  return path.join(home(), "policy.json");
+}
+function sanitizePolicy(value) {
+  const policy = {};
+  if (typeof value.rootHarness === "string" && value.rootHarness.length > 0 && value.rootHarness.length <= 50) policy.rootHarness = value.rootHarness;
+  if (typeof value.rootQualityPrior === "number" && value.rootQualityPrior >= 0 && value.rootQualityPrior <= 1) policy.rootQualityPrior = value.rootQualityPrior;
+  if (OBJECTIVES.includes(value.objective)) policy.objective = value.objective;
+  if (PERMISSIONS.includes(value.permissionCeiling)) policy.permissionCeiling = value.permissionCeiling;
+  if (typeof value.maxDelegationDepth === "number" && Number.isInteger(value.maxDelegationDepth) && value.maxDelegationDepth >= 0 && value.maxDelegationDepth <= 3) policy.maxDelegationDepth = value.maxDelegationDepth;
+  if (Array.isArray(value.subscriptionHarnesses)) policy.subscriptionHarnesses = value.subscriptionHarnesses.filter((item) => typeof item === "string" && item.length > 0 && item.length <= 50).slice(0, 10);
+  if (typeof value.sharePromptDefault === "boolean") policy.sharePromptDefault = value.sharePromptDefault;
+  return policy;
+}
+async function readLocalPolicy() {
+  try {
+    return sanitizePolicy(JSON.parse(await readFile(policyFile(), "utf8")));
+  } catch {
+    return {};
+  }
+}
+async function saveLocalPolicy(patch) {
+  const current = await readLocalPolicy();
+  const merged = sanitizePolicy({ ...current, ...patch });
+  const file = policyFile();
+  const temporary = `${file}.${process.pid}.${randomUUID()}.tmp`;
+  await mkdir(home(), { recursive: true, mode: 448 });
+  await writeFile(temporary, `${JSON.stringify(merged, null, 2)}
+`, { mode: 384 });
+  await rename(temporary, file);
+  return merged;
+}
+async function saveLastRoute(receipt) {
+  const directory = home();
+  const file = path.join(directory, "last-route.json");
+  const temporary = `${file}.${process.pid}.${randomUUID()}.tmp`;
+  await mkdir(directory, { recursive: true, mode: 448 });
+  await writeFile(temporary, `${JSON.stringify(receipt, null, 2)}
+`, { mode: 384 });
+  await rename(temporary, file);
+}
+async function readLastRoute() {
+  const value = JSON.parse(await readFile(path.join(home(), "last-route.json"), "utf8"));
+  if (typeof value.routeId !== "string" || typeof value.feedbackToken !== "string" || typeof value.expiresAt !== "string") {
+    throw new Error("invalid local route receipt");
+  }
+  return {
+    routeId: value.routeId,
+    ...typeof value.runId === "string" ? { runId: value.runId } : {},
+    feedbackToken: value.feedbackToken,
+    expiresAt: value.expiresAt,
+    targetId: value.targetId ?? null
+  };
+}
+
+// src/local/process.ts
+import { spawn } from "child_process";
+function terminateProcessTree(child, signal) {
+  if (process.platform !== "win32" && child.pid) {
+    try {
+      process.kill(-child.pid, signal);
+      return;
+    } catch {
+    }
+  }
+  try {
+    child.kill(signal);
+  } catch {
+  }
+}
+async function run(command, args, options = {}) {
+  return await new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      shell: false,
+      detached: process.platform !== "win32",
+      env: options.env ?? process.env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "", stderr = "", timedOut = false;
+    let settled = false;
+    const max = options.maxBytes ?? 8e6;
+    child.stdout.on("data", (data) => {
+      if (stdout.length < max) stdout += data.toString().slice(0, max - stdout.length);
+    });
+    child.stderr.on("data", (data) => {
+      if (stderr.length < max) stderr += data.toString().slice(0, max - stderr.length);
+    });
+    let forceTimer;
+    let timer;
+    const finish = (code) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      if (forceTimer) clearTimeout(forceTimer);
+      resolve({ code, stdout, stderr, timedOut });
+    };
+    child.on("error", (error) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      if (forceTimer) clearTimeout(forceTimer);
+      reject(error);
+    });
+    timer = setTimeout(() => {
+      timedOut = true;
+      terminateProcessTree(child, "SIGTERM");
+      forceTimer = setTimeout(() => {
+        terminateProcessTree(child, "SIGKILL");
+        child.stdin.destroy();
+        child.stdout.destroy();
+        child.stderr.destroy();
+        child.unref();
+        finish(null);
+      }, 1e3);
+    }, options.timeoutMs ?? 15e3);
+    child.on("close", finish);
+    if (options.input) child.stdin.end(options.input);
+    else child.stdin.end();
+  });
+}
+
+// src/local/discovery.ts
+var DISCOVERY_CACHE_VERSION = 5;
+var DEFAULT_DISCOVERY_CACHE_TTL_MS = 6 * 60 * 60 * 1e3;
+var INCOMPLETE_DISCOVERY_CACHE_TTL_MS = 5 * 60 * 1e3;
+var HARNESS_PROBE_DEADLINE_MS = 12e3;
+async function executable(names) {
+  const directories = [...new Set([process.env.NVM_BIN, process.env.VOLTA_HOME ? path2.join(process.env.VOLTA_HOME, "bin") : void 0, path2.dirname(process.execPath), ...(process.env.PATH ?? "").split(path2.delimiter), path2.join(os2.homedir(), ".local", "bin"), path2.join(os2.homedir(), ".opencode", "bin")].filter((value) => Boolean(value)))];
+  for (const name of names) for (const directory of directories) {
+    const candidate = path2.join(directory, name);
+    try {
+      await access(candidate);
+      return candidate;
+    } catch {
+    }
+  }
+}
+function subscriptionApproved(harness) {
+  return (process.env.TOKENSIZE_ALLOW_SUBSCRIPTION_HARNESSES ?? "").split(",").map((v) => v.trim()).includes(harness);
+}
+function discoveryCacheFile() {
+  return path2.join(home(), "discovery.json");
+}
+function discoveryCacheTtlMs() {
+  const value = Number(process.env.TOKENSIZE_DISCOVERY_CACHE_TTL_MS ?? DEFAULT_DISCOVERY_CACHE_TTL_MS);
+  return Number.isFinite(value) && value >= 0 ? value : DEFAULT_DISCOVERY_CACHE_TTL_MS;
+}
+function discoveryFingerprint() {
+  return JSON.stringify({
+    path: process.env.PATH ?? "",
+    nvmBin: process.env.NVM_BIN ?? "",
+    voltaHome: process.env.VOLTA_HOME ?? "",
+    claudeModels: process.env.TOKENSIZE_CLAUDE_MODELS ?? "",
+    copilotModels: process.env.TOKENSIZE_COPILOT_MODELS ?? ""
+  });
+}
+function model(harness, id, name, approved, authMode = "subscription", priors = {}) {
+  return { id: `${harness}:${id}`, harness, nativeModelId: id, displayName: name, readiness: "model-listed", authMode, productUseApproved: approved, capabilities: { tools: true, vision: harness === "codex" || harness === "claude", structuredOutput: harness === "codex" ? "jsonl" : "json", sessions: "resume", permissions: ["inspect", "edit", "test", "network"] }, identityProof: "runtime-reported", qualityPrior: priors.qualityPrior ?? 0.9, tokenEfficiencyPrior: priors.tokenEfficiencyPrior ?? 0.72, latencyPrior: priors.latencyPrior ?? 0.65 };
+}
+async function codex() {
+  const exe = await executable(["codex"]);
+  if (!exe) return { harness: "codex", installed: false, authenticated: false, models: [], warnings: [] };
+  const [version, auth] = await Promise.all([
+    run(exe, ["--version"], { timeoutMs: 5e3, maxBytes: 64e3 }),
+    run(exe, ["login", "status"], { timeoutMs: 5e3, maxBytes: 64e3 })
+  ]);
+  const child = await import("child_process").then(({ spawn: spawn3 }) => spawn3(exe, ["app-server", "--stdio"], {
+    detached: process.platform !== "win32",
+    shell: false,
+    stdio: ["pipe", "pipe", "ignore"]
+  }));
+  const models = await new Promise((resolve) => {
+    let buffer = "", done = false;
+    const finish = (value) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      terminateProcessTree(child, "SIGTERM");
+      resolve(value);
+    };
+    const timer = setTimeout(() => finish([]), 8e3);
+    child.once("error", () => finish([]));
+    child.stdout.on("data", (chunk) => {
+      if (buffer.length >= 2e6) return finish([]);
+      buffer += chunk.toString();
+      let newline;
+      while ((newline = buffer.indexOf("\n")) >= 0) {
+        const line = buffer.slice(0, newline);
+        buffer = buffer.slice(newline + 1);
+        try {
+          const message = JSON.parse(line);
+          if (message.id === 1) {
+            child.stdin.write(JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" }) + "\n");
+            child.stdin.write(JSON.stringify({ jsonrpc: "2.0", id: 2, method: "model/list", params: { includeHidden: false, limit: 100 } }) + "\n");
+          }
+          if (message.id === 2) {
+            const apiKey = Boolean(process.env.OPENAI_API_KEY);
+            finish((message.result?.data ?? []).map((m, index) => model("codex", m.id, m.displayName ?? m.id, apiKey || subscriptionApproved("codex"), apiKey ? "api-key" : "subscription", { qualityPrior: Math.max(0.82, 0.97 - index * 0.04), tokenEfficiencyPrior: /mini/i.test(m.id) ? 0.94 : Math.min(0.88, 0.76 + index * 0.03), latencyPrior: /mini/i.test(m.id) ? 0.94 : 0.68 })));
+          }
+        } catch {
+        }
+      }
+    });
+    child.stdin.write(JSON.stringify({ jsonrpc: "2.0", id: 1, method: "initialize", params: { clientInfo: { name: "tokensize", version: "0.1.0" }, capabilities: { experimentalApi: true } } }) + "\n");
+  });
+  return { harness: "codex", installed: true, executable: exe, version: version.stdout.trim(), authenticated: auth.code === 0, models, warnings: models.length ? [] : ["Codex model catalog was unavailable"] };
+}
+async function generic(harness, names) {
+  const exe = await executable(names);
+  if (!exe) return { harness, installed: false, authenticated: false, models: [], warnings: [] };
+  const [version, claudeAuth, help] = await Promise.all([
+    run(exe, ["--version"], { timeoutMs: 5e3, maxBytes: 64e3 }),
+    harness === "claude" ? run(exe, ["auth", "status"], { timeoutMs: 8e3, maxBytes: 64e3 }) : Promise.resolve(void 0),
+    harness === "claude" ? run(exe, ["--help"], { timeoutMs: 5e3, maxBytes: 256e3 }) : Promise.resolve(void 0)
+  ]);
+  let authenticated = harness !== "copilot";
+  if (harness === "claude") {
+    authenticated = claudeAuth?.code === 0;
+  }
+  if (harness === "copilot") authenticated = Boolean(process.env.GH_TOKEN || process.env.GITHUB_TOKEN);
+  const cliReported = harness === "claude" ? [.../* @__PURE__ */ new Set([...(help?.stdout.match(/'([a-z][a-z0-9.-]+)'/g) ?? []).map((value) => value.slice(1, -1)), ...help?.stdout.match(/claude-[a-z0-9.-]+/g) ?? []])].filter((id) => ["fable", "opus", "sonnet"].includes(id) || id.startsWith("claude-")) : [];
+  const configured = [.../* @__PURE__ */ new Set([...(process.env[`TOKENSIZE_${harness.toUpperCase()}_MODELS`] ?? "").split(",").map((v) => v.trim()).filter(Boolean), ...cliReported])];
+  const apiKey = harness === "claude" && Boolean(process.env.ANTHROPIC_API_KEY);
+  const approved = apiKey || subscriptionApproved(harness);
+  const warnings = configured.length ? [] : [`Set TOKENSIZE_${harness.toUpperCase()}_MODELS to advertise supported models`];
+  if (harness === "copilot" && !authenticated) warnings.push("Copilot CLI has no non-interactive auth-status command; set GH_TOKEN/GITHUB_TOKEN or verify authentication before advertising models");
+  return { harness, installed: true, executable: exe, version: version.stdout.trim(), authenticated, models: configured.map((id) => model(harness, id, id, approved, apiKey ? "api-key" : "subscription")), warnings };
+}
+async function cursor() {
+  const exe = await executable(["agent", "cursor-agent"]);
+  if (!exe) return { harness: "cursor", installed: false, authenticated: false, models: [], warnings: [] };
+  const [version, auth, catalog] = await Promise.all([
+    run(exe, ["--version"], { timeoutMs: 5e3, maxBytes: 64e3 }),
+    run(exe, ["status"], { timeoutMs: 8e3, maxBytes: 64e3 }),
+    run(exe, ["--list-models"], { timeoutMs: 1e4, maxBytes: 512e3 })
+  ]);
+  const available = catalog.stdout.split(/\r?\n/).flatMap((line) => {
+    const match = /^(\S+)\s+-\s+(.+)$/.exec(line.trim());
+    return match ? [{ id: match[1], name: match[2] }] : [];
+  });
+  const preferred = [
+    /^gpt-5\.6-sol-high$/,
+    /^claude-opus-4-8-high$/,
+    /^claude-fable-5-high$/,
+    /^claude-sonnet-5-high$/,
+    /^cursor-grok-4\.5-high$/,
+    /^composer-2\.5$/,
+    /^gpt-5\.5-high$/,
+    /^gpt-5\.4-high$/
+  ];
+  const selected = preferred.flatMap((pattern) => available.find((item) => pattern.test(item.id)) ?? []);
+  const approved = subscriptionApproved("cursor");
+  const models = selected.map((item, index) => {
+    const candidate = model("cursor", item.id, item.name, approved, "subscription", { qualityPrior: Math.max(0.84, 0.98 - index * 0.018), tokenEfficiencyPrior: /composer|grok/i.test(item.id) ? 0.86 : 0.72, latencyPrior: /composer|grok/i.test(item.id) ? 0.82 : 0.66 });
+    candidate.capabilities.permissions = ["inspect"];
+    return candidate;
+  });
+  return { harness: "cursor", installed: true, executable: exe, version: version.stdout.trim(), authenticated: auth.code === 0 && /logged in/i.test(auth.stdout), models, warnings: models.length ? [] : ["Cursor model catalog did not contain a supported frontier model"] };
+}
+function stripAnsi(value) {
+  return value.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "");
+}
+function opencodeModelIds(output) {
+  return [...new Set(stripAnsi(output).split(/\r?\n/).map((line) => line.trim()).filter((line) => /^[a-z0-9][a-z0-9._-]*\/[a-z0-9][a-z0-9._:/-]*$/i.test(line)))];
+}
+function isCredentialFreeOpenCodeModel(id) {
+  return /^opencode\/(?:big-pickle|[a-z0-9._:/-]+-free)$/i.test(id);
+}
+async function opencode() {
+  const exe = await executable(["opencode"]);
+  if (!exe) return { harness: "opencode", installed: false, authenticated: false, models: [], warnings: [] };
+  const [version, auth, initialCatalog] = await Promise.all([
+    run(exe, ["--version"], { timeoutMs: 5e3, maxBytes: 64e3 }),
+    run(exe, ["auth", "list"], { timeoutMs: 8e3, maxBytes: 128e3 }),
+    run(exe, ["models"], { timeoutMs: 1e4, maxBytes: 512e3 })
+  ]);
+  const available = opencodeModelIds(initialCatalog.stdout);
+  const credentialFree = available.filter(isCredentialFreeOpenCodeModel);
+  const frontier = available.filter((id) => /gpt-5\.[4-9]|opus|fable|sonnet|grok|gemini|glm|qwen|coder/i.test(id));
+  const ids = [.../* @__PURE__ */ new Set([...credentialFree, ...frontier.length ? frontier : available])].slice(0, 48);
+  const authOutput = stripAnsi(`${auth.stdout}
+${auth.stderr}`).trim();
+  const hasStoredCredentials = auth.code === 0 && authOutput.length > 0 && !/\b(?:no|0)\s+(?:credentials|providers|authentication)\b/i.test(authOutput);
+  const authenticated = hasStoredCredentials || credentialFree.length > 0;
+  const subscriptionIsApproved = subscriptionApproved("opencode");
+  const models = ids.map((id, index) => {
+    const isCredentialFree = isCredentialFreeOpenCodeModel(id);
+    const candidate = model("opencode", id, id, isCredentialFree || subscriptionIsApproved, isCredentialFree ? "cloud-provider" : "subscription", {
+      qualityPrior: Math.max(0.82, 0.96 - index * 0.01),
+      tokenEfficiencyPrior: 0.76,
+      latencyPrior: 0.7
+    });
+    candidate.capabilities.permissions = ["inspect"];
+    candidate.capabilities.vision = false;
+    return candidate;
+  });
+  const warnings = [];
+  if (!hasStoredCredentials && credentialFree.length) warnings.push(`OpenCode has no stored provider credentials; ${credentialFree.length} credential-free model(s) remain available`);
+  else if (!hasStoredCredentials) warnings.push("OpenCode did not report a configured provider credential");
+  if (!models.length) warnings.push("OpenCode model catalog was unavailable; run `opencode models --refresh`");
+  if (!subscriptionIsApproved && models.some((item) => item.authMode === "subscription")) warnings.push("Paid/provider OpenCode models remain ineligible; set TOKENSIZE_ALLOW_SUBSCRIPTION_HARNESSES=opencode only when provider and product terms permit delegated use");
+  return { harness: "opencode", installed: true, executable: exe, version: version.stdout.trim(), authenticated, models, warnings };
+}
+var HARNESS_IDS = ["codex", "claude", "copilot", "cursor", "opencode"];
+async function discoverHarness(harness) {
+  let probe;
+  switch (harness) {
+    case "codex":
+      probe = codex;
+      break;
+    case "claude":
+      probe = () => generic("claude", ["claude"]);
+      break;
+    case "copilot":
+      probe = () => generic("copilot", ["copilot", "github-copilot-cli"]);
+      break;
+    case "cursor":
+      probe = cursor;
+      break;
+    case "opencode":
+      probe = opencode;
+      break;
+    case "custom":
+      return { harness: "custom", installed: false, authenticated: false, models: [], warnings: ["No custom harness adapter is configured"] };
+  }
+  let timer;
+  const deadline = new Promise((resolve) => {
+    timer = setTimeout(() => resolve({
+      harness,
+      installed: true,
+      authenticated: false,
+      models: [],
+      warnings: [`${harness} discovery exceeded the ${HARNESS_PROBE_DEADLINE_MS / 1e3}s safety deadline; retry with --refresh`],
+      probeTimedOut: true
+    }), HARNESS_PROBE_DEADLINE_MS);
+  });
+  return Promise.race([probe().finally(() => {
+    if (timer) clearTimeout(timer);
+  }), deadline]);
+}
+async function discoverHarnesses() {
+  const [codexResult, cursorResult] = await Promise.all([discoverHarness("codex"), discoverHarness("cursor")]);
+  const [claudeResult, copilotResult, opencodeResult] = await Promise.all([
+    discoverHarness("claude"),
+    discoverHarness("copilot"),
+    discoverHarness("opencode")
+  ]);
+  return [codexResult, claudeResult, copilotResult, cursorResult, opencodeResult];
+}
+function applyCurrentApproval(harnesses) {
+  return harnesses.map((item) => ({
+    ...item,
+    models: item.models.map((candidate) => {
+      const apiKeyMode = candidate.harness === "codex" && Boolean(process.env.OPENAI_API_KEY) || candidate.harness === "claude" && Boolean(process.env.ANTHROPIC_API_KEY);
+      const credentialFree = candidate.harness === "opencode" && isCredentialFreeOpenCodeModel(candidate.nativeModelId);
+      return {
+        ...candidate,
+        authMode: credentialFree ? "cloud-provider" : apiKeyMode ? "api-key" : "subscription",
+        productUseApproved: credentialFree || apiKeyMode || subscriptionApproved(candidate.harness)
+      };
+    })
+  }));
+}
+async function cachedExecutablesExist(harnesses) {
+  try {
+    await Promise.all(harnesses.filter((item) => item.installed && !item.probeTimedOut).map((item) => item.executable ? access(item.executable) : Promise.reject(new Error("cached installed harness has no executable"))));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readDiscoveryCache() {
+  const file = discoveryCacheFile();
+  try {
+    const cached = JSON.parse(await readFile2(file, "utf8"));
+    if (cached.schemaVersion !== DISCOVERY_CACHE_VERSION || cached.fingerprint !== discoveryFingerprint() || !cached.createdAt || !cached.expiresAt || !Array.isArray(cached.harnesses) || Date.parse(cached.expiresAt) <= Date.now() || !await cachedExecutablesExist(cached.harnesses)) return null;
+    return {
+      harnesses: applyCurrentApproval(cached.harnesses),
+      cache: { hit: true, path: file, createdAt: cached.createdAt, expiresAt: cached.expiresAt, ageMs: Math.max(0, Date.now() - Date.parse(cached.createdAt)) }
+    };
+  } catch {
+    return null;
+  }
+}
+async function writeDiscoveryCache(harnesses, reason) {
+  const directory = home();
+  const file = discoveryCacheFile();
+  const temporary = `${file}.${process.pid}.tmp`;
+  const createdAt = /* @__PURE__ */ new Date();
+  const cacheTtl = harnesses.some((item) => item.probeTimedOut) ? Math.min(discoveryCacheTtlMs(), INCOMPLETE_DISCOVERY_CACHE_TTL_MS) : discoveryCacheTtlMs();
+  const value = {
+    schemaVersion: DISCOVERY_CACHE_VERSION,
+    createdAt: createdAt.toISOString(),
+    expiresAt: new Date(createdAt.getTime() + cacheTtl).toISOString(),
+    fingerprint: discoveryFingerprint(),
+    harnesses
+  };
+  await mkdir2(directory, { recursive: true, mode: 448 });
+  await writeFile2(temporary, `${JSON.stringify(value, null, 2)}
+`, { mode: 384 });
+  await rename2(temporary, file);
+  return { hit: false, refreshed: true, reason, path: file, createdAt: value.createdAt, expiresAt: value.expiresAt, ageMs: 0 };
+}
+async function discoverHarnessesCached(options = {}) {
+  if (!options.forceRefresh) {
+    const cached = await readDiscoveryCache();
+    if (cached) return cached;
+  }
+  const harnesses = await discoverHarnesses();
+  const reason = options.reason ?? (options.forceRefresh ? "manual" : "miss-or-stale");
+  try {
+    return { harnesses, cache: await writeDiscoveryCache(harnesses, reason) };
+  } catch (error) {
+    return {
+      harnesses,
+      cache: { hit: false, refreshed: true, persisted: false, reason, warning: `could not persist discovery cache: ${error instanceof Error ? error.message : String(error)}` }
+    };
+  }
+}
+function flattenModels(discovery, maximum = 100) {
+  const queues = discovery.filter((item) => item.authenticated).map((item) => [...item.models]);
+  const selected = [];
+  while (selected.length < maximum && queues.some((queue) => queue.length)) {
+    for (const queue of queues) {
+      const next = queue.shift();
+      if (next) selected.push(next);
+      if (selected.length === maximum) break;
+    }
+  }
+  return selected;
+}
+
+// src/local/allowance.ts
+import { spawn as spawn2 } from "child_process";
+import { access as access2, mkdir as mkdir3, readFile as readFile3, rename as rename3, writeFile as writeFile3 } from "fs/promises";
+import path3 from "path";
+var CACHE_VERSION = 1;
+var DEFAULT_TTL_MS = 5 * 60 * 1e3;
+function observed(status2, source, remainingFraction, resetsAt) {
+  const normalized = remainingFraction === void 0 ? void 0 : Math.round(Math.max(0, Math.min(1, remainingFraction)) * 1e4) / 1e4;
+  return {
+    status: status2,
+    source,
+    observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...normalized === void 0 ? {} : { remainingFraction: normalized },
+    ...resetsAt ? { resetsAt } : {}
+  };
+}
+function status(remaining) {
+  if (remaining <= 0) return "exhausted";
+  if (remaining <= 0.15) return "low";
+  return "available";
+}
+function unknown() {
+  return observed("unknown", "unavailable");
+}
+function cacheFile() {
+  return path3.join(home(), "allowance.json");
+}
+function ttlMs() {
+  const value = Number(process.env.TOKENSIZE_ALLOWANCE_CACHE_TTL_MS ?? DEFAULT_TTL_MS);
+  return Number.isFinite(value) && value >= 0 ? value : DEFAULT_TTL_MS;
+}
+async function codexAllowance(executable2) {
+  return await new Promise((resolve) => {
+    const child = spawn2(executable2, ["app-server", "--stdio"], { shell: false, stdio: ["pipe", "pipe", "ignore"] });
+    let buffer = "";
+    let complete = false;
+    const finish = (value) => {
+      if (complete) return;
+      complete = true;
+      clearTimeout(timer);
+      child.kill();
+      resolve(value);
+    };
+    const timer = setTimeout(() => finish(unknown()), 15e3);
+    child.once("error", () => finish(unknown()));
+    child.stdout.on("data", (chunk) => {
+      buffer += chunk.toString();
+      let newline;
+      while ((newline = buffer.indexOf("\n")) >= 0) {
+        const line = buffer.slice(0, newline);
+        buffer = buffer.slice(newline + 1);
+        try {
+          const message = JSON.parse(line);
+          if (message.id === 1) {
+            child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" })}
+`);
+            child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id: 2, method: "account/rateLimits/read" })}
+`);
+          }
+          if (message.id === 2) {
+            const limits = message.result?.rateLimits;
+            if (!limits) return finish(unknown());
+            if (limits.rateLimitReachedType) return finish(observed("exhausted", "runtime-reported", 0));
+            const windows = [limits.primary, limits.secondary].filter((value) => Boolean(value)).flatMap((value) => typeof value.usedPercent === "number" ? [{ remaining: 1 - value.usedPercent / 100, resetsAt: value.resetsAt }] : []);
+            if (typeof limits.individualLimit?.remainingPercent === "number") {
+              windows.push({ remaining: limits.individualLimit.remainingPercent / 100, resetsAt: limits.individualLimit.resetsAt });
+            }
+            if (!windows.length && limits.credits?.unlimited) return finish(observed("unmetered", "runtime-reported"));
+            if (!windows.length) return finish(unknown());
+            const constrained = windows.sort((a, b) => a.remaining - b.remaining)[0];
+            const remaining = Math.max(0, Math.min(1, constrained.remaining));
+            const resetsAt = constrained.resetsAt ? new Date(constrained.resetsAt * 1e3).toISOString() : void 0;
+            return finish(observed(status(remaining), "runtime-reported", remaining, resetsAt));
+          }
+        } catch {
+        }
+      }
+    });
+    child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id: 1, method: "initialize", params: { clientInfo: { name: "tokensize", version: "0.1.0" }, capabilities: { experimentalApi: true } } })}
+`);
+  });
+}
+function stripTerminal(value) {
+  return value.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "").replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "").replace(/\r/g, "\n");
+}
+function usedPercent(text, label) {
+  const match = label.exec(text);
+  if (match?.index === void 0) return void 0;
+  const nearby = text.slice(match.index, match.index + 260);
+  const percentage = /(\d{1,3})%\s*used/i.exec(nearby);
+  return percentage ? Math.max(0, Math.min(100, Number(percentage[1]))) : void 0;
+}
+function parseClaudeUsage(raw) {
+  const text = stripTerminal(raw);
+  const usageScreen = text.slice(Math.max(0, text.lastIndexOf("Settings")));
+  const ordered = [...usageScreen.matchAll(/(\d{1,3})\s*%\s*used/gi)].map((match) => Math.max(0, Math.min(100, Number(match[1]))));
+  const exactSession = usedPercent(text, /Current\s+session/i);
+  const exactGeneral = usedPercent(text, /Current\s+week\s*\(all\s+models\)/i);
+  const exactFable = usedPercent(text, /Current\s+week\s*\(Fable\)/i);
+  const sessionUsed = exactSession ?? ordered[0];
+  const weeklyUsed = exactGeneral ?? ordered[1] ?? ordered[0];
+  const fableUsed = exactFable ?? ordered[2];
+  const generalUsed = [sessionUsed, weeklyUsed].filter((value) => value !== void 0);
+  const generalRemaining = generalUsed.length ? 1 - Math.max(...generalUsed) / 100 : void 0;
+  const defaultAllowance = generalRemaining === void 0 ? unknown() : observed(status(generalRemaining), "runtime-reported", generalRemaining);
+  const byModelId = {};
+  if (fableUsed !== void 0) {
+    const remaining = Math.min(generalRemaining ?? 1, 1 - fableUsed / 100);
+    byModelId.fable = observed(status(remaining), "runtime-reported", remaining);
+  }
+  return { default: defaultAllowance, ...Object.keys(byModelId).length ? { byModelId } : {} };
+}
+async function claudeAllowance(executable2) {
+  if (process.platform !== "darwin") return { default: unknown() };
+  try {
+    await access2("/usr/bin/expect");
+  } catch {
+    return { default: unknown() };
+  }
+  return await new Promise((resolve) => {
+    const script = 'set timeout 10; log_user 1; spawn -noecho $env(TOKENSIZE_CLAUDE_EXECUTABLE) --safe-mode; after 1800; send -- "/usage\\r"; after 700; send -- "\\r"; expect -re {Current}; after 3500; exit 0';
+    const child = spawn2("/usr/bin/expect", ["-c", script], {
+      env: { ...process.env, TERM: "xterm-256color", TOKENSIZE_CLAUDE_EXECUTABLE: executable2 },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let raw = "";
+    let complete = false;
+    const finish = () => {
+      if (complete) return;
+      complete = true;
+      clearTimeout(timeout);
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      const parsed = parseClaudeUsage(raw);
+      raw = "";
+      resolve(parsed);
+    };
+    const timeout = setTimeout(finish, 13e3);
+    child.once("error", finish);
+    const collect2 = (chunk) => {
+      if (raw.length < 256e3) raw += chunk.toString().slice(0, 256e3 - raw.length);
+    };
+    child.stdout.on("data", collect2);
+    child.stderr.on("data", collect2);
+    child.once("close", finish);
+  });
+}
+async function collect(discovery) {
+  const result = {};
+  for (const item of discovery) {
+    if (!item.installed || !item.authenticated || !item.executable) continue;
+    if (item.harness === "codex") {
+      let detected = await codexAllowance(item.executable);
+      if (detected.status === "unknown") detected = await codexAllowance(item.executable);
+      result.codex = { default: detected };
+    } else if (item.harness === "claude") {
+      let detected = await claudeAllowance(item.executable);
+      if (detected.default.status === "unknown") detected = await claudeAllowance(item.executable);
+      result.claude = detected;
+    } else result[item.harness] = { default: unknown() };
+  }
+  return result;
+}
+async function readCache() {
+  const file = cacheFile();
+  try {
+    const value = JSON.parse(await readFile3(file, "utf8"));
+    if (value.schemaVersion !== CACHE_VERSION || !value.createdAt || !value.expiresAt || !value.harnesses || Date.parse(value.expiresAt) <= Date.now()) return null;
+    return { harnesses: value.harnesses, cache: { hit: true, path: file, createdAt: value.createdAt, expiresAt: value.expiresAt } };
+  } catch {
+    return null;
+  }
+}
+async function allowances(discovery, forceRefresh = false) {
+  if (!forceRefresh) {
+    const cached = await readCache();
+    if (cached) return cached;
+  }
+  const harnesses = await collect(discovery);
+  const createdAt = /* @__PURE__ */ new Date();
+  const expiresAt = new Date(createdAt.getTime() + ttlMs());
+  const file = cacheFile();
+  const temporary = `${file}.${process.pid}.tmp`;
+  await mkdir3(home(), { recursive: true, mode: 448 });
+  await writeFile3(temporary, `${JSON.stringify({ schemaVersion: CACHE_VERSION, createdAt: createdAt.toISOString(), expiresAt: expiresAt.toISOString(), harnesses }, null, 2)}
+`, { mode: 384 });
+  await rename3(temporary, file);
+  return { harnesses, cache: { hit: false, path: file, createdAt: createdAt.toISOString(), expiresAt: expiresAt.toISOString() } };
+}
+function forModel(model2, snapshot) {
+  if (model2.harness === "opencode" && /^opencode\/(?:big-pickle|[a-z0-9._:/-]+-free)$/i.test(model2.nativeModelId)) {
+    return observed("unmetered", "credential-free");
+  }
+  const harness = snapshot[model2.harness];
+  if (!harness) return unknown();
+  if (model2.harness === "claude" && /fable/i.test(model2.nativeModelId)) return harness.byModelId?.fable ?? unknown();
+  return harness.default;
+}
+function applyAllowances(discovery, snapshot) {
+  return discovery.map((item) => ({
+    ...item,
+    models: item.models.map((model2) => ({ ...model2, allowance: forModel(model2, snapshot.harnesses) }))
+  }));
+}
+function rootAllowance(harness, snapshot) {
+  return snapshot.harnesses[harness]?.default ?? unknown();
+}
+function publicAllowance(value) {
+  const remainingFraction = value.remainingFraction === void 0 ? void 0 : Math.round(value.remainingFraction * 1e4) / 1e4;
+  return {
+    ...value,
+    ...remainingFraction === void 0 ? {} : {
+      remainingFraction,
+      remainingPercent: Math.round(remainingFraction * 1e3) / 10
+    }
+  };
+}
+function allowanceKey(value) {
+  return [value.status, value.source, value.remainingFraction ?? "n/a", value.resetsAt ?? "n/a"].join(":");
+}
+function allowanceScopesForHarness(item) {
+  const scopes = /* @__PURE__ */ new Map();
+  for (const model2 of item.models) {
+    const value = model2.allowance ?? unknown();
+    const key = allowanceKey(value);
+    const existing = scopes.get(key);
+    if (existing) existing.modelIds.push(model2.nativeModelId);
+    else scopes.set(key, { modelIds: [model2.nativeModelId], allowance: value });
+  }
+  return [...scopes.values()].map((scope) => {
+    const compact = scope.modelIds.length > 12;
+    return {
+      ...compact ? { sampleModelIds: scope.modelIds.slice(0, 12), omittedModelCount: scope.modelIds.length - 12 } : { modelIds: scope.modelIds },
+      modelCount: scope.modelIds.length,
+      allowance: publicAllowance(scope.allowance)
+    };
+  });
+}
+function allowanceReport(discovery, snapshot) {
+  const available = applyAllowances(discovery, snapshot);
+  return available.filter((item) => item.installed).map((item) => ({
+    harness: item.harness,
+    harnessDefault: publicAllowance(snapshot.harnesses[item.harness]?.default ?? unknown()),
+    modelScopes: allowanceScopesForHarness(item)
+  }));
+}
+
+// src/local/execution.ts
+function executionArgs(harness, model2, permission, cwd) {
+  if (harness === "codex") {
+    return ["exec", "-C", cwd, "-s", permission === "inspect" ? "read-only" : "workspace-write", "--json", "-m", model2, "-"];
+  }
+  if (harness === "claude") {
+    return ["-p", "--model", model2, "--output-format", "json", "--permission-mode", permission === "inspect" ? "plan" : "acceptEdits", "--no-session-persistence"];
+  }
+  if (harness === "cursor") {
+    return ["-p", "--output-format", "json", "--mode", "plan", "--model", model2, "--workspace", cwd, "--trust"];
+  }
+  if (harness === "opencode") {
+    return ["run", "--model", model2, "--agent", "plan", "--format", "json", "--dir", cwd];
+  }
+  throw new Error(`execution adapter for ${harness} is unavailable`);
+}
+
+// src/index.ts
+var CLIENT_VERSION = "0.3.0-beta.0";
+var MAX_OUTPUT_BYTES = 2e5;
+function apiUrl(value) {
+  return (value ?? process.env.TOKENSIZE_API_URL ?? "https://api.tokensize.dev").replace(/\/$/, "");
+}
+function home2() {
+  return home();
+}
+function digest(value) {
+  return createHash("sha256").update(value.trim().replace(/\s+/g, " ")).digest("hex");
+}
+function receiptFile(receiptId) {
+  return path4.join(home2(), `receipt-${receiptId}.json`);
+}
+function receiptKeyFile() {
+  return path4.join(home2(), "receipt-key");
+}
+async function receiptKey() {
+  try {
+    const value2 = await readFile4(receiptKeyFile());
+    if (value2.length >= 32) return value2;
+  } catch {
+  }
+  const value = randomBytes(32);
+  await mkdir4(home2(), { recursive: true, mode: 448 });
+  await writeFile4(receiptKeyFile(), value, { mode: 384 });
+  return value;
+}
+function receiptMac(value, key) {
+  return createHmac("sha256", key).update(JSON.stringify(value)).digest("base64url");
+}
+async function saveReceipt(route, task, surface, runId) {
+  const receiptId = randomUUID2();
+  const value = {
+    receiptId,
+    taskDigest: digest(task),
+    installationId: await installationId(),
+    surface,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    route,
+    ...runId ? { runId } : {}
+  };
+  const stored = { ...value, mac: receiptMac(value, await receiptKey()) };
+  const file = receiptFile(receiptId);
+  const temporary = `${file}.${process.pid}.${randomUUID2()}.tmp`;
+  await mkdir4(home2(), { recursive: true, mode: 448 });
+  await writeFile4(temporary, `${JSON.stringify(stored, null, 2)}
+`, { mode: 384 });
+  await rename4(temporary, file);
+  return receiptId;
+}
+async function readReceipt(receiptId, task) {
+  if (!/^[0-9a-f-]{36}$/i.test(receiptId)) throw new Error("invalid route receipt");
+  const value = JSON.parse(await readFile4(receiptFile(receiptId), "utf8"));
+  if (value.receiptId !== receiptId || task !== void 0 && value.taskDigest !== digest(task) || Date.parse(value.route.expiresAt) <= Date.now()) throw new Error("route receipt is invalid, expired, or bound to a different task");
+  const { mac, ...unsigned } = value;
+  const expected = receiptMac(unsigned, await receiptKey());
+  const actualBytes = Buffer.from(mac ?? "", "base64url");
+  const expectedBytes = Buffer.from(expected, "base64url");
+  if (actualBytes.length !== expectedBytes.length || !timingSafeEqual(actualBytes, expectedBytes)) throw new Error("route receipt integrity check failed");
+  return value;
+}
+function summarizeHarness(item, verbose = false) {
+  const summary = {
+    harness: item.harness,
+    installed: item.installed,
+    authenticated: item.authenticated,
+    version: item.version,
+    modelCount: item.models.length,
+    allowanceScopes: allowanceScopesForHarness(item),
+    warnings: item.warnings
+  };
+  return verbose ? {
+    ...summary,
+    models: item.models.map(({ id, harness, nativeModelId, displayName, readiness, authMode, productUseApproved, capabilities, identityProof, qualityPrior, tokenEfficiencyPrior, latencyPrior, allowance }) => ({
+      id,
+      harness,
+      nativeModelId,
+      displayName,
+      readiness,
+      authMode,
+      productUseApproved,
+      capabilities,
+      identityProof,
+      qualityPrior,
+      tokenEfficiencyPrior,
+      latencyPrior,
+      allowance
+    }))
+  } : summary;
+}
+function parseRootHarness(value) {
+  if (["codex", "claude", "copilot", "cursor", "opencode", "custom"].includes(value ?? "")) return value;
+  return "codex";
+}
+function parseRole(value) {
+  return value ?? "inspect";
+}
+var TokenSizeClient = class {
+  options;
+  constructor(options = {}) {
+    this.options = {
+      ...options,
+      clientSurface: options.clientSurface ?? "cli",
+      clientVersion: options.clientVersion ?? CLIENT_VERSION
+    };
+  }
+  /**
+   * Resolve routing defaults: explicit constructor options win, then
+   * environment variables (CI overrides), then the local policy document at
+   * ~/.tokensize/policy.json, then fail-closed defaults.
+   */
+  async resolvedDefaults() {
+    const policy = await readLocalPolicy();
+    return {
+      policy,
+      rootHarness: this.options.rootHarness ?? parseRootHarness(process.env.TOKENSIZE_ROOT_HARNESS ?? policy.rootHarness),
+      rootActive: this.options.rootActive ?? process.env.TOKENSIZE_ROOT_ACTIVE === "1",
+      rootQualityPrior: this.options.rootQualityPrior ?? Number(process.env.TOKENSIZE_ROOT_QUALITY_PRIOR ?? policy.rootQualityPrior ?? 0.82),
+      maxDelegationDepth: this.options.maxDelegationDepth ?? Number(process.env.TOKENSIZE_MAX_DELEGATION_DEPTH ?? policy.maxDelegationDepth ?? 1)
+    };
+  }
+  async key(required = true) {
+    const value = process.env.TOKENSIZE_API_KEY ?? await readApiKey();
+    if (!value && required) throw new Error("TokenSize API key is missing; use tokensize_connect or tokensize auth login");
+    return value;
+  }
+  async api(pathname, options = {}) {
+    const key = await this.key();
+    const fetcher = this.options.fetchImpl ?? fetch;
+    const response = await fetcher(`${apiUrl(this.options.apiUrl)}${pathname}`, {
+      ...options,
+      headers: {
+        authorization: `Bearer ${key}`,
+        ...options.body ? { "content-type": "application/json" } : {},
+        ...options.headers
+      }
+    });
+    const text = await response.text();
+    let body;
+    try {
+      body = JSON.parse(text);
+    } catch {
+      body = { message: text.slice(0, 500) };
+    }
+    if (!response.ok) {
+      const record = body;
+      throw new Error(`service returned ${response.status}: ${record.error?.message ?? record.message ?? "request failed"}`);
+    }
+    return body;
+  }
+  async status(options = {}) {
+    const [key, discovered] = await Promise.all([
+      this.key(false),
+      discoverHarnessesCached({ forceRefresh: options.refresh, reason: options.refresh ? "manual" : void 0 })
+    ]);
+    const allowanceSnapshot = await allowances(discovered.harnesses, options.refresh);
+    const available = applyAllowances(discovered.harnesses, allowanceSnapshot);
+    const catalog = key ? await this.api("/v1/agent-catalog").catch((error) => ({ warning: error instanceof Error ? error.message : String(error) })) : void 0;
+    return {
+      service: { url: apiUrl(this.options.apiUrl), authenticated: Boolean(key), ...catalog === void 0 ? {} : { catalog } },
+      installationId: await installationId(),
+      cache: { discovery: discovered.cache, allowance: allowanceSnapshot.cache },
+      harnesses: available.map((item) => summarizeHarness(item, options.verbose === true))
+    };
+  }
+  async connect(surface = this.options.clientSurface) {
+    const state = randomUUID2();
+    let completed = false;
+    const server = createServer((request, response) => {
+      if (request.method === "OPTIONS" && request.url === `/callback/${state}`) {
+        response.writeHead(204, { "access-control-allow-origin": "https://tokensize.dev", "access-control-allow-methods": "POST", "access-control-allow-headers": "content-type" }).end();
+        return;
+      }
+      if (request.method !== "POST" || request.url !== `/callback/${state}`) {
+        response.writeHead(404).end();
+        return;
+      }
+      let body = "";
+      request.on("data", (chunk) => {
+        if (body.length < 16e3) body += chunk;
+      });
+      request.on("end", async () => {
+        try {
+          const payload = JSON.parse(body);
+          if (payload.state !== state || typeof payload.apiKey !== "string" || payload.apiKey.length < 20 || /\s/.test(payload.apiKey)) throw new Error("invalid callback");
+          await saveApiKey(payload.apiKey);
+          completed = true;
+          response.writeHead(200, { "content-type": "text/plain", "access-control-allow-origin": "https://tokensize.dev" }).end("TokenSize connected. You can close this window.\n");
+          setTimeout(() => server.close(), 100);
+        } catch {
+          response.writeHead(400, { "access-control-allow-origin": "https://tokensize.dev" }).end("Invalid TokenSize callback.\n");
+        }
+      });
+    });
+    await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+    const address = server.address();
+    if (!address || typeof address === "string") throw new Error("could not start local authorization callback");
+    const callback = `http://127.0.0.1:${address.port}/callback/${state}`;
+    const url = `https://tokensize.dev/authorize?callback=${encodeURIComponent(callback)}&state=${encodeURIComponent(state)}&surface=${encodeURIComponent(surface)}`;
+    if (this.options.openBrowser) this.options.openBrowser(url);
+    else execFile(process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open", process.platform === "win32" ? ["/c", "start", url] : [url]);
+    const timeout = setTimeout(() => server.close(), 10 * 60 * 1e3);
+    await new Promise((resolve) => server.on("close", resolve));
+    clearTimeout(timeout);
+    if (!completed) throw new Error("browser authorization timed out or was cancelled");
+  }
+  async prepare(options) {
+    const defaults = await this.resolvedDefaults();
+    const role = parseRole(options.role);
+    const permission = options.permission ?? defaults.policy.permissionCeiling ?? "inspect";
+    if (!process.env.TOKENSIZE_ALLOW_SUBSCRIPTION_HARNESSES && defaults.policy.subscriptionHarnesses?.length) {
+      process.env.TOKENSIZE_ALLOW_SUBSCRIPTION_HARNESSES = defaults.policy.subscriptionHarnesses.join(",");
+    }
+    const discovered = await discoverHarnessesCached({ forceRefresh: options.refresh, reason: options.refresh ? "manual" : void 0 });
+    const allowanceSnapshot = await allowances(discovered.harnesses, options.refresh);
+    const discovery = applyAllowances(discovered.harnesses, allowanceSnapshot);
+    const delegationDepth = Number(process.env.TOKENSIZE_DELEGATION_DEPTH ?? 0);
+    const body = {
+      schemaVersion: AGENT_ROUTER_SCHEMA_VERSION,
+      client: { surface: this.options.clientSurface, version: this.options.clientVersion },
+      requestId: randomUUID2(),
+      installationId: await installationId(),
+      routerMode: options.sharePrompt ? "prompt-assisted" : "metadata-only",
+      task: featurizeAgentTask({ task: options.task, role, permissionProfile: permission }),
+      ...options.sharePrompt ? { prompt: options.task } : {},
+      candidates: flattenModels(discovery),
+      root: { harness: defaults.rootHarness, active: defaults.rootActive, qualityPrior: defaults.rootQualityPrior, allowance: rootAllowance(defaults.rootHarness, allowanceSnapshot) },
+      policy: { objective: options.objective ?? defaults.policy.objective ?? "balanced", maxDelegationDepth: defaults.maxDelegationDepth, delegationDepth, permissionCeiling: permission, wallTimeBudgetMs: options.timeoutMs ?? 9e5 }
+    };
+    return { body, discovery, cache: { discovery: discovered.cache, allowance: allowanceSnapshot.cache } };
+  }
+  async route(options) {
+    if (!options.task.trim()) throw new Error("task is required");
+    const prepared = await this.prepare(options);
+    const response = await this.api("/v1/agent-routes", { method: "POST", body: JSON.stringify(prepared.body) });
+    const runId = typeof response.runId === "string" ? response.runId : void 0;
+    const route = agentRouteResponseSchema.parse(response);
+    const receiptId = await saveReceipt(route, options.task, this.options.clientSurface, runId);
+    const { feedbackToken: _feedbackToken, ...safeRoute } = route;
+    return { receiptId, ...runId ? { runId } : {}, route: safeRoute, cache: prepared.cache, harnesses: prepared.discovery.map((item) => summarizeHarness(item)) };
+  }
+  /** List recent Run documents for this tenant. */
+  async runs(options = {}) {
+    return this.api(`/v1/runs?limit=${Math.min(Math.max(options.limit ?? 25, 1), 100)}`);
+  }
+  /** Read one Run document — the authoritative story of a delegation. */
+  async runDocument(runId) {
+    if (!/^[0-9a-f-]{36}$/i.test(runId)) throw new Error("invalid run id");
+    return this.api(`/v1/runs/${runId}`);
+  }
+  /** Append one event to a Run. Execution-class events need the receipt token. */
+  async appendRunEvent(runId, event, options = {}) {
+    const candidate = runEventSchema.parse({ seq: event.seq ?? 0, ...event });
+    return this.api(`/v1/runs/${runId}/events`, {
+      method: "POST",
+      body: JSON.stringify({
+        event: candidate,
+        autoSeq: event.seq === void 0,
+        ...options.receiptToken ? { receiptToken: options.receiptToken } : {}
+      })
+    });
+  }
+  /** The human hand at the terminal: grant a pending approval on a Run. */
+  async approve(runId, kind = "subscription-use") {
+    return this.appendRunEvent(runId, {
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      actor: "human",
+      type: "approval-granted",
+      data: { kind, grantedBy: "local-cli" }
+    });
+  }
+  /** Cancel a Run from any surface that can authenticate. */
+  async cancel(runId) {
+    return this.appendRunEvent(runId, {
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      actor: "human",
+      type: "cancelled",
+      data: { by: "human" }
+    });
+  }
+  async execute(options) {
+    const stored = await readReceipt(options.receiptId, options.task);
+    const route = stored.route;
+    if (this.options.clientSurface === "opencode-plugin" && route.plan.permissionProfile !== "inspect") throw new Error("OpenCode execution is inspect-only in this release");
+    if (!route.plan.targetId) throw new Error(`no local target selected (${route.reasonCodes.join(", ")})`);
+    if (route.plan.permissionProfile === "network") throw new Error("network delegation is not supported");
+    const discovered = await discoverHarnessesCached();
+    const snapshot = await allowances(discovered.harnesses);
+    const available = applyAllowances(discovered.harnesses, snapshot);
+    const target = available.flatMap((item) => item.models.map((model2) => ({ item, model: model2 }))).find(({ model: model2 }) => model2.id === route.plan.targetId);
+    if (!target?.item.executable || !target.item.authenticated) throw new Error("selected target is no longer available; local discovery cache refreshed");
+    try {
+      await access3(target.item.executable);
+    } catch {
+      throw new Error("selected harness executable no longer exists; local discovery cache refreshed");
+    }
+    if (!["codex", "claude", "cursor", "opencode"].includes(target.model.harness)) throw new Error(`${target.model.harness} execution is unavailable`);
+    if (["cursor", "opencode"].includes(target.model.harness) && route.plan.permissionProfile !== "inspect") throw new Error(`${target.model.harness} execution is inspect-only`);
+    const cwd = options.cwd ?? process.cwd();
+    const started = Date.now();
+    await this.recordRunEvent(stored, {
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      actor: "delegate",
+      type: "execution-started",
+      data: { targetId: target.model.id, permissionProfile: route.plan.permissionProfile, worktree: false }
+    });
+    const result = await run(target.item.executable, executionArgs(target.model.harness, target.model.nativeModelId, route.plan.permissionProfile, cwd), {
+      cwd,
+      input: options.task,
+      timeoutMs: route.plan.maxWallMs,
+      env: { ...process.env, TOKENSIZE_ROOT_HARNESS: target.model.harness, TOKENSIZE_ROOT_ACTIVE: "1", TOKENSIZE_DELEGATION_DEPTH: String(Number(process.env.TOKENSIZE_DELEGATION_DEPTH ?? 0) + 1) }
+    });
+    const elapsedMs = Date.now() - started;
+    await this.recordRunEvent(stored, {
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      actor: "delegate",
+      type: "execution-finished",
+      data: {
+        outcome: result.timedOut ? "timeout" : result.code === 0 ? "success" : "failure",
+        ...result.code === 0 && !result.timedOut ? {} : { failureCode: result.timedOut ? "EXECUTION_TIMEOUT" : "EXECUTION_FAILED" },
+        elapsedMs,
+        usage: { contextTokensEstimated: route.expected.contextTokens, source: "estimated" }
+      }
+    });
+    return { target: target.model.id, ...stored.runId ? { runId: stored.runId } : {}, code: result.code, timedOut: result.timedOut, elapsedMs, stdout: result.stdout.slice(0, MAX_OUTPUT_BYTES), stderr: result.stderr.slice(0, MAX_OUTPUT_BYTES) };
+  }
+  async recordRunEvent(stored, event) {
+    if (!stored.runId) return;
+    try {
+      await this.appendRunEvent(stored.runId, event, { receiptToken: stored.route.feedbackToken });
+    } catch {
+    }
+  }
+  async feedback(options) {
+    const stored = await readReceipt(options.receiptId, options.task);
+    return this.api("/v1/agent-feedback", { method: "POST", body: JSON.stringify({ schemaVersion: AGENT_ROUTER_SCHEMA_VERSION, routeId: stored.route.routeId, feedbackToken: stored.route.feedbackToken, idempotencyKey: randomUUID2(), status: options.modelChoice === "wrong" ? "failed" : "verified", confirmedTargetId: stored.route.plan.targetId, identityConfirmed: true, checksPassed: options.modelChoice === "right" ? 1 : 0, checksFailed: options.modelChoice === "wrong" ? 1 : 0, retries: 0, usage: { contextTokensEstimated: stored.route.expected.contextTokens, source: "estimated" }, timings: { totalMs: 0, routingMs: 0, executionMs: 0, verificationMs: 0 } }) });
+  }
+};
+function createTokenSizeClient(options) {
+  return new TokenSizeClient(options);
+}
+export {
+  HARNESS_IDS,
+  TokenSizeClient,
+  allowanceReport,
+  allowanceScopesForHarness,
+  allowances,
+  applyAllowances,
+  createTokenSizeClient,
+  discoverHarness,
+  discoverHarnesses,
+  discoverHarnessesCached,
+  executionArgs,
+  flattenModels,
+  home,
+  installationId,
+  isCredentialFreeOpenCodeModel,
+  opencodeModelIds,
+  parseClaudeUsage,
+  readApiKey,
+  readLastRoute,
+  readLocalPolicy,
+  rootAllowance,
+  run,
+  saveApiKey,
+  saveLastRoute,
+  saveLocalPolicy,
+  terminateProcessTree
+};
+//# sourceMappingURL=index.js.map