@lucid-agents/taskmarket 1.16.0 → 1.17.1

package/dist/chunk-F5SS4NUF.js

@@ -0,0 +1,1062 @@
+import { createRequire as __tmCreateRequire } from 'node:module'; import { fileURLToPath as __tmFileURLToPath } from 'node:url'; import { dirname as __tmDirname } from 'node:path'; const require = __tmCreateRequire(import.meta.url); const __tmFilename = __tmFileURLToPath(import.meta.url); const __tmDirnameValue = __tmDirname(__tmFilename);
+import {
+  BASE_CHANNEL_RAIL_ID,
+  WITHDRAW_DELAY_SECONDS,
+  createBaseChannelPayer,
+  createBaseChannelRpcReader,
+  createWalletAccountFromKeystore,
+  createX402Allocations,
+  getTaskmarketHome,
+  getX402JournalPath,
+  getX402PolicyPath,
+  keystoreExists,
+  listX402Payments,
+  loadKeystore,
+  loadX402Policy,
+  rpcUrlForNetwork
+} from "./chunk-3S63AB3C.js";
+import {
+  AgentLaunchError
+} from "./chunk-YM4S6IE4.js";
+import {
+  formatUsdc
+} from "./chunk-73RXOYME.js";
+
+// src/lib/agent/channels.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// ../../node_modules/.pnpm/@lucid-agents+xgate-client@0.1.6_@solana+sysvars@5.5.1_typescript@5.7.3_zod@3.25.76/node_modules/@lucid-agents/xgate-client/dist/types.js
+var XgateError = class extends Error {
+  code;
+  constructor(code) {
+    super(`Xgate: ${code}. Inspect /xgate status before another purchase.`);
+    this.name = "XgateError";
+    this.code = code;
+  }
+};
+function requireValue(condition, code) {
+  if (!condition)
+    throw new XgateError(code);
+}
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function atomic(value) {
+  requireValue(typeof value === "string" && /^(0|[1-9][0-9]{0,12})$/.test(value), "invalid_amount");
+  const n = BigInt(value);
+  requireValue(n <= 1000000000000n, "amount_bound");
+  return n;
+}
+function origin(value, loopback = false) {
+  const u = new URL(value);
+  requireValue((u.protocol === "https:" || loopback && u.protocol === "http:" && ["127.0.0.1", "[::1]"].includes(u.hostname)) && !u.username && !u.password && u.pathname === "/" && !u.search && !u.hash, "invalid_origin");
+  return u.origin;
+}
+function route(value) {
+  requireValue([
+    "/v1/chat/completions",
+    "/providers/openai/v1/responses",
+    "/providers/anthropic/v1/messages"
+  ].includes(String(value)), "invalid_route");
+}
+
+// ../../node_modules/.pnpm/@lucid-agents+pi-xgate@0.1.6_@earendil-works+pi-ai@0.85.1_@earendil-works+pi-coding-agent@0.8_344x6vs3jrzh5eh3xewwgv3ik4/node_modules/@lucid-agents/pi-xgate/dist/transport.js
+var XgatePurchaseError = class extends XgateError {
+  invocationId;
+  pending;
+  payment;
+  constructor(code, invocationId, pending, payment) {
+    super(code);
+    this.name = "XgatePurchaseError";
+    this.message = pending ? `Xgate: ${code}. The payment outcome is unknown; do not retry. Reconcile it before another purchase.` : `Xgate: ${code}. Inspect the payment status before another purchase.`;
+    this.invocationId = invocationId;
+    this.pending = pending;
+    if (payment)
+      this.payment = payment;
+  }
+};
+
+// ../../node_modules/.pnpm/@lucid-agents+pi-xgate@0.1.6_@earendil-works+pi-ai@0.85.1_@earendil-works+pi-coding-agent@0.8_344x6vs3jrzh5eh3xewwgv3ik4/node_modules/@lucid-agents/pi-xgate/dist/taskmarket.js
+var RESOLVED_CHARGES = ["none", "released", "settled", "manually_resolved"];
+var RESOLVED_STATES = ["completed", "failed"];
+var CATALOG_BYTES = 2 * 1024 * 1024;
+var REQUEST_BYTES = 8 * 1024 * 1024;
+var CATALOG_DEADLINE_MS = 15e3;
+function createTaskMarketTransport(options) {
+  const { payer } = options, base = origin(options.origin), fetcher = options.fetch ?? fetch;
+  if (payer.apiVersion !== 1)
+    throw new XgateError("unsupported_payer_api");
+  const channel = async (payment) => {
+    if (!options.balances || payment.rail.kind !== "session")
+      return;
+    try {
+      const matches = (await options.balances()).filter((b2) => b2.railId === payment.rail.id && b2.network === payment.network && b2.asset === payment.asset);
+      if (matches.length !== 1)
+        return;
+      const b = matches[0];
+      return {
+        depositingAtomic: b.depositing,
+        lockedAtomic: b.locked,
+        chargedAtomic: b.charged,
+        pendingAtomic: b.pending,
+        refundableAtomic: b.refundable
+      };
+    } catch {
+      return;
+    }
+  };
+  return {
+    async models(signal) {
+      const deadline = AbortSignal.timeout(CATALOG_DEADLINE_MS);
+      let response;
+      try {
+        response = await fetcher(base + "/v1/models", {
+          signal: signal ? AbortSignal.any([signal, deadline]) : deadline,
+          redirect: "error",
+          cache: "no-store",
+          credentials: "omit",
+          referrerPolicy: "no-referrer",
+          headers: { accept: "application/json" }
+        });
+      } catch {
+        throw new XgateError("catalog_unavailable");
+      }
+      if (!response.ok) {
+        await response.body?.cancel().catch(() => {
+        });
+        throw new XgateError("catalog_unavailable");
+      }
+      const v = parse(await bounded(response, CATALOG_BYTES));
+      if (!record(v) || !Array.isArray(v.data) || v.data.length > 128)
+        throw new XgateError("invalid_catalog");
+      return v.data.filter((m) => record(m) && (options.models === void 0 || options.models.includes(m.id))).map((m) => ({ ...m, xgate_origin: base }));
+    },
+    async purchase(invocation, signal, onResponse) {
+      route(invocation.route);
+      const body = new TextEncoder().encode(invocation.body);
+      if (body.byteLength === 0 || body.byteLength > REQUEST_BYTES)
+        throw new XgateError("invalid_invocation");
+      const id = invocation.id;
+      let result;
+      try {
+        result = await payer.request({
+          apiVersion: 1,
+          invocationId: id,
+          url: base + invocation.route,
+          method: "POST",
+          // Application headers only: the payer owns every payment header.
+          headers: {
+            "content-type": "application/json",
+            accept: "application/json"
+          },
+          body,
+          limits: { maxRequestBodyBytes: REQUEST_BYTES },
+          ...options.allocationId !== void 0 ? { allocationId: options.allocationId } : {},
+          ...options.policyRuleId !== void 0 ? { policyRuleId: options.policyRuleId } : {},
+          ...options.nonInteractive !== void 0 ? { nonInteractive: options.nonInteractive } : {}
+        }, {
+          ...signal ? { signal } : {},
+          ...options.confirmPayment ? { confirmPayment: options.confirmPayment } : {}
+        });
+      } catch (error) {
+        throw failure(error, id);
+      }
+      const payment = result.payment;
+      if (result.invocationId !== id || result.apiVersion !== 1)
+        throw new XgatePurchaseError("payer_result_mismatch", id, true, payment && display(payment));
+      if (!payment)
+        throw new XgatePurchaseError(result.response.status === 200 ? "payment_missing" : "request_rejected", id, false);
+      const shown = display(payment);
+      if (payment.charge !== "settled" || typeof payment.settledAmount !== "string")
+        throw new XgatePurchaseError("payment_unverified", id, true, shown);
+      shown.chargedAtomic = payment.settledAmount;
+      try {
+        if (atomic(payment.settledAmount) > atomic(payment.authorizedAmount))
+          throw new XgateError("charge_over_authorization");
+      } catch {
+        throw new XgatePurchaseError("invalid_settlement", id, true, shown);
+      }
+      const r = result.response, h = r.headers;
+      if (r.status !== 200 || !/^application\/json\b/i.test(r.contentType) || h["x-inference-privacy"] !== "anonymous" || h["x-result-retention"] !== "none" || !h["cache-control"]?.includes("no-store"))
+        throw new XgatePurchaseError("response_rejected", id, false, shown);
+      let value;
+      try {
+        value = parse(r.body);
+      } catch {
+        throw new XgatePurchaseError("invalid_response", id, false, shown);
+      }
+      if (!record(value) || typeof value.id !== "string" || value.result_replay_available !== void 0)
+        throw new XgatePurchaseError("invalid_response", id, false, shown);
+      const head = {
+        status: r.status,
+        headers: { "content-type": r.contentType, "cache-control": "no-store" }
+      };
+      try {
+        await onResponse?.(head);
+      } catch {
+        throw new XgatePurchaseError("response_hook_failed", id, false, shown);
+      }
+      const balance = await channel(payment);
+      if (balance)
+        shown.channel = balance;
+      return {
+        body: value,
+        settlement: {
+          chargedAtomic: payment.settledAmount,
+          reference: payment.transaction ?? payment.commitment ?? payment.paymentId
+        },
+        purchase: payment.commitment ?? payment.paymentId,
+        payment: shown
+      };
+    },
+    async status() {
+      return {
+        transport: "taskmarket",
+        origin: base,
+        ...options.balances ? {
+          balances: (await options.balances()).map((b) => ({
+            rail: b.railId,
+            network: b.network,
+            asset: b.asset,
+            depositingAtomic: b.depositing,
+            lockedAtomic: b.locked,
+            chargedAtomic: b.charged,
+            pendingAtomic: b.pending,
+            refundableAtomic: b.refundable
+          }))
+        } : {}
+      };
+    },
+    async reconcile(invocationId) {
+      const s = await payer.reconcile(invocationId);
+      return {
+        invocationId: s.invocationId,
+        state: s.state,
+        charge: s.charge,
+        uncertain: s.uncertain,
+        ...s.errorCode ? { errorCode: s.errorCode } : {},
+        ...s.payment ? { payment: display(s.payment) } : {}
+      };
+    }
+  };
+}
+function display(p) {
+  return {
+    network: p.network,
+    scheme: p.scheme,
+    asset: p.asset,
+    payTo: p.payTo,
+    rail: p.rail.kind,
+    authorizedAtomic: p.authorizedAmount,
+    ...p.charge === "settled" && p.settledAmount !== void 0 ? { chargedAtomic: p.settledAmount } : {},
+    status: p.charge,
+    ...p.transaction ?? p.commitment ? { reference: p.transaction ?? p.commitment } : {}
+  };
+}
+function failure(error, id) {
+  const e = error;
+  const code = typeof e?.code === "string" && /^[a-z0-9_]{1,64}$/.test(e.code) ? e.code : "payer_failed";
+  const recorded = e?.invocation;
+  const pending = e?.pending !== false || recorded !== void 0 && !(recorded.uncertain === false && RESOLVED_CHARGES.includes(recorded.charge) && RESOLVED_STATES.includes(recorded.state));
+  const summary = e?.invocation?.payment;
+  return new XgatePurchaseError(code, id, pending, record(summary) ? display(summary) : void 0);
+}
+async function bounded(response, limit) {
+  if (!response.body)
+    throw new XgateError("invalid_catalog");
+  const reader = response.body.getReader(), chunks = [];
+  let length = 0;
+  try {
+    for (; ; ) {
+      const part = await reader.read();
+      if (part.done)
+        break;
+      length += part.value.byteLength;
+      if (length > limit)
+        throw new XgateError("catalog_bound");
+      chunks.push(part.value);
+    }
+  } catch (error) {
+    await reader.cancel().catch(() => {
+    });
+    throw error instanceof XgateError ? error : new XgateError("catalog_unavailable");
+  } finally {
+    reader.releaseLock();
+  }
+  return Buffer.concat(chunks, length);
+}
+function parse(bytes) {
+  try {
+    return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+  } catch {
+    throw new XgateError("invalid_response");
+  }
+}
+
+// src/lib/agent/payer.ts
+function routeOfCatalogRow(row) {
+  return row?.owned_by === "anthropic" ? "/providers/anthropic/v1/messages" : "/providers/openai/v1/responses";
+}
+async function createAgentRails(options) {
+  const journalPath = getX402JournalPath();
+  const policyPath = getX402PolicyPath();
+  const loadPolicy = (loadOptions) => loadX402Policy(policyPath, loadOptions);
+  const x402Policy = await loadX402Policy(policyPath);
+  const allocations = createX402Allocations({ journalPath, loadPolicy });
+  return (options.rails ?? options.policy.rails).map((rail) => {
+    if (rail.wallet.toLowerCase() !== options.walletAddress.toLowerCase()) {
+      throw new AgentLaunchError(
+        "invalid_agent_policy",
+        `Rail ${rail.id} pays from ${rail.wallet}, but the wallet is ${options.walletAddress}`
+      );
+    }
+    let rpcUrl;
+    try {
+      rpcUrl = rpcUrlForNetwork(x402Policy, rail.network);
+    } catch (error) {
+      throw new AgentLaunchError("invalid_agent_policy", error.message);
+    }
+    const channel = {
+      network: rail.network,
+      payer: rail.wallet,
+      receiver: rail.receiver,
+      receiverAuthorizer: rail.receiverAuthorizer,
+      salt: rail.salt
+    };
+    const payer = createBaseChannelPayer({
+      channel,
+      reader: createBaseChannelRpcReader({ channel, rpcUrl, fromBlock: BigInt(rail.fromBlock) }),
+      resourceUrl: `${rail.origin}${rail.route}`,
+      journalPath,
+      loadPolicy,
+      getAccount: options.getAccount,
+      allocationId: rail.allocationId,
+      budgetAmount: rail.limits.total,
+      depositAmount: rail.limits.deposit,
+      policyRuleId: rail.policyRuleId,
+      ...options.fetch ? { fetch: options.fetch } : {}
+    });
+    const transport = createTaskMarketTransport({
+      payer,
+      origin: rail.origin,
+      allocationId: rail.allocationId,
+      policyRuleId: rail.policyRuleId,
+      nonInteractive: true,
+      models: options.models,
+      balances: () => allocations.balances(),
+      ...options.fetch ? { fetch: options.fetch } : {}
+    });
+    return { rail, payer, transport };
+  });
+}
+function bodyModel(body) {
+  try {
+    const model = JSON.parse(body)?.model;
+    return typeof model === "string" ? model : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function neverRecorded(payer, invocationId) {
+  try {
+    await payer.status(invocationId);
+    return false;
+  } catch (error) {
+    return error.code === "invocation_not_found";
+  }
+}
+function createAgentTransport(rails) {
+  const byRoute = new Map(rails.map((r) => [r.rail.route, r]));
+  let offered = /* @__PURE__ */ new Map();
+  return {
+    async models(signal) {
+      const seen = /* @__PURE__ */ new Map();
+      const rows = [];
+      for (const { rail, transport } of rails) {
+        for (const row of await transport.models(signal)) {
+          const id = row.id;
+          if (routeOfCatalogRow(row) !== rail.route || typeof id !== "string" || seen.has(id)) {
+            continue;
+          }
+          seen.set(id, rail.route);
+          rows.push(row);
+        }
+      }
+      offered = seen;
+      return rows;
+    },
+    async purchase(invocation, signal, onResponse) {
+      const rail = byRoute.get(invocation.route);
+      if (!rail) {
+        throw new XgatePurchaseError("no_rail_for_route", invocation.id, false);
+      }
+      if (Date.now() >= Date.parse(rail.rail.limits.expiresAt)) {
+        throw new XgatePurchaseError("policy_expired", invocation.id, false);
+      }
+      const model = typeof invocation.body === "string" ? bodyModel(invocation.body) : void 0;
+      if (model === void 0 || offered.get(model) !== invocation.route) {
+        throw new XgatePurchaseError("model_not_offered", invocation.id, false);
+      }
+      const leftover = (await rail.payer.channelStatus()).pendingOperation;
+      if (leftover && leftover.id !== invocation.id) {
+        throw new XgatePurchaseError("channel_operation_pending", invocation.id, false);
+      }
+      try {
+        return await rail.transport.purchase(invocation, signal, onResponse);
+      } catch (error) {
+        if (error instanceof XgatePurchaseError && error.pending && await neverRecorded(rail.payer, invocation.id)) {
+          throw new XgatePurchaseError(
+            error.code === "outcome_uncertain" ? "channel_operation_pending" : error.code,
+            invocation.id,
+            false
+          );
+        }
+        throw error;
+      }
+    },
+    async status() {
+      return {
+        transport: "taskmarket",
+        rails: await Promise.all(
+          rails.map(async ({ rail, transport }) => ({
+            rail: rail.id,
+            ...await transport.status()
+          }))
+        )
+      };
+    },
+    async reconcile(invocationId) {
+      for (const { transport } of rails) {
+        try {
+          return await transport.reconcile(invocationId);
+        } catch (error) {
+          if (error.code !== "invocation_not_found") throw error;
+        }
+      }
+      throw new XgateError("invocation_not_found");
+    }
+  };
+}
+async function reconcileLeftoverOperations(rails, log = () => void 0) {
+  for (const { rail, payer } of rails) {
+    let pending = (await payer.channelStatus()).pendingOperation;
+    if (!pending) continue;
+    if (pending.kind === "payment") {
+      log(`Reconciling payment ${pending.id} left on rail ${rail.id}`);
+      try {
+        await payer.reconcile(pending.id);
+      } catch (error) {
+        log(
+          `Payment ${pending.id} could not be reconciled: ${error.code ?? error.message}`
+        );
+      }
+      pending = (await payer.channelStatus()).pendingOperation;
+      if (!pending) continue;
+    }
+    throw new AgentLaunchError(
+      "channel_operation_pending",
+      `The ${rail.id} channel has an unresolved ${pending.kind} operation ${pending.id} from an earlier session; it must be reconciled before anything else is bought on that channel. Try again later.`
+    );
+  }
+}
+
+// src/lib/agent/policy.ts
+import { randomUUID } from "crypto";
+import { promises as fs } from "fs";
+import path from "path";
+import { z } from "zod";
+var XGATE_ROUTES = [
+  "/providers/anthropic/v1/messages",
+  "/providers/openai/v1/responses"
+];
+var WORKSPACE_CONSENT_VERSION = "boat-eu-2026-10";
+var address = z.string().regex(/^0x[0-9a-fA-F]{40}$/, "expected a 0x-prefixed 20-byte address");
+var atomic2 = z.string().regex(/^(0|[1-9][0-9]{0,30})$/, "expected an integer amount string");
+var positiveAtomic = atomic2.refine((value) => BigInt(value) > 0n, "expected an amount above 0");
+var ruleId = z.string().regex(/^[a-z0-9][a-z0-9._-]{0,63}$/, "invalid id");
+var allocationId = z.string().regex(/^[A-Za-z0-9._:-]{1,128}$/, "invalid allocation id");
+var origin2 = z.string().url().refine((value) => {
+  const url = new URL(value);
+  return url.protocol === "https:" && !url.username && !url.password && url.pathname === "/" && !url.search && !url.hash && !value.endsWith("/");
+}, "expected an HTTPS origin such as https://api.xgate.run");
+var RailLimitsSchema = z.object({
+  perRequest: positiveAtomic,
+  deposit: positiveAtomic,
+  total: positiveAtomic,
+  expiresAt: z.string().datetime()
+}).strict();
+var BaseBatchChannelRailSchema = z.object({
+  id: ruleId,
+  kind: z.literal("base-batch-channel"),
+  /** The wallet that funds deposits and signs vouchers; must be the keystore's wallet. */
+  wallet: address,
+  network: z.enum(["eip155:8453", "eip155:84532"]),
+  scheme: z.literal("batch-settlement"),
+  /** USDC on `network`. */
+  asset: address,
+  origin: origin2,
+  route: z.enum(XGATE_ROUTES),
+  receiver: address,
+  receiverAuthorizer: address,
+  salt: z.string().regex(/^0x[0-9a-fA-F]{64}$/, "expected a 32-byte hex salt"),
+  /** A block at or before the channel's first deposit; return scans start here. */
+  fromBlock: z.string().regex(/^(0|[1-9][0-9]{0,19})$/),
+  /** The channel's withdraw delay, as onboarding showed it. */
+  withdrawDelaySeconds: z.number().int().nonnegative(),
+  /**
+   * The durable root allocation, shared by every rail of the policy: all routes and every
+   * renewal's history count against its one `total`.
+   */
+  budgetAllocationId: allocationId,
+  /** The current session allocation, a child of the budget, bound to the channel. */
+  allocationId,
+  /** The x402 policy rule that authorizes this rail's vouchers and deposits. */
+  policyRuleId: ruleId,
+  limits: RailLimitsSchema
+}).strict();
+var AgentRailSchema = z.discriminatedUnion("kind", [BaseBatchChannelRailSchema]);
+var MAX_RETIRED_RAILS = 64;
+var AgentPolicySchema = z.object({
+  version: z.literal(1),
+  approvedAt: z.string().datetime(),
+  /** xgate model ids the user approved. Only those the router also qualifies are offered. */
+  models: z.array(z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/, "invalid model id")).min(1).max(64),
+  rails: z.array(AgentRailSchema).min(1).max(XGATE_ROUTES.length),
+  /**
+   * Channels that buy nothing more but may still hold a refundable deposit: those a renewal
+   * replaced (a channel's budget and allocation are fixed for its life, ADR-0243, so a larger
+   * budget is a new channel under the same budget allocation) and those whose route no longer
+   * has an approved model. Their session allocations are closed. The launcher and
+   * `assessAgentPolicy` ignore them; `taskmarket agent status` and `close` (#1198) read them to
+   * show and refund what they hold. An entry is removed only once its allocation is closed and
+   * the journal shows nothing deposited, pending or refundable on its channel; onboarding never
+   * drops one to make room, and refuses to retire more than `MAX_RETIRED_RAILS`.
+   */
+  retiredRails: z.array(AgentRailSchema).max(MAX_RETIRED_RAILS).default([]),
+  workspace: z.object({
+    consentVersion: z.string().min(1).max(64),
+    approvedAt: z.string().datetime()
+  }).strict()
+}).strict().superRefine((policy, ctx) => {
+  const ids = /* @__PURE__ */ new Set();
+  const routes = /* @__PURE__ */ new Set();
+  policy.rails.forEach((rail, index) => {
+    if (ids.has(rail.id)) {
+      ctx.addIssue({
+        code: "custom",
+        message: `duplicate rail id ${rail.id}`,
+        path: ["rails", index]
+      });
+    }
+    if (routes.has(rail.route)) {
+      ctx.addIssue({
+        code: "custom",
+        message: `more than one rail pays ${rail.route}`,
+        path: ["rails", index]
+      });
+    }
+    const { perRequest, deposit, total } = rail.limits;
+    if (BigInt(perRequest) > BigInt(deposit) || BigInt(deposit) > BigInt(total)) {
+      ctx.addIssue({
+        code: "custom",
+        message: "limits must satisfy perRequest <= deposit <= total",
+        path: ["rails", index, "limits"]
+      });
+    }
+    if (rail.budgetAllocationId !== policy.rails[0].budgetAllocationId) {
+      ctx.addIssue({
+        code: "custom",
+        message: "every rail must draw on the one aggregate budget allocation",
+        path: ["rails", index, "budgetAllocationId"]
+      });
+    }
+    ids.add(rail.id);
+    routes.add(rail.route);
+  });
+  if (new Set(policy.models).size !== policy.models.length) {
+    ctx.addIssue({ code: "custom", message: "duplicate model id", path: ["models"] });
+  }
+});
+function getAgentPolicyPath() {
+  return path.join(getTaskmarketHome(), "agent", "policy.json");
+}
+async function readAgentPolicy(policyPath = getAgentPolicyPath()) {
+  let raw;
+  try {
+    raw = await fs.readFile(policyPath, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new AgentLaunchError("invalid_agent_policy", `${policyPath} is not valid JSON`);
+  }
+  const result = AgentPolicySchema.safeParse(parsed);
+  if (!result.success) {
+    const issue = result.error.issues[0];
+    throw new AgentLaunchError(
+      "invalid_agent_policy",
+      `${policyPath}: ${issue.path.join(".") || "(root)"}: ${issue.message}`
+    );
+  }
+  return result.data;
+}
+async function loadAgentPolicy(policyPath = getAgentPolicyPath()) {
+  const policy = await readAgentPolicy(policyPath);
+  if (!policy) {
+    throw new AgentLaunchError(
+      "setup_required",
+      `taskmarket agent has no approved spending policy at ${policyPath}; run taskmarket agent at a terminal to set it up`,
+      { reasons: ["no_policy"] }
+    );
+  }
+  return policy;
+}
+async function saveAgentPolicy(policy, policyPath = getAgentPolicyPath()) {
+  const validated = AgentPolicySchema.parse(policy);
+  await fs.mkdir(path.dirname(policyPath), { recursive: true, mode: 448 });
+  const temporary = `${policyPath}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    await fs.writeFile(temporary, `${JSON.stringify(validated, null, 2)}
+`, {
+      mode: 384,
+      flag: "wx"
+    });
+    await fs.rename(temporary, policyPath);
+  } finally {
+    await fs.rm(temporary, { force: true }).catch(() => void 0);
+  }
+}
+async function assessAgentPolicy(policy, options) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const reasons = [];
+  const usage = [];
+  if (policy.workspace.consentVersion !== WORKSPACE_CONSENT_VERSION) {
+    reasons.push({ reason: "consent_outdated" });
+  }
+  for (const rail of policy.rails) {
+    if (now.getTime() >= Date.parse(rail.limits.expiresAt)) {
+      reasons.push({ reason: "expired", railId: rail.id });
+    }
+    let budget;
+    let session;
+    try {
+      [budget, session] = await Promise.all([
+        options.allocation(rail.budgetAllocationId),
+        options.allocation(rail.allocationId)
+      ]);
+    } catch (error) {
+      if (error.code !== "allocation_not_found") throw error;
+      reasons.push({ reason: "allocation_unavailable", railId: rail.id });
+      continue;
+    }
+    usage.push({
+      railId: rail.id,
+      used: budget.usage.used,
+      cap: budget.allocation.caps.amount
+    });
+    if (budget.allocation.closedAt || session.allocation.closedAt) {
+      reasons.push({ reason: "allocation_unavailable", railId: rail.id });
+      continue;
+    }
+    const remaining = BigInt(budget.allocation.caps.amount) - BigInt(budget.usage.used);
+    if (remaining < BigInt(rail.limits.perRequest)) {
+      reasons.push({ reason: "exhausted", railId: rail.id });
+    }
+  }
+  return { reasons, usage };
+}
+function selectModels(policy, requested) {
+  if (requested === void 0) return [...policy.models];
+  if (!policy.models.includes(requested)) {
+    throw new AgentLaunchError(
+      "model_not_allowed",
+      `Model ${requested} is not in the approved spending policy (${policy.models.join(", ")})`
+    );
+  }
+  return [requested];
+}
+
+// src/lib/agent/retired.ts
+async function settledRetiredRails(store, retired) {
+  const settled = /* @__PURE__ */ new Set();
+  if (retired.length === 0) return settled;
+  const balances = await store.balances();
+  for (const rail of retired) {
+    let session;
+    try {
+      session = (await store.get(rail.allocationId)).allocation;
+    } catch {
+      continue;
+    }
+    const sessionKey = session.funding?.sessionKey;
+    if (!session.closedAt || !sessionKey) continue;
+    const balance = balances.find(
+      (entry) => entry.railId === BASE_CHANNEL_RAIL_ID && entry.sessionKey === sessionKey
+    );
+    if (!balance || balance.depositing === "0" && balance.pending === "0" && balance.refundable === "0") {
+      settled.add(rail.salt);
+    }
+  }
+  return settled;
+}
+async function pruneRetiredRails(store) {
+  const policy = await readAgentPolicy();
+  if (!policy || policy.retiredRails.length === 0) return [];
+  const settled = await settledRetiredRails(store, policy.retiredRails);
+  if (settled.size === 0) return [];
+  await saveAgentPolicy({
+    ...policy,
+    retiredRails: policy.retiredRails.filter((rail) => !settled.has(rail.salt))
+  });
+  return [...settled];
+}
+
+// src/lib/agent/channels.ts
+async function openAgentChannels(options = {}) {
+  if (!options.keystore && !await keystoreExists()) {
+    throw new AgentLaunchError(
+      "wallet_required",
+      "No wallet is set up; run `taskmarket wallet import` or `taskmarket init` first"
+    );
+  }
+  const keystore = options.keystore ?? await loadKeystore();
+  const policy = await loadAgentPolicy();
+  let account;
+  const getAccount = () => {
+    account ??= createWalletAccountFromKeystore(keystore).catch((error) => {
+      account = void 0;
+      throw error;
+    });
+    return account;
+  };
+  const common = {
+    policy,
+    models: options.models ? options.models(policy) : [...policy.models],
+    walletAddress: keystore.walletAddress,
+    getAccount,
+    ...options.fetch ? { fetch: options.fetch } : {}
+  };
+  const rails = await createAgentRails(common);
+  const retired = await createAgentRails({
+    ...common,
+    rails: policy.retiredRails.filter(
+      (rail) => rail.wallet.toLowerCase() === keystore.walletAddress.toLowerCase()
+    )
+  });
+  return { keystore, policy, rails, retired };
+}
+function selectChannel(opened, choice) {
+  if (choice.channel !== void 0) {
+    const wanted = choice.channel.toLowerCase();
+    for (const [list, retired] of [
+      [opened.rails, false],
+      [opened.retired, true]
+    ]) {
+      const rail = list.find((candidate) => candidate.payer.channelId.toLowerCase() === wanted);
+      if (rail) return { rail, retired };
+    }
+    throw new AgentLaunchError(
+      "rail_not_found",
+      `No channel ${choice.channel} in the spending policy; taskmarket agent status lists them`
+    );
+  }
+  return { rail: selectRail(opened.rails, choice.rail), retired: false };
+}
+function selectRail(rails, id) {
+  if (id !== void 0) {
+    const rail = rails.find((candidate) => candidate.rail.id === id);
+    if (!rail) {
+      throw new AgentLaunchError(
+        "rail_not_found",
+        `No rail ${id} in the spending policy (${rails.map((r) => r.rail.id).join(", ")})`
+      );
+    }
+    return rail;
+  }
+  if (rails.length !== 1) {
+    throw new AgentLaunchError(
+      "rail_required",
+      `The spending policy has ${rails.length} rails; name one with --rail (${rails.map((r) => r.rail.id).join(", ")})`
+    );
+  }
+  return rails[0];
+}
+async function channelView(rail, status, options = {}) {
+  const s = status ?? await rail.payer.channelStatus();
+  const f = s.funding;
+  const budget = BigInt(rail.rail.limits.total);
+  const room = budget - BigInt(f.locked) - BigInt(f.depositing);
+  const blocking = s.divergences.filter((d) => d.blocking).map((d) => d.kind);
+  return {
+    rail: rail.rail.id,
+    route: rail.rail.route,
+    network: rail.rail.network,
+    asset: f.asset,
+    channelId: s.channelId,
+    state: s.closed ? "closed" : s.closing ? "closing" : s.withdrawalPending ? "withdrawal_pending" : blocking.length > 0 ? "blocked" : "open",
+    amounts: {
+      budget: budget.toString(),
+      depositTarget: rail.rail.limits.deposit,
+      depositing: f.depositing,
+      locked: f.locked,
+      charged: f.charged,
+      pending: f.pending,
+      refunded: f.refunded,
+      refundable: f.refundable,
+      lifetimeRoom: (room > 0n ? room : 0n).toString()
+    },
+    pendingOperation: s.pendingOperation ? { kind: s.pendingOperation.kind, id: s.pendingOperation.id } : null,
+    blockingDivergences: blocking,
+    retired: options.retired ?? false
+  };
+}
+function allocationsReader() {
+  const policyPath = getX402PolicyPath();
+  return createX402Allocations({
+    journalPath: getX402JournalPath(),
+    loadPolicy: (options) => loadX402Policy(policyPath, options)
+  });
+}
+async function allocationViews(rails, extra = []) {
+  const ids = [
+    .../* @__PURE__ */ new Set([
+      ...rails.flatMap((r) => [r.rail.budgetAllocationId, r.rail.allocationId]),
+      ...extra
+    ])
+  ].filter((id) => id !== void 0);
+  const reader = allocationsReader();
+  const views = [];
+  for (const id of ids) {
+    try {
+      const { allocation, usage } = await reader.get(id);
+      views.push({
+        allocationId: id,
+        exposure: allocation.exposure,
+        closed: allocation.closedAt !== void 0,
+        caps: {
+          amount: allocation.caps.amount,
+          ...allocation.caps.perDay ? { perDay: allocation.caps.perDay } : {},
+          ...allocation.caps.perMonth ? { perMonth: allocation.caps.perMonth } : {}
+        },
+        used: { total: usage.used, today: usage.day, thisMonth: usage.month }
+      });
+    } catch {
+    }
+  }
+  return views;
+}
+var UNDECIDED = /* @__PURE__ */ new Set([
+  "reserved",
+  "approval_pending",
+  "ready",
+  "dispatched",
+  "unknown",
+  "settled_amount_unknown"
+]);
+async function uncertainPurchases(rails, statuses = /* @__PURE__ */ new Map()) {
+  const records = await listX402Payments({}, getX402JournalPath());
+  const found = [];
+  for (const record2 of records) {
+    if (!record2.invocationId || record2.rail?.id !== BASE_CHANNEL_RAIL_ID) continue;
+    if (!UNDECIDED.has(record2.state)) continue;
+    const rail = rails.find(
+      (r) => record2.origin === r.rail.origin && record2.pathname === r.rail.route
+    );
+    if (!rail) continue;
+    const lease = statuses.get(rail.rail.id)?.pendingOperation;
+    found.push({
+      invocationId: record2.invocationId,
+      rail: rail.rail.id,
+      state: record2.state,
+      authorizedAtomic: record2.authorizedAmount,
+      createdAt: record2.createdAt,
+      blocking: lease?.kind === "payment" && lease.id === record2.invocationId
+    });
+  }
+  for (const rail of rails) {
+    const lease = statuses.get(rail.rail.id)?.pendingOperation;
+    if (lease?.kind === "payment" && !found.some((p) => p.invocationId === lease.id)) {
+      found.push({
+        invocationId: lease.id,
+        rail: rail.rail.id,
+        state: "leased",
+        authorizedAtomic: "0",
+        createdAt: "",
+        blocking: true
+      });
+    }
+  }
+  return found.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
+function withdrawalHatch(channel) {
+  return {
+    kind: "timed-withdrawal",
+    delaySeconds: WITHDRAW_DELAY_SECONDS,
+    state: channel.state === "withdrawal_pending" ? "pending" : "not_started",
+    availableInCli: false,
+    note: `If the router cannot refund cooperatively, the wallet can withdraw the escrow on chain itself: initiate a timed withdrawal, wait ${WITHDRAW_DELAY_SECONDS / 60} minutes, then finalize it to get back what valid claims do not cover. It needs ETH on Base for gas, is never started automatically, and this CLI does not send it yet.`
+  };
+}
+async function requestTopUp(rail, amount) {
+  if (!/^[1-9][0-9]{0,30}$/.test(amount)) {
+    throw new AgentLaunchError("invalid_amount", "A top-up must be a positive USDC amount");
+  }
+  const channel = await channelView(rail);
+  if (channel.state === "closed" || channel.state === "closing") {
+    throw new AgentLaunchError(
+      "channel_closed",
+      `The ${rail.rail.id} channel is ${channel.state}; it takes no more deposits`
+    );
+  }
+  if (channel.state === "withdrawal_pending") {
+    throw new AgentLaunchError(
+      "channel_closed",
+      `A timed withdrawal was started on the ${rail.rail.id} channel; it takes no more deposits`
+    );
+  }
+  if (channel.state === "blocked") {
+    throw new AgentLaunchError(
+      "channel_blocked",
+      `The ${rail.rail.id} channel is blocked (${channel.blockingDivergences.join(", ")}); nothing is deposited until the records agree`
+    );
+  }
+  const room = BigInt(channel.amounts.lifetimeRoom);
+  if (BigInt(amount) > room) {
+    throw new AgentLaunchError(
+      "topup_over_cap",
+      `A top-up of ${formatUsdc(amount)} is over the approved budget: ${formatUsdc(channel.amounts.budget)} in total, ${formatUsdc(BigInt(channel.amounts.budget) - room)} already deposited, so at most ${formatUsdc(room)} more. Refunds do not free budget; a larger budget needs a new approval of the spending policy.`
+    );
+  }
+  try {
+    const allocation = await allocationsReader().get(rail.rail.allocationId);
+    if (allocation.allocation.closedAt !== void 0) {
+      throw new AgentLaunchError(
+        "allocation_closed",
+        `The ${rail.rail.allocationId} allocation is closed; it admits no more purchases or deposits`
+      );
+    }
+  } catch (error) {
+    if (error instanceof AgentLaunchError) throw error;
+  }
+  return {
+    rail: rail.rail.id,
+    amount,
+    outcome: "automatic",
+    channel,
+    note: `${formatUsdc(amount)} fits the approved budget (${formatUsdc(room)} may still be deposited). The channel tops itself up: when a turn needs more than the ${formatUsdc(channel.amounts.refundable)} left, a gasless deposit of ${formatUsdc(channel.amounts.depositTarget)} (or what the turn needs, if more) goes with it. The router takes a deposit only together with a turn's voucher, so nothing was deposited now.`
+  };
+}
+function outcomeOf(operation) {
+  if (operation.state === "confirmed") return "refunded";
+  if (operation.state === "failed") return "failed";
+  return "pending";
+}
+async function closeSession(allocationId2) {
+  try {
+    await allocationsReader().close(allocationId2);
+    return true;
+  } catch (error) {
+    if (error.code === "allocation_not_found") return false;
+    throw error;
+  }
+}
+function closeLines(channel) {
+  const a = channel.amounts;
+  return [
+    `Close the ${channel.rail} channel (${channel.network}) and refund its unused balance`,
+    `Locked ${formatUsdc(a.locked)} (deposited); charged ${formatUsdc(a.charged)} (kept by the router for turns already paid); pending vouchers ${formatUsdc(a.pending)}`,
+    `Refundable now: ${formatUsdc(a.refundable)}, returned to the wallet by the router`,
+    "After closing, the channel takes no more turns. The budget is not freed by the refund."
+  ];
+}
+async function closeChannel(rail, confirm, options = {}) {
+  const retired = options.retired ?? false;
+  const status = await rail.payer.channelStatus();
+  const channel = await channelView(rail, status, { retired });
+  const result = async (outcome, operation2, reconciled) => {
+    const after = operation2 ? await channelView(rail, void 0, { retired }) : channel;
+    let sessionClosed = false;
+    let dropped = false;
+    if (outcome !== "failed") {
+      sessionClosed = await closeSession(rail.rail.allocationId);
+      if (retired) {
+        dropped = (await pruneRetiredRails(allocationsReader())).includes(rail.rail.salt);
+      }
+    }
+    return {
+      rail: rail.rail.id,
+      outcome,
+      reconciled,
+      retired,
+      sessionClosed,
+      dropped,
+      operation: operation2,
+      channel: after,
+      withdrawal: withdrawalHatch(after)
+    };
+  };
+  if (status.closed) return result("closed", null, false);
+  const lease = status.pendingOperation;
+  if (lease?.kind === "lifecycle") {
+    const operation2 = await rail.payer.reconcileOperation(lease.id);
+    return result(outcomeOf(operation2), operation2, true);
+  }
+  if (lease?.kind === "payment") {
+    throw new AgentLaunchError(
+      "channel_operation_pending",
+      `Purchase ${lease.id} on the ${rail.rail.id} channel is unresolved; reconcile it first with taskmarket agent reconcile ${lease.id}. Nothing was refunded.`
+    );
+  }
+  if (channel.state === "blocked") {
+    throw new AgentLaunchError(
+      "channel_blocked",
+      `The ${rail.rail.id} channel is blocked (${channel.blockingDivergences.join(", ")}), so the router cannot refund it cooperatively. ${withdrawalHatch(channel).note}`
+    );
+  }
+  if (channel.state === "withdrawal_pending") {
+    throw new AgentLaunchError(
+      "channel_closed",
+      `A timed withdrawal was started on the ${rail.rail.id} channel; finish it on chain instead`
+    );
+  }
+  if (!await confirm(closeLines(channel))) {
+    throw new AgentLaunchError("not_approved", "The channel was not closed");
+  }
+  const operation = await rail.payer.refund({
+    operationId: `agent-close-${randomUUID2()}`,
+    close: true
+  });
+  return result(outcomeOf(operation), operation, false);
+}
+
+export {
+  XgateError,
+  XgatePurchaseError,
+  routeOfCatalogRow,
+  createAgentTransport,
+  reconcileLeftoverOperations,
+  XGATE_ROUTES,
+  WORKSPACE_CONSENT_VERSION,
+  MAX_RETIRED_RAILS,
+  getAgentPolicyPath,
+  readAgentPolicy,
+  loadAgentPolicy,
+  saveAgentPolicy,
+  assessAgentPolicy,
+  selectModels,
+  settledRetiredRails,
+  openAgentChannels,
+  selectChannel,
+  selectRail,
+  channelView,
+  allocationViews,
+  uncertainPurchases,
+  withdrawalHatch,
+  requestTopUp,
+  closeLines,
+  closeChannel
+};