@lucid-agents/taskmarket 1.17.2 → 1.18.1

package/dist/chunk-LDCFKFF6.js

@@ -1,154 +0,0 @@
-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-52Q2DCZN.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-XXD7TWLP.js

@@ -1,181 +0,0 @@
-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-LDCFKFF6.js";
-import {
-  allocationViews,
-  channelView,
-  getAgentPolicyPath,
-  openAgentChannels,
-  uncertainPurchases,
-  withdrawalHatch
-} from "./chunk-GJQUALXN.js";
-import {
-  SandboxListOutputSchema,
-  apiUrl
-} from "./chunk-FRV3ZHUR.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/reconcile-XZR2UYSW.js

@@ -1,83 +0,0 @@
-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-GJQUALXN.js";
-import {
-  X402_INVOCATION_ID_PATTERN
-} from "./chunk-FRV3ZHUR.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
-};