@lucid-agents/taskmarket 1.16.0 → 1.17.1

package/dist/chunk-JAZ5BWPB.js

@@ -0,0 +1,181 @@
+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 {
+  computeAllocationId,
+  readComputeView
+} from "./chunk-MI2GPMCZ.js";
+import {
+  allocationViews,
+  channelView,
+  getAgentPolicyPath,
+  openAgentChannels,
+  uncertainPurchases,
+  withdrawalHatch
+} from "./chunk-F5SS4NUF.js";
+import {
+  SandboxListOutputSchema,
+  apiUrl
+} from "./chunk-3S63AB3C.js";
+import {
+  AgentLaunchError
+} from "./chunk-YM4S6IE4.js";
+import {
+  AGENT_VIEW_VERSION,
+  blockingPurchases,
+  channelLines,
+  computeLines,
+  formatUsdc
+} from "./chunk-73RXOYME.js";
+
+// src/lib/agent/status.ts
+async function listSandboxes(credentials, fetchImpl = fetch) {
+  const response = await fetchImpl(`${apiUrl().replace(/\/+$/, "")}/api/sandboxes/list`, {
+    method: "POST",
+    redirect: "error",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(credentials),
+    signal: AbortSignal.timeout(15e3)
+  });
+  if (!response.ok) {
+    await response.body?.cancel().catch(() => void 0);
+    throw new Error(`the sandbox broker answered ${response.status}`);
+  }
+  const parsed = SandboxListOutputSchema.safeParse(await response.json());
+  if (!parsed.success) throw new Error("the sandbox list is malformed");
+  return parsed.data.sandboxes.map((s) => ({
+    sandboxId: s.sandboxId,
+    purpose: s.purpose,
+    state: s.state,
+    meteredSeconds: s.meteredSeconds,
+    lastActiveAt: s.lastActiveAt,
+    expiresAt: s.expiresAt,
+    creditWarning: s.creditWarning,
+    creditGraceUntil: s.creditGraceUntil
+  }));
+}
+function message(error) {
+  return error.code ?? error.message;
+}
+async function collectAgentStatus(deps = {}) {
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  const view = {
+    version: AGENT_VIEW_VERSION,
+    kind: "taskmarket.agent.status",
+    generatedAt: now().toISOString(),
+    wallet: null,
+    policy: { state: "missing", path: getAgentPolicyPath(), models: [] },
+    channels: [],
+    purchases: { uncertain: [] },
+    inference: { blocked: false, reasons: [] },
+    allocations: [],
+    sandbox: { state: "no_wallet", sandboxes: [] },
+    compute: {
+      configured: false,
+      availableCredits: null,
+      reservedCredits: null,
+      burnCreditsPerHour: null,
+      low: false,
+      warning: null,
+      pendingPurchases: 0,
+      autoTopUp: null
+    }
+  };
+  const reasons = view.inference.reasons;
+  let credentials;
+  try {
+    const opened = await (deps.openChannels ?? openAgentChannels)();
+    view.wallet = { address: opened.keystore.walletAddress };
+    credentials = { deviceId: opened.keystore.deviceId, apiToken: opened.keystore.apiToken };
+    view.policy = { state: "approved", path: view.policy.path, models: [...opened.policy.models] };
+    const statuses = /* @__PURE__ */ new Map();
+    for (const rail of opened.rails) {
+      const status = await rail.payer.channelStatus();
+      statuses.set(rail.rail.id, status);
+      const channel = await channelView(rail, status);
+      view.channels.push({ ...channel, withdrawal: withdrawalHatch(channel) });
+    }
+    for (const rail of opened.retired ?? []) {
+      const channel = await channelView(rail, void 0, { retired: true });
+      view.channels.push({ ...channel, withdrawal: withdrawalHatch(channel) });
+    }
+    view.purchases.uncertain = [
+      ...await uncertainPurchases(opened.rails, statuses),
+      ...await uncertainPurchases(opened.retired ?? [])
+    ];
+    view.allocations = await allocationViews(opened.rails, [
+      await (deps.computeAllocation ?? computeAllocationId)()
+    ]);
+  } catch (error) {
+    if (error instanceof AgentLaunchError && error.code === "wallet_required") {
+      reasons.push("no wallet: run taskmarket wallet import");
+    } else if (error instanceof AgentLaunchError && error.code === "setup_required") {
+      reasons.push("no approved spending policy");
+    } else {
+      view.policy = { ...view.policy, state: "invalid", error: message(error) };
+      reasons.push(`the spending policy cannot be used: ${message(error)}`);
+    }
+  }
+  const active = view.channels.filter((channel) => !channel.retired);
+  for (const id of blockingPurchases({ channels: active, unresolved: [] })) {
+    reasons.push(`purchase ${id} is unresolved: taskmarket agent reconcile ${id}`);
+  }
+  for (const channel of active) {
+    if (channel.state !== "open") reasons.push(`channel ${channel.rail} is ${channel.state}`);
+  }
+  if (credentials) {
+    try {
+      view.sandbox = {
+        state: "ok",
+        sandboxes: await (deps.listSandboxes ?? listSandboxes)(credentials)
+      };
+    } catch (error) {
+      view.sandbox = { state: "unavailable", sandboxes: [], error: message(error) };
+    }
+  }
+  const warning = view.sandbox.sandboxes.find((s) => s.purpose === "interactive" && s.creditWarning)?.creditWarning ?? null;
+  view.compute = await (deps.readCompute ?? readComputeView)({ warning });
+  view.inference.blocked = reasons.length > 0;
+  return view;
+}
+function statusLines(view) {
+  const lines = [
+    `taskmarket agent status (view v${view.version}, ${view.generatedAt})`,
+    view.wallet ? `Wallet: ${view.wallet.address}` : "Wallet: none",
+    `Spending policy: ${view.policy.state}${view.policy.models.length ? ` (${view.policy.models.join(", ")})` : ""}${view.policy.error ? `: ${view.policy.error}` : ""}`
+  ];
+  for (const channel of view.channels) {
+    lines.push(...channelLines(channel));
+    if (channel.state === "blocked" || channel.state === "withdrawal_pending") {
+      lines.push(`  ${channel.withdrawal.note}`);
+    }
+  }
+  if (view.purchases.uncertain.length === 0) {
+    lines.push("Purchases with an unknown outcome: none");
+  } else {
+    lines.push("Purchases with an unknown outcome (never resent; reconcile them):");
+    for (const purchase of view.purchases.uncertain) {
+      lines.push(
+        `  ${purchase.invocationId} on ${purchase.rail}: ${purchase.state}, at most ${formatUsdc(purchase.authorizedAtomic)}${purchase.blocking ? ", blocks new turns" : ""}`
+      );
+    }
+  }
+  lines.push(
+    view.inference.blocked ? `New inference: blocked (${view.inference.reasons.join("; ")})` : "New inference: ready"
+  );
+  if (view.sandbox.state === "ok") {
+    lines.push(
+      view.sandbox.sandboxes.length === 0 ? "Sandbox: none" : `Sandbox: ${view.sandbox.sandboxes.map(
+        (s) => `${s.sandboxId} ${s.purpose} ${s.state}${s.creditWarning ? ` (${s.creditWarning})` : ""}`
+      ).join("; ")}`
+    );
+  } else if (view.sandbox.state === "unavailable") {
+    lines.push(`Sandbox: unavailable (${view.sandbox.error})`);
+  }
+  lines.push(...computeLines(view.compute));
+  return lines;
+}
+
+export {
+  listSandboxes,
+  collectAgentStatus,
+  statusLines
+};

package/dist/chunk-MI2GPMCZ.js

@@ -0,0 +1,154 @@
+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 {
+  buyComputeCredit,
+  fetchComputePricing,
+  listPendingComputePurchases,
+  loadComputeCreditConfig,
+  onComputeBalanceObserved,
+  readComputeCreditStatus
+} from "./chunk-EIHZYRIU.js";
+import {
+  AgentLaunchError
+} from "./chunk-YM4S6IE4.js";
+import {
+  burnRate,
+  computeLow
+} from "./chunk-73RXOYME.js";
+
+// ../../packages/remote-tools/dist/backend.js
+var SANDBOX_TOOL_USER = "agent";
+var SandboxUnavailableError = class extends Error {
+  reason;
+  constructor(reason, options) {
+    super(`Sandbox unavailable, tools are disabled (no local fallback): ${reason}`, options);
+    this.name = "SandboxUnavailableError";
+    this.reason = reason;
+  }
+};
+
+// src/lib/agent/compute.ts
+async function readComputeView(options = {}) {
+  const warning = options.warning ?? null;
+  const empty = {
+    availableCredits: null,
+    reservedCredits: null,
+    burnCreditsPerHour: null,
+    low: warning === "low_credit" || warning === "credit_exhausted",
+    warning,
+    pendingPurchases: 0,
+    autoTopUp: null
+  };
+  let config;
+  try {
+    config = await loadComputeCreditConfig();
+  } catch (error) {
+    return { configured: false, ...empty, error: error.message };
+  }
+  if (!config) return { configured: false, ...empty };
+  try {
+    let status = await readComputeCreditStatus();
+    if (options.observe && await options.observe({ availableCredits: status.balance.availableCredits })) {
+      status = await readComputeCreditStatus();
+    }
+    const burn = burnRate(status.debits);
+    const autoTopUp = config.autoTopUp ? {
+      thresholdCredits: config.autoTopUp.thresholdCredits,
+      amountUsd: config.autoTopUp.amountUsd,
+      maxChunksPerDay: config.autoTopUp.maxChunksPerDay
+    } : null;
+    return {
+      configured: true,
+      availableCredits: status.balance.availableCredits,
+      reservedCredits: status.balance.reservedCredits,
+      burnCreditsPerHour: burn,
+      low: computeLow({
+        availableCredits: status.balance.availableCredits,
+        burnCreditsPerHour: burn,
+        warning,
+        ...autoTopUp ? { thresholdCredits: autoTopUp.thresholdCredits } : {}
+      }),
+      warning,
+      pendingPurchases: (await listPendingComputePurchases()).length,
+      autoTopUp
+    };
+  } catch (error) {
+    return {
+      configured: true,
+      ...empty,
+      error: error.code ?? error.message
+    };
+  }
+}
+async function computeAllocationId() {
+  return (await loadComputeCreditConfig().catch(() => void 0))?.allocationId;
+}
+async function computeCreditOffer() {
+  const pricing = await fetchComputePricing();
+  return {
+    usdPerCredit: pricing.usdPerCredit,
+    denominations: pricing.denominations.map((entry) => ({
+      amountUsd: entry.amountUsd,
+      credits: entry.credits,
+      default: entry.default
+    }))
+  };
+}
+async function buyComputeChunk(amountUsd) {
+  const pricing = await fetchComputePricing();
+  const size = amountUsd ?? (pricing.denominations.find((entry) => entry.default) ?? pricing.denominations[0])?.amountUsd;
+  if (size === void 0) {
+    throw new AgentLaunchError("invalid_amount", "The API sells no compute credit sizes");
+  }
+  const bought = await buyComputeCredit({ amountUsd: size });
+  return { purchase: bought.purchase, balance: bought.balance, amountUsd: size };
+}
+function computeCreditObserver(log) {
+  return async (observation) => {
+    try {
+      const { topUp } = await onComputeBalanceObserved(observation);
+      if (topUp.action === "bought") log("Compute credit auto-top-up bought one chunk");
+      else if (topUp.action === "skipped")
+        log(`Compute credit auto-top-up skipped: ${topUp.reason}`);
+      return topUp.action === "bought";
+    } catch (error) {
+      log(
+        `Compute credit auto-top-up failed: ${error.code ?? error.message}`
+      );
+      return false;
+    }
+  };
+}
+function insufficientCredit(error) {
+  return error instanceof SandboxUnavailableError && /\binsufficient_credit\b/.test(error.reason);
+}
+async function openSandbox(createBroker, observe) {
+  const first = createBroker();
+  try {
+    await first.connect("start");
+    return first;
+  } catch (error) {
+    if (!insufficientCredit(error)) throw error;
+    if (!await observe({ creditWarning: "credit_exhausted" })) {
+      throw new AgentLaunchError("insufficient_credit", error.reason);
+    }
+  }
+  const retry = createBroker();
+  try {
+    await retry.connect("start");
+    return retry;
+  } catch (error) {
+    if (insufficientCredit(error)) throw new AgentLaunchError("insufficient_credit", error.reason);
+    throw error;
+  }
+}
+
+export {
+  SANDBOX_TOOL_USER,
+  SandboxUnavailableError,
+  readComputeView,
+  computeAllocationId,
+  computeCreditOffer,
+  buyComputeChunk,
+  computeCreditObserver,
+  openSandbox
+};

package/dist/chunk-OKZ2NRYZ.js

@@ -0,0 +1,133 @@
+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 {
+  AgentLaunchError
+} from "./chunk-YM4S6IE4.js";
+
+// src/lib/agent/compatibility.ts
+import { existsSync, readFileSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+var AGENT_COMPATIBILITY = {
+  manifestVersion: 1,
+  pi: { package: "@earendil-works/pi-coding-agent", version: "0.85.1" },
+  piAi: { package: "@earendil-works/pi-ai", version: "0.85.1" },
+  piXgate: { package: "@lucid-agents/pi-xgate", version: "0.1.6" },
+  xgateClient: { package: "@lucid-agents/xgate-client", version: "0.1.6" },
+  /**
+   * Pi 0.85.1 takes these (and pi-ai) at `^0.85.1`, so a later 0.85.x could otherwise be installed
+   * under the pinned Pi without anyone verifying it. Checked as Pi itself resolves them, with
+   * pi-ai.
+   */
+  piPackages: [
+    { package: "@earendil-works/pi-agent-core", version: "0.85.1" },
+    { package: "@earendil-works/pi-tui", version: "0.85.1" },
+    { package: "@earendil-works/chord", version: "0.85.1" },
+    { package: "@earendil-works/pi-telemetry", version: "0.85.1" }
+  ],
+  /** What the remote tool extension and the broker connector are built with besides Pi. */
+  support: [{ package: "ssh2", version: "1.17.0" }],
+  /**
+   * pi-xgate 0.1.6 and xgate-client 0.1.6 declare `>=24.19 <25`. The lower bound is enforced at
+   * launch; no upper bound is, since nothing the agent runs is known to break on a later Node.
+   */
+  node: { minimum: "24.19.0" },
+  protocol: {
+    /** `@taskmarket/x402-payer` request/status/reconcile API. */
+    payerApi: 1,
+    /** The router's channel profile the payer speaks to xgate. */
+    paymentProfile: "base-batch-channel-v1",
+    /** JSON lines between pi-xgate inside Pi and the controller's payer (fds 6 and 7). */
+    inferenceChannel: 1,
+    /** JSON lines between the remote tools inside Pi and the controller's broker (fds 4 and 5). */
+    sandboxChannel: 1,
+    /** The redaction values the controller hands the Pi guard (fd 3). */
+    secretsChannel: 1
+  }
+};
+function agentCompatibility(taskmarketVersion) {
+  return { taskmarket: taskmarketVersion, ...AGENT_COMPATIBILITY };
+}
+function parseVersion(version) {
+  const match = /^v?(\d+)\.(\d+)\.(\d+)/.exec(version.trim());
+  return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : void 0;
+}
+function compare(a, b) {
+  for (let i = 0; i < 3; i++) if (a[i] !== b[i]) return a[i] - b[i];
+  return 0;
+}
+function nodeVersionSupported(version) {
+  const parsed = parseVersion(version);
+  return !!parsed && compare(parsed, parseVersion(AGENT_COMPATIBILITY.node.minimum)) >= 0;
+}
+function findInstalledPackage(name, fromDir) {
+  let dir = fromDir;
+  for (; ; ) {
+    const manifest = path.join(dir, "node_modules", ...name.split("/"), "package.json");
+    if (existsSync(manifest)) {
+      const pkg = JSON.parse(readFileSync(manifest, "utf8"));
+      return {
+        dir: path.dirname(manifest),
+        version: typeof pkg.version === "string" ? pkg.version : ""
+      };
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+var here = path.dirname(fileURLToPath(import.meta.url));
+function piRuntime(fromDir = here) {
+  const staged = path.join(fromDir, "pi");
+  const packageDir = existsSync(path.join(staged, "package.json")) ? staged : findInstalledPackage(AGENT_COMPATIBILITY.pi.package, fromDir)?.dir;
+  if (!packageDir) return void 0;
+  return { packageDir, cliPath: path.join(packageDir, "dist", "bundle", "cli.js") };
+}
+var reinstall = "reinstall @lucid-agents/taskmarket";
+function assertAgentCompatibility(options = {}) {
+  const nodeVersion = options.nodeVersion ?? process.versions.node;
+  if (!nodeVersionSupported(nodeVersion)) {
+    throw new AgentLaunchError(
+      "unsupported_node",
+      `taskmarket agent needs Node ${AGENT_COMPATIBILITY.node.minimum} or later; this is Node ${nodeVersion}. Other taskmarket commands work on this Node.`
+    );
+  }
+  const fromDir = options.fromDir ?? here;
+  const runtime = piRuntime(fromDir);
+  if (!runtime || !existsSync(runtime.cliPath)) {
+    throw new AgentLaunchError(
+      "incompatible_install",
+      `Pi, which taskmarket agent runs, is missing from this install; ${reinstall}`
+    );
+  }
+  const pi = JSON.parse(readFileSync(path.join(runtime.packageDir, "package.json"), "utf8"));
+  const expected = AGENT_COMPATIBILITY.pi;
+  if (pi.name !== expected.package || pi.version !== expected.version) {
+    throw new AgentLaunchError(
+      "incompatible_install",
+      `This install has ${String(pi.name)} ${String(pi.version)}; taskmarket agent requires ${expected.package} ${expected.version}. ${reinstall}`
+    );
+  }
+  const shipped = path.join(fromDir, "agent-compatibility.json");
+  if (existsSync(shipped)) {
+    const manifest = JSON.parse(readFileSync(shipped, "utf8"));
+    const mismatched = ["pi", "piAi", "piXgate", "xgateClient"].filter(
+      (key) => manifest[key]?.version !== AGENT_COMPATIBILITY[key].version
+    );
+    if (mismatched.length > 0 || manifest.protocol?.inferenceChannel !== AGENT_COMPATIBILITY.protocol.inferenceChannel) {
+      throw new AgentLaunchError(
+        "incompatible_install",
+        `dist/agent-compatibility.json does not match this build of taskmarket agent; ${reinstall}`
+      );
+    }
+  }
+  return runtime;
+}
+
+export {
+  AGENT_COMPATIBILITY,
+  agentCompatibility,
+  nodeVersionSupported,
+  findInstalledPackage,
+  piRuntime,
+  assertAgentCompatibility
+};

package/dist/chunk-S7SJMJ2I.js

@@ -0,0 +1,38 @@
+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);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __require,
+  __commonJS,
+  __toESM
+};

package/dist/chunk-YM4S6IE4.js

@@ -0,0 +1,15 @@
+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);
+
+// src/lib/agent/errors.ts
+var AgentLaunchError = class extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "AgentLaunchError";
+  }
+};
+
+export {
+  AgentLaunchError
+};

package/dist/compatibility-KUYGZSUC.js

@@ -0,0 +1,19 @@
+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 {
+  AGENT_COMPATIBILITY,
+  agentCompatibility,
+  assertAgentCompatibility,
+  findInstalledPackage,
+  nodeVersionSupported,
+  piRuntime
+} from "./chunk-OKZ2NRYZ.js";
+import "./chunk-YM4S6IE4.js";
+import "./chunk-S7SJMJ2I.js";
+export {
+  AGENT_COMPATIBILITY,
+  agentCompatibility,
+  assertAgentCompatibility,
+  findInstalledPackage,
+  nodeVersionSupported,
+  piRuntime
+};