@lucid-agents/taskmarket 1.17.2 → 1.18.0

package/dist/{chunk-GJQUALXN.js → chunk-MO5KMUTL.js}

@@ -6,21 +6,23 @@ import {
   createBaseChannelRpcReader,
   createWalletAccountFromKeystore,
   createX402Allocations,
-  getTaskmarketHome,
   getX402JournalPath,
   getX402PolicyPath,
-  keystoreExists,
   listX402Payments,
-  loadKeystore,
   loadX402Policy,
   rpcUrlForNetwork
-} from "./chunk-FRV3ZHUR.js";
+} from "./chunk-S4A6V3J3.js";
 import {
-  AgentLaunchError
-} from "./chunk-YM4S6IE4.js";
+  getTaskmarketHome,
+  keystoreExists,
+  loadKeystore
+} from "./chunk-75LS6XS6.js";
 import {
   formatUsdc
-} from "./chunk-73RXOYME.js";
+} from "./chunk-EB6OJBF5.js";
+import {
+  AgentLaunchError
+} from "./chunk-YM4S6IE4.js";
 
 // src/lib/agent/channels.ts
 import { randomUUID as randomUUID2 } from "crypto";
@@ -334,7 +336,11 @@ async function createAgentRails(options) {
       budgetAmount: rail.limits.total,
       depositAmount: rail.limits.deposit,
       policyRuleId: rail.policyRuleId,
-      ...options.fetch ? { fetch: options.fetch } : {}
+      ...options.fetch ? { fetch: options.fetch } : {},
+      confirmationWait: {
+        ...options.confirmationWait,
+        ...options.onConfirmationWait ? { onWait: (progress) => options.onConfirmationWait(rail, progress) } : {}
+      }
     });
     const transport = createTaskMarketTransport({
       payer,
@@ -438,10 +444,12 @@ function createAgentTransport(rails) {
   };
 }
 async function reconcileLeftoverOperations(rails, log = () => void 0) {
-  for (const { rail, payer } of rails) {
+  const usable = [];
+  const blocked = [];
+  for (const entry of rails) {
+    const { rail, payer } = entry;
     let pending = (await payer.channelStatus()).pendingOperation;
-    if (!pending) continue;
-    if (pending.kind === "payment") {
+    if (pending?.kind === "payment") {
       log(`Reconciling payment ${pending.id} left on rail ${rail.id}`);
       try {
         await payer.reconcile(pending.id);
@@ -451,13 +459,22 @@ async function reconcileLeftoverOperations(rails, log = () => void 0) {
         );
       }
       pending = (await payer.channelStatus()).pendingOperation;
-      if (!pending) continue;
     }
+    if (!pending) {
+      usable.push(entry);
+      continue;
+    }
+    const reason = `The ${rail.id} channel has an unresolved ${pending.kind} operation ${pending.id} from an earlier session; it must be reconciled (taskmarket agent reconcile ${pending.id}) before anything else is bought on that channel.`;
+    log(`${reason} Its models are left out of this session.`);
+    blocked.push(reason);
+  }
+  if (usable.length === 0 && blocked.length > 0) {
     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.`
+      `${blocked.join(" ")} Try again later.`
     );
   }
+  return usable;
 }
 
 // src/lib/agent/policy.ts
@@ -469,7 +486,7 @@ var XGATE_ROUTES = [
   "/providers/anthropic/v1/messages",
   "/providers/openai/v1/responses"
 ];
-var WORKSPACE_CONSENT_VERSION = "boat-eu-2026-10";
+var WORKSPACE_CONSENT_VERSION = "boat-eu-2026-10-sync";
 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");
@@ -669,15 +686,31 @@ async function assessAgentPolicy(policy, options) {
   }
   return { reasons, usage };
 }
-function selectModels(policy, requested) {
-  if (requested === void 0) return [...policy.models];
-  if (!policy.models.includes(requested)) {
+function requireApprovedModel(policy, requested) {
+  if (requested !== void 0 && !policy.models.includes(requested)) {
     throw new AgentLaunchError(
       "model_not_allowed",
       `Model ${requested} is not in the approved spending policy (${policy.models.join(", ")})`
     );
   }
-  return [requested];
+}
+function planSessionModels(options) {
+  const { approved, offered, requested, previous } = options;
+  const unavailable = approved.filter((model) => !offered.includes(model));
+  if (offered.length === 0) {
+    throw new AgentLaunchError(
+      "no_qualified_models",
+      `None of the approved models (${approved.join(", ")}) is qualified by xgate on a route the policy pays for`
+    );
+  }
+  if (requested !== void 0 && !offered.includes(requested)) {
+    throw new AgentLaunchError(
+      "model_not_offered",
+      `Model ${requested} is approved, but xgate does not offer it on a route a usable rail of the policy pays for, so this session cannot buy it. This session offers ${offered.join(", ")}`
+    );
+  }
+  const start = requested ?? (previous !== void 0 && offered.includes(previous) ? previous : offered[0]);
+  return { start, unavailable };
 }
 
 // src/lib/agent/retired.ts
@@ -738,7 +771,9 @@ async function openAgentChannels(options = {}) {
     models: options.models ? options.models(policy) : [...policy.models],
     walletAddress: keystore.walletAddress,
     getAccount,
-    ...options.fetch ? { fetch: options.fetch } : {}
+    ...options.fetch ? { fetch: options.fetch } : {},
+    ...options.onConfirmationWait ? { onConfirmationWait: options.onConfirmationWait } : {},
+    ...options.confirmationWait ? { confirmationWait: options.confirmationWait } : {}
   };
   const rails = await createAgentRails(common);
   const retired = await createAgentRails({
@@ -863,9 +898,7 @@ async function uncertainPurchases(rails, statuses = /* @__PURE__ */ new Map()) {
   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
-    );
+    const rail = rails.find((r) => record2.funding?.sessionKey === r.payer.sessionKey);
     if (!rail) continue;
     const lease = statuses.get(rail.rail.id)?.pendingOperation;
     found.push({
@@ -955,6 +988,34 @@ function outcomeOf(operation) {
   if (operation.state === "failed") return "failed";
   return "pending";
 }
+var REFUND_WAIT_TIMEOUT_MS = 9e4;
+var REFUND_WAIT_INTERVAL_MS = 3e3;
+async function awaitRefund(rail, operation, wait = {}) {
+  const timeoutMs = wait.timeoutMs ?? REFUND_WAIT_TIMEOUT_MS;
+  const intervalMs = Math.max(1, wait.intervalMs ?? REFUND_WAIT_INTERVAL_MS);
+  const sleep = wait.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  let current = operation;
+  let waitedMs = 0;
+  while ((current.state === "dispatched" || current.state === "unknown") && current.transaction && waitedMs < timeoutMs) {
+    try {
+      wait.onWait?.({
+        transaction: current.transaction,
+        amount: current.amount,
+        waitedMs,
+        timeoutMs
+      });
+    } catch {
+    }
+    const step = Math.min(intervalMs, timeoutMs - waitedMs);
+    await sleep(step);
+    waitedMs += step;
+    try {
+      current = await rail.payer.reconcileOperation(current.operationId);
+    } catch {
+    }
+  }
+  return current;
+}
 async function closeSession(allocationId2) {
   try {
     await allocationsReader().close(allocationId2);
@@ -975,7 +1036,11 @@ function closeLines(channel) {
 }
 async function closeChannel(rail, confirm, options = {}) {
   const retired = options.retired ?? false;
-  const status = await rail.payer.channelStatus();
+  let status = await rail.payer.channelStatus();
+  if (status.pendingOperation?.kind === "payment" && options.reconcilePurchase) {
+    await options.reconcilePurchase(status.pendingOperation.id);
+    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;
@@ -1002,7 +1067,11 @@ async function closeChannel(rail, confirm, options = {}) {
   if (status.closed) return result("closed", null, false);
   const lease = status.pendingOperation;
   if (lease?.kind === "lifecycle") {
-    const operation2 = await rail.payer.reconcileOperation(lease.id);
+    const operation2 = await awaitRefund(
+      rail,
+      await rail.payer.reconcileOperation(lease.id),
+      options.wait
+    );
     return result(outcomeOf(operation2), operation2, true);
   }
   if (lease?.kind === "payment") {
@@ -1026,10 +1095,17 @@ async function closeChannel(rail, confirm, options = {}) {
   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
-  });
+  const operationId = `agent-close-${randomUUID2()}`;
+  let operation;
+  try {
+    operation = await rail.payer.refund({ operationId, close: true });
+  } catch (error) {
+    if (error.code !== "outcome_uncertain") throw error;
+    const recorded = await rail.payer.reconcileOperation(operationId).catch(() => void 0);
+    if (!recorded || recorded.state !== "dispatched" && recorded.state !== "unknown") throw error;
+    operation = recorded;
+  }
+  operation = await awaitRefund(rail, operation, options.wait);
   return result(outcomeOf(operation), operation, false);
 }
 
@@ -1047,7 +1123,8 @@ export {
   loadAgentPolicy,
   saveAgentPolicy,
   assessAgentPolicy,
-  selectModels,
+  requireApprovedModel,
+  planSessionModels,
   settledRetiredRails,
   openAgentChannels,
   selectChannel,