@lucid-agents/taskmarket 1.17.0 → 1.17.1

package/dist/pi-extensions/xgate.cjs

@@ -2006,11 +2006,293 @@ init_cjs_shims();
 var import_node_path4 = __toESM(require("path"), 1);
 var import_pi_coding_agent = require("@earendil-works/pi-coding-agent");
 
+// src/lib/agent/budget-ui.ts
+init_cjs_shims();
+
+// src/lib/agent/budget-view.ts
+init_cjs_shims();
+var USDC_DECIMALS = 6;
+function formatUsdc(atomic2) {
+  let value;
+  try {
+    value = typeof atomic2 === "bigint" ? atomic2 : BigInt(atomic2);
+  } catch {
+    return "$?";
+  }
+  const negative = value < 0n;
+  const abs = negative ? -value : value;
+  const scale = 10n ** BigInt(USDC_DECIMALS);
+  const fraction = (abs % scale).toString().padStart(USDC_DECIMALS, "0").replace(/0+$/, "");
+  return `${negative ? "-" : ""}$${abs / scale}.${fraction.padEnd(2, "0")}`;
+}
+function formatCredits(value) {
+  const number = Number(value);
+  if (!Number.isFinite(number)) return value;
+  return number >= 100 ? number.toFixed(0) : number.toFixed(1);
+}
+function remainingBudget(view) {
+  const channels = view.channels.filter((channel) => channel.state === "open" && !channel.retired).reduce(
+    (sum, channel) => sum + BigInt(channel.amounts.refundable) + BigInt(channel.amounts.lifetimeRoom),
+    0n
+  );
+  if (!view.budget) return channels;
+  const left = BigInt(view.budget.cap) - BigInt(view.budget.used);
+  const budget = left > 0n ? left : 0n;
+  return channels < budget ? channels : budget;
+}
+function blockingPurchases(view) {
+  const ids = new Set(view.unresolved);
+  for (const channel of view.channels) {
+    if (channel.pendingOperation?.kind === "payment") ids.add(channel.pendingOperation.id);
+  }
+  return [...ids];
+}
+function statusBarText(view) {
+  const parts = [];
+  parts.push(view.lastTurn ? `turn ${formatUsdc(view.lastTurn.chargedAtomic)}` : "turn -");
+  const active = view.channels.filter((channel) => !channel.retired);
+  if (active.length > 0) {
+    const open = active.some((channel) => channel.state === "open");
+    parts.push(
+      open ? `budget ${formatUsdc(remainingBudget(view))} left` : `channel ${active[0].state.replace("_", " ")}`
+    );
+  }
+  const compute = view.compute;
+  if (compute?.configured && compute.availableCredits !== null) {
+    const burn = compute.burnCreditsPerHour !== null ? ` at ${formatCredits(compute.burnCreditsPerHour)}/h` : "";
+    parts.push(
+      `compute ${formatCredits(compute.availableCredits)} cr${burn}${compute.low ? " LOW: /credits" : ""}`
+    );
+  } else if (compute && !compute.configured) {
+    parts.push("compute: not set up");
+  }
+  const blocking = blockingPurchases(view);
+  if (blocking.length > 0) {
+    const id = blocking[0].length > 12 ? `${blocking[0].slice(0, 12)}...` : blocking[0];
+    parts.push(`purchase ${id} unresolved: new turns blocked, see /budget`);
+  }
+  return parts.join(" | ");
+}
+function channelLines(channel) {
+  const a = channel.amounts;
+  return [
+    `Channel ${channel.rail}${channel.retired ? " (retired)" : ""} ${channel.channelId} (${channel.network}, ${channel.route}): ${channel.state.replace("_", " ")}`,
+    `  Locked ${formatUsdc(a.locked)} (deposited, not spent); charged ${formatUsdc(a.charged)}; pending vouchers ${formatUsdc(a.pending)}; refunded ${formatUsdc(a.refunded)}`,
+    `  Refundable ${formatUsdc(a.refundable)}: what further turns can use and a close returns`,
+    `  Budget ${formatUsdc(a.budget)}; ${formatUsdc(a.lifetimeRoom)} may still be deposited; next deposit ${formatUsdc(a.depositTarget)}${Number(a.depositing) > 0 ? `; ${formatUsdc(a.depositing)} being deposited` : ""}`,
+    ...channel.pendingOperation ? [
+      channel.pendingOperation.kind === "payment" ? `  Purchase ${channel.pendingOperation.id} is unresolved and blocks new turns: taskmarket agent reconcile ${channel.pendingOperation.id}` : `  A refund or withdrawal (${channel.pendingOperation.id}) is unresolved: taskmarket agent close checks it again`
+    ] : [],
+    ...channel.blockingDivergences.length > 0 ? [
+      `  Blocked: the journal, the router and the chain disagree (${channel.blockingDivergences.join(", ")})`
+    ] : []
+  ];
+}
+function budgetLines(view) {
+  const lines2 = [
+    `This session: ${view.session.turns} paid turn${view.session.turns === 1 ? "" : "s"}, ${formatUsdc(view.session.chargedAtomic)}${view.lastTurn ? `; last turn ${formatUsdc(view.lastTurn.chargedAtomic)}` : ""}`
+  ];
+  for (const channel of view.channels) lines2.push(...channelLines(channel));
+  for (const allocation of view.allocations) {
+    lines2.push(
+      `Allocation ${allocation.allocationId} (${allocation.exposure})${allocation.closed ? ", closed" : ""}: used ${formatUsdc(allocation.used.total)} of ${formatUsdc(allocation.caps.amount)}${allocation.caps.perDay ? `; today ${formatUsdc(allocation.used.today)} of ${formatUsdc(allocation.caps.perDay)}` : ""}`
+    );
+  }
+  for (const id of blockingPurchases(view)) {
+    lines2.push(uncertainPurchaseMessage(id));
+  }
+  const compute = view.compute;
+  if (compute) lines2.push(...computeLines(compute));
+  return lines2;
+}
+function computeLines(compute) {
+  if (!compute.configured) {
+    return ["Compute credit: not set up; run taskmarket agent credits setup"];
+  }
+  if (compute.error !== void 0 || compute.availableCredits === null) {
+    return [`Compute credit: unavailable (${compute.error ?? "not read"})`];
+  }
+  return [
+    `Compute credit: ${formatCredits(compute.availableCredits)} available${compute.burnCreditsPerHour !== null ? `, burning ${formatCredits(compute.burnCreditsPerHour)} an hour while the sandbox runs` : ""}${compute.low ? ". Low: buy more with /credits" : ""}`,
+    ...compute.pendingPurchases > 0 ? [
+      `  ${compute.pendingPurchases} purchase(s) not settled yet: taskmarket agent credits reconcile`
+    ] : [],
+    ...compute.autoTopUp ? [
+      `  Auto-top-up: $${compute.autoTopUp.amountUsd} below ${compute.autoTopUp.thresholdCredits} credits, at most ${compute.autoTopUp.maxChunksPerDay} a day`
+    ] : []
+  ];
+}
+var LOST_RESPONSE_TEXT = "It was charged, and the response cannot be recovered or regenerated: xgate delivers it live only and keeps no copy. Asking again is a new paid turn.";
+function uncertainPurchaseMessage(invocationId2) {
+  return `The outcome of purchase ${invocationId2} is unknown. It is never sent again, and new turns on its channel are blocked until it is reconciled: taskmarket agent reconcile ${invocationId2}. If it was charged, its response cannot be recovered or regenerated.`;
+}
+var CHARGED_UNDELIVERED = /* @__PURE__ */ new Set([
+  "result_too_large",
+  "response_rejected",
+  "invalid_response",
+  "response_hook_failed"
+]);
+function purchaseFailureNotice(failure) {
+  if (failure.pending) {
+    return {
+      level: "warning",
+      text: uncertainPurchaseMessage(failure.invocationId || "(unknown)")
+    };
+  }
+  const charged = failure.payment?.chargedAtomic;
+  if (charged !== void 0 || CHARGED_UNDELIVERED.has(failure.code)) {
+    return {
+      level: "error",
+      text: `This turn was paid${charged !== void 0 ? ` (${formatUsdc(charged)})` : ""} but its response was lost (${failure.code}). ${LOST_RESPONSE_TEXT}`
+    };
+  }
+  return void 0;
+}
+
+// src/lib/agent/budget-ui.ts
+var BUDGET_STATUS_KEY = "xgate-taskmarket";
+function isBudgetView(value) {
+  const view = value;
+  return !!view && view.version === 1 && Array.isArray(view.channels) && Array.isArray(view.unresolved) && Array.isArray(view.allocations) && typeof view.session === "object";
+}
+function errorCode(error) {
+  const code = error?.code;
+  return typeof code === "string" ? code : "controller_unavailable";
+}
+function withPurchaseNotices(transport, notify) {
+  const wrapped = {
+    models: (signal) => transport.models(signal),
+    async purchase(invocation, signal, onResponse) {
+      try {
+        return await transport.purchase(invocation, signal, onResponse);
+      } catch (error) {
+        const failure = error;
+        if (typeof failure?.pending === "boolean" && typeof failure.code === "string") {
+          const notice = purchaseFailureNotice({
+            code: failure.code,
+            invocationId: typeof failure.invocationId === "string" && failure.invocationId ? failure.invocationId : invocation.id,
+            pending: failure.pending,
+            ...failure.payment ? { payment: failure.payment } : {}
+          });
+          if (notice) notify(notice.text, notice.level);
+        }
+        throw error;
+      }
+    }
+  };
+  if (transport.status) wrapped.status = (signal) => transport.status(signal);
+  if (transport.receipts) wrapped.receipts = (signal) => transport.receipts(signal);
+  if (transport.reconcile) {
+    wrapped.reconcile = (id, signal) => transport.reconcile(id, signal);
+  }
+  return wrapped;
+}
+function isOffer(value) {
+  const offer = value;
+  return !!offer && typeof offer.usdPerCredit === "string" && Array.isArray(offer.denominations) && offer.denominations.every(
+    (entry) => Number.isSafeInteger(entry?.amountUsd) && typeof entry?.credits === "string"
+  );
+}
+function registerBudgetUi(pi2, channel) {
+  let context;
+  let inFlight;
+  const read = async () => {
+    if (!channel) throw Object.assign(new Error("unavailable"), { code: "controller_unavailable" });
+    const value = await channel.budget();
+    if (!isBudgetView(value)) throw Object.assign(new Error("invalid"), { code: "invalid_budget" });
+    return value;
+  };
+  const refresh = (ctx) => {
+    if (ctx) context = ctx;
+    inFlight ??= read().then((view) => {
+      context?.ui.setStatus(BUDGET_STATUS_KEY, statusBarText(view));
+      return view;
+    }).catch(() => {
+      context?.ui.setStatus(BUDGET_STATUS_KEY, "budget unavailable");
+      return void 0;
+    }).finally(() => {
+      inFlight = void 0;
+    });
+    return inFlight;
+  };
+  pi2.on("session_start", async (_event, ctx) => {
+    await refresh(ctx);
+  });
+  pi2.on("turn_end", async (_event, ctx) => {
+    await refresh(ctx);
+  });
+  pi2.registerCommand("budget", {
+    description: "Show what this session cost, the channel (locked, charged, pending vouchers, refundable), allocations, unresolved purchases and compute credit",
+    handler: async (_args, ctx) => {
+      context = ctx;
+      try {
+        const view = await read();
+        ctx.ui.setStatus(BUDGET_STATUS_KEY, statusBarText(view));
+        ctx.ui.notify(budgetLines(view).join("\n"), "info");
+      } catch (error) {
+        ctx.ui.notify(`The budget is unavailable (${errorCode(error)})`, "error");
+      }
+    }
+  });
+  pi2.registerCommand("credits", {
+    description: "Show compute credit and buy a chunk from your compute allocation (asks first; /credits <usd> picks the size)",
+    handler: async (args, ctx) => {
+      context = ctx;
+      if (!channel) {
+        ctx.ui.notify("Compute credit is unavailable (controller_unavailable)", "error");
+        return;
+      }
+      try {
+        const view = await read();
+        if (view.compute) ctx.ui.notify(computeLines(view.compute).join("\n"), "info");
+        if (view.compute && !view.compute.configured) return;
+        const offer = await channel.creditOffer();
+        if (!isOffer(offer) || offer.denominations.length === 0) {
+          ctx.ui.notify("Compute credit is not on sale right now", "error");
+          return;
+        }
+        const requested = args.trim().replace(/^\$/, "");
+        const size = requested ? offer.denominations.find((entry) => String(entry.amountUsd) === requested) : offer.denominations.find((entry) => entry.default) ?? offer.denominations[0];
+        if (!size) {
+          ctx.ui.notify(
+            `Compute credit is sold in $${offer.denominations.map((entry) => entry.amountUsd).join(", $")} chunks`,
+            "error"
+          );
+          return;
+        }
+        if (!ctx.hasUI) {
+          ctx.ui.notify("Buying compute credit needs the interactive session", "error");
+          return;
+        }
+        const approved = await ctx.ui.confirm(
+          "Buy compute credit",
+          `Buy $${size.amountUsd} of compute credit (${size.credits} credits at $${offer.usdPerCredit} each) in USDC from your compute allocation? Its daily and monthly caps apply.`
+        );
+        if (!approved) return;
+        const bought = await channel.buyCredits(size.amountUsd);
+        ctx.ui.notify(
+          `Bought ${bought?.purchase?.credits ?? size.credits} credits; ${bought?.balance?.availableCredits ?? "?"} available`,
+          "info"
+        );
+        await refresh(ctx);
+      } catch (error) {
+        const code = errorCode(error);
+        ctx.ui.notify(
+          code === "purchase_pending" ? "Nothing was bought: an earlier compute purchase may have been paid and is not settled yet. Run taskmarket agent credits reconcile; it never pays again." : code === "controller_unavailable" || code === "aborted" ? "The controller did not answer, so the purchase may still complete. It is never repeated automatically; check with /budget or taskmarket agent credits status." : `Nothing was bought (${code})`,
+          "error"
+        );
+      }
+    }
+  });
+  return { refresh };
+}
+
 // src/lib/agent/inference-channel.ts
 init_cjs_shims();
 var import_net = __toESM(require("net"), 1);
 var MAX_MESSAGE_BYTES = 48 * 1024 * 1024;
 var VIEW_TIMEOUT_MS = 6e4;
+var BUY_TIMEOUT_MS = 5 * 6e4;
 var CODE = /^[a-z0-9_]{1,64}$/;
 function lines(stream, onLine, onOverflow, maxBytes) {
   let chunks = [];
@@ -2147,8 +2429,8 @@ var ChannelXgateTransport = class _ChannelXgateTransport {
     this.requests.write(line);
     return { id, reply };
   }
-  async view(body, signal) {
-    const sent = this.send(body, { timeoutMs: VIEW_TIMEOUT_MS, signal });
+  async view(body, signal, timeoutMs = VIEW_TIMEOUT_MS) {
+    const sent = this.send(body, { timeoutMs, signal });
     if (sent === "too_large") throw new XgateError("message_too_large");
     if (!sent) throw new XgateError("controller_unavailable");
     let reply;
@@ -2211,6 +2493,25 @@ var ChannelXgateTransport = class _ChannelXgateTransport {
   async reconcile(invocationId2, signal) {
     return (await this.view({ op: "reconcile", invocationId: invocationId2 }, signal)).value;
   }
+  /** The controller's budget view (`BudgetView`) for the status bar and `/budget`. */
+  async budget(signal) {
+    return (await this.view({ op: "budget" }, signal)).value;
+  }
+  /** The compute credit sizes and price the controller can buy, for `/credits`. */
+  async creditOffer(signal) {
+    return (await this.view({ op: "credit_offer" }, signal)).value;
+  }
+  /**
+   * `/credits`: ask the controller to buy one chunk of compute credit. The controller's purchase
+   * is journaled and capped; a reply lost here never makes it buy again.
+   */
+  async buyCredits(amountUsd, signal) {
+    return (await this.view(
+      { op: "buy_credits", ...amountUsd !== void 0 ? { amountUsd } : {} },
+      signal,
+      BUY_TIMEOUT_MS
+    )).value;
+  }
 };
 function unavailableTransport() {
   return {
@@ -2236,20 +2537,24 @@ function openTransport() {
 }
 async function taskmarketXgate(pi2) {
   const transport = openTransport();
-  await createXgateExtension({ transport })(pi2);
+  const channel = transport instanceof ChannelXgateTransport ? transport : void 0;
   let context;
   let controllerGone = false;
   pi2.on("session_start", async (_event, ctx) => {
     context = ctx;
     if (controllerGone) ctx.shutdown();
   });
-  if (transport instanceof ChannelXgateTransport) {
-    transport.onClose((reason) => {
+  if (channel) {
+    channel.onClose((reason) => {
       log(`The taskmarket controller is gone (${reason}); ending the session`);
       controllerGone = true;
       context?.shutdown();
     });
   }
+  await createXgateExtension({
+    transport: withPurchaseNotices(transport, (text2, level) => context?.ui.notify(text2, level))
+  })(pi2);
+  registerBudgetUi(pi2, channel);
   pi2.on("model_select", async (event, ctx) => {
     if (event.model.provider === "xgate") return;
     const fallback = event.previousModel?.provider === "xgate" ? event.previousModel : ctx.modelRegistry.getAvailable().find((model) => model.provider === "xgate");

package/dist/reconcile-VEMPNIAO.js

@@ -0,0 +1,83 @@
+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 {
+  openAgentChannels
+} from "./chunk-F5SS4NUF.js";
+import {
+  X402_INVOCATION_ID_PATTERN
+} from "./chunk-3S63AB3C.js";
+import {
+  AgentLaunchError
+} from "./chunk-YM4S6IE4.js";
+import {
+  AGENT_VIEW_VERSION,
+  LOST_RESPONSE_TEXT,
+  formatUsdc
+} from "./chunk-73RXOYME.js";
+import "./chunk-S7SJMJ2I.js";
+
+// src/lib/agent/reconcile.ts
+function outcomeOf(status) {
+  if (status.state === "in_progress") return "in_progress";
+  if (status.charge === "manually_resolved") return "resolved_manually";
+  if (status.uncertain) return "uncertain";
+  if (status.charge === "settled") return "charged";
+  if (status.charge === "none" || status.charge === "released") return "not_charged";
+  return "uncertain";
+}
+function messageFor(outcome, status) {
+  const charged = status.payment?.settledAmount;
+  switch (outcome) {
+    case "charged":
+      return `Charged ${charged !== void 0 ? formatUsdc(charged) : "an amount the router committed"}. If its response did not reach you: ${LOST_RESPONSE_TEXT}`;
+    case "not_charged":
+      return "Nothing was charged. The request is not sent again; ask again in the agent if you still want an answer.";
+    case "in_progress":
+      return "It is still being sent by another process; reconcile it again once that finishes.";
+    case "resolved_manually":
+      return "It was resolved by hand; its recorded amount stands.";
+    default:
+      return "Its outcome is still unknown. It keeps its maximum counted and blocks new turns on its channel; reconcile it again later. It is never sent again.";
+  }
+}
+async function railFor(rails, invocationId) {
+  for (const rail of rails) {
+    try {
+      await rail.payer.status(invocationId);
+      return rail;
+    } catch (error) {
+      if (error.code !== "invocation_not_found") throw error;
+    }
+    const lease = (await rail.payer.channelStatus()).pendingOperation;
+    if (lease?.kind === "payment" && lease.id === invocationId) return rail;
+  }
+  throw new AgentLaunchError(
+    "invocation_not_found",
+    `No agent purchase ${invocationId} is recorded on this device`
+  );
+}
+async function reconcileInvocation(invocationId, deps = {}) {
+  if (!X402_INVOCATION_ID_PATTERN.test(invocationId)) {
+    throw new AgentLaunchError("invalid_invocation_id", `Not an invocation ID: ${invocationId}`);
+  }
+  const opened = await (deps.openChannels ?? openAgentChannels)();
+  const rail = await railFor([...opened.rails, ...opened.retired ?? []], invocationId);
+  const status = await rail.payer.reconcile(invocationId);
+  const lease = (await rail.payer.channelStatus()).pendingOperation;
+  const outcome = outcomeOf(status);
+  return {
+    version: AGENT_VIEW_VERSION,
+    kind: "taskmarket.agent.reconcile",
+    invocationId,
+    rail: rail.rail.id,
+    outcome,
+    state: status.state,
+    charge: status.charge,
+    authorizedAtomic: status.payment?.authorizedAmount ?? null,
+    chargedAtomic: status.payment?.settledAmount ?? null,
+    blocksChannel: lease?.kind === "payment" && lease.id === invocationId,
+    message: messageFor(outcome, status)
+  };
+}
+export {
+  reconcileInvocation
+};

package/dist/status-3Q55PBFC.js

@@ -0,0 +1,18 @@
+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 {
+  collectAgentStatus,
+  listSandboxes,
+  statusLines
+} from "./chunk-JAZ5BWPB.js";
+import "./chunk-MI2GPMCZ.js";
+import "./chunk-EIHZYRIU.js";
+import "./chunk-F5SS4NUF.js";
+import "./chunk-3S63AB3C.js";
+import "./chunk-YM4S6IE4.js";
+import "./chunk-73RXOYME.js";
+import "./chunk-S7SJMJ2I.js";
+export {
+  collectAgentStatus,
+  listSandboxes,
+  statusLines
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lucid-agents/taskmarket",
-  "version": "1.17.0",
+  "version": "1.17.1",
   "type": "module",
   "bin": {
     "taskmarket": "./dist/index.js"
@@ -28,11 +28,11 @@
     "tsx": "^4.7.0",
     "typescript": "^5.3.3",
     "vitest": "^2.0.0",
+    "@taskmarket/agent-host": "0.0.1",
     "@taskmarket/contracts": "0.0.0",
-    "@taskmarket/prettier-config": "0.0.0",
     "@taskmarket/eslint-config": "0.0.0",
+    "@taskmarket/prettier-config": "0.0.0",
     "@taskmarket/remote-tools": "0.0.1",
-    "@taskmarket/agent-host": "0.0.1",
     "@taskmarket/shared": "2.0.0",
     "@taskmarket/x402-payer": "0.1.0"
   },