@lucid-agents/taskmarket 1.17.2 → 1.18.1

package/dist/chunk-RHUDL5WA.js

@@ -0,0 +1,351 @@
+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 {
+  attemptsUsed,
+  computeAllocationId,
+  fileActiveTaskStore,
+  loadDeliverableRecord,
+  readComputeView,
+  taskStage
+} from "./chunk-3FF6JAMK.js";
+import {
+  activeClaim,
+  captureProblem,
+  killedSession,
+  loadSyncState,
+  orphanOf
+} from "./chunk-ONYTKAHC.js";
+import {
+  allocationViews,
+  channelView,
+  getAgentPolicyPath,
+  openAgentChannels,
+  uncertainPurchases,
+  withdrawalHatch
+} from "./chunk-LEVAZYR5.js";
+import {
+  SandboxListOutputSchema,
+  apiUrl,
+  selectedNetwork
+} from "./chunk-YB2B5DPR.js";
+import {
+  AGENT_VIEW_VERSION,
+  blockingPurchases,
+  channelLines,
+  computeLines,
+  formatUsdc
+} from "./chunk-EB6OJBF5.js";
+import {
+  AgentLaunchError
+} from "./chunk-YM4S6IE4.js";
+
+// src/lib/agent/status.ts
+import { promises as fs } from "fs";
+async function readTaskStatus(wallet) {
+  const network = selectedNetwork();
+  const record = await fileActiveTaskStore(wallet, network.chainId).load();
+  if (!record) return null;
+  const spec = record.workspace?.spec;
+  const deliverable = spec ? await loadDeliverableRecord(record.taskId).catch(() => void 0) : void 0;
+  return {
+    taskId: record.taskId,
+    chainId: record.chainId,
+    network: network.name,
+    stage: taskStage(record),
+    claimId: record.claimId ?? null,
+    workspace: record.workspace?.state === "ready" ? record.workspace.path : null,
+    validation: spec ? {
+      attemptsUsed: deliverable ? attemptsUsed(deliverable) : 0,
+      maxAttempts: spec.maxAttempts,
+      deadline: spec.deadline
+    } : null,
+    deliverableId: record.deliverable?.deliverableId ?? record.submission?.deliverableId ?? null,
+    submissionId: record.submission?.submissionId ?? null,
+    updatedAt: record.updatedAt,
+    source: "saved_state"
+  };
+}
+async function readSyncStatus(cwd = process.cwd()) {
+  const view = {
+    project: null,
+    approved: false,
+    approvedAt: null,
+    sessionRunning: false,
+    lastUploadAt: null,
+    uploadedFiles: null,
+    lastPullAt: null,
+    pending: null,
+    captureFailed: null,
+    orphanSandboxId: null,
+    source: "saved_state"
+  };
+  let state;
+  try {
+    view.project = await fs.realpath(cwd);
+    state = await loadSyncState(view.project);
+  } catch {
+    return view;
+  }
+  view.approved = state.approval !== void 0;
+  view.approvedAt = state.approval?.approvedAt ?? null;
+  const session = state.session;
+  const claim = activeClaim(state);
+  view.sessionRunning = claim?.purpose === "session" || !!session && !session.endedAt && !killedSession(state);
+  if (session) {
+    view.lastUploadAt = session.lastUploadAt ?? null;
+    view.uploadedFiles = session.uploadedFiles ?? null;
+    view.lastPullAt = session.lastPullAt ?? null;
+  }
+  if (state.capture?.state === "saved") {
+    view.pending = { ...state.capture.pending, checkedAt: state.capture.capturedAt, saved: true };
+  } else if (session?.pending) {
+    view.pending = { ...session.pending, saved: false };
+  }
+  const problem = captureProblem(state);
+  view.orphanSandboxId = problem ? null : orphanOf(state)?.sandboxId ?? null;
+  if (problem) {
+    view.captureFailed = {
+      kind: problem.kind,
+      at: problem.at,
+      reason: problem.reason,
+      sandboxId: problem.sandboxId ?? null
+    };
+  }
+  return view;
+}
+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
+    },
+    sync: {
+      project: null,
+      approved: false,
+      approvedAt: null,
+      sessionRunning: false,
+      lastUploadAt: null,
+      uploadedFiles: null,
+      lastPullAt: null,
+      pending: null,
+      captureFailed: null,
+      orphanSandboxId: null,
+      source: "saved_state"
+    },
+    task: 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.sync = await (deps.readSync ?? readSyncStatus)();
+  if (view.wallet) {
+    try {
+      view.task = await (deps.readTask ?? readTaskStatus)(view.wallet.address);
+    } catch (error) {
+      view.taskError = message(error);
+    }
+  }
+  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));
+  lines.push(...syncLines(view.sync));
+  lines.push(...taskLines(view.task, view.taskError));
+  return lines;
+}
+var STAGES = {
+  claiming: "claiming (a claim may have been sent; the next session confirms it before anything else)",
+  claimed: "claimed (the task workspace is not set up yet)",
+  working: "working (workspace ready, not validated yet)",
+  frozen: "frozen (validated, waiting for your approval to submit)",
+  submitting: "submitting (sent; the next session looks it up before anything is sent again)",
+  submitted: "submitted (not yet accepted or paid)",
+  stopped: "stopped"
+};
+function taskLines(task, error) {
+  if (error) return [`Marketplace task: the run state cannot be read (${error})`];
+  if (!task) return ["Marketplace task: none"];
+  const lines = [`Marketplace task ${task.taskId} on ${task.network}: ${STAGES[task.stage]}`];
+  if (task.claimId) lines.push(`  Claim: ${task.claimId}`);
+  if (task.workspace) lines.push(`  Workspace (in the sandbox): ${task.workspace}`);
+  if (task.validation) {
+    lines.push(
+      `  Validation: ${task.validation.attemptsUsed} of ${task.validation.maxAttempts} attempt(s) used, until ${task.validation.deadline}`
+    );
+  }
+  if (task.deliverableId) lines.push(`  Deliverable: ${task.deliverableId}`);
+  if (task.submissionId) lines.push(`  Submission: ${task.submissionId}`);
+  lines.push(`  As recorded ${task.updatedAt}`);
+  return lines;
+}
+function syncLines(sync) {
+  if (!sync.project) return ["Workspace sync: this directory cannot be read"];
+  const lines = [
+    `Workspace sync (${sync.project}): ${sync.approved ? `upload approved ${sync.approvedAt}` : "upload not approved yet"}${sync.sessionRunning ? "; a session is running here" : ""}`
+  ];
+  if (sync.lastUploadAt) {
+    lines.push(`  Last upload: ${sync.lastUploadAt} (${sync.uploadedFiles ?? 0} file(s))`);
+  }
+  if (sync.lastPullAt) lines.push(`  Last pull: ${sync.lastPullAt}`);
+  if (sync.pending) {
+    const { clean, conflict, blocked } = sync.pending;
+    const notSaved = sync.pending.notSaved ?? 0;
+    const tooDeep = sync.pending.tooDeep ?? 0;
+    const waiting = `${clean + conflict} change(s) to pull${conflict ? ` (${conflict} in conflict)` : ""}${notSaved ? `, ${notSaved} too large to have been saved` : ""}${tooDeep ? `, ${tooDeep} director(ies) nested too deep to have been saved (taskmarket agent pull --keep-local <dir> acknowledges one, --discard all)` : ""}${blocked ? `, ${blocked} blocked` : ""}`;
+    lines.push(
+      sync.pending.saved ? `  Saved from the last session: ${waiting}; review them with taskmarket agent pull` : `  In the sandbox: ${waiting}, as counted ${sync.pending.checkedAt} (not checked live, which would resume the sandbox)`
+    );
+  }
+  if (sync.orphanSandboxId) {
+    lines.push(
+      `  A killed --no-sync session left sandbox ${sync.orphanSandboxId}: taskmarket agent pull --recover brings back what the agent made there, until it stops once idle.`
+    );
+  }
+  if (sync.captureFailed) {
+    const failed = sync.captureFailed;
+    const where = failed.sandboxId ? ` (sandbox ${failed.sandboxId})` : "";
+    lines.push(
+      failed.kind === "interrupted" ? `  The last session ended at ${failed.at} before its changes were saved${where}: recover them with taskmarket agent pull --recover, or drop them with taskmarket agent pull --discard. New sessions wait until then.` : `  The last session's changes could not be saved${where}: ${failed.reason}. Recover them with taskmarket agent pull --recover, or drop them with taskmarket agent pull --discard. New sessions wait until then.`
+    );
+  }
+  return lines;
+}
+
+export {
+  readTaskStatus,
+  readSyncStatus,
+  listSandboxes,
+  collectAgentStatus,
+  statusLines,
+  taskLines,
+  syncLines
+};