@lucid-agents/taskmarket 1.17.0 → 1.17.2

package/dist/chunk-LDCFKFF6.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-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/{compatibility-F3RC2GX7.js → chunk-OKZ2NRYZ.js}

@@ -1,8 +1,7 @@
 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-O27J7ZPH.js";
-import "./chunk-S7SJMJ2I.js";
+} from "./chunk-YM4S6IE4.js";
 
 // src/lib/agent/compatibility.ts
 import { existsSync, readFileSync } from "fs";
@@ -123,11 +122,12 @@ function assertAgentCompatibility(options = {}) {
   }
   return runtime;
 }
+
 export {
   AGENT_COMPATIBILITY,
   agentCompatibility,
-  assertAgentCompatibility,
-  findInstalledPackage,
   nodeVersionSupported,
-  piRuntime
+  findInstalledPackage,
+  piRuntime,
+  assertAgentCompatibility
 };

package/dist/chunk-XXD7TWLP.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-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/{chunk-O27J7ZPH.js → chunk-YM4S6IE4.js}

@@ -2,9 +2,10 @@ import { createRequire as __tmCreateRequire } from 'node:module'; import { fileU
 
 // src/lib/agent/errors.ts
 var AgentLaunchError = class extends Error {
-  constructor(code, message) {
+  constructor(code, message, details) {
     super(message);
     this.code = code;
+    this.details = details;
     this.name = "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
+};

package/dist/doctor-7TWLIJWW.js

@@ -0,0 +1,216 @@
+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,
+  assertAgentCompatibility,
+  nodeVersionSupported
+} from "./chunk-OKZ2NRYZ.js";
+import {
+  listSandboxes
+} from "./chunk-XXD7TWLP.js";
+import "./chunk-LDCFKFF6.js";
+import "./chunk-52Q2DCZN.js";
+import {
+  channelView,
+  loadAgentPolicy,
+  openAgentChannels
+} from "./chunk-GJQUALXN.js";
+import {
+  apiUrl,
+  getX402PolicyPath,
+  keystoreExists,
+  loadKeystore,
+  loadX402Policy,
+  rpcUrlForNetwork
+} from "./chunk-FRV3ZHUR.js";
+import "./chunk-YM4S6IE4.js";
+import {
+  AGENT_VIEW_VERSION
+} from "./chunk-73RXOYME.js";
+import "./chunk-S7SJMJ2I.js";
+
+// src/lib/agent/doctor.ts
+var CHAIN_IDS = { "eip155:8453": "0x2105", "eip155:84532": "0x14a34" };
+function reason(error) {
+  return error.code ?? error.message;
+}
+function loopback(url) {
+  return ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+}
+async function runDoctor(deps = {}) {
+  const fetchImpl = deps.fetch ?? fetch;
+  const nodeVersion = deps.nodeVersion ?? process.versions.node;
+  const apiBase = deps.apiUrl ?? apiUrl();
+  const checks = [];
+  const add = (id, status, summary) => checks.push({ id, status, summary });
+  const get = (url, init = {}) => fetchImpl(url, { redirect: "error", signal: AbortSignal.timeout(1e4), ...init });
+  add(
+    "node",
+    nodeVersionSupported(nodeVersion) ? "pass" : "fail",
+    `Node ${nodeVersion}; taskmarket agent needs ${AGENT_COMPATIBILITY.node.minimum} or later`
+  );
+  try {
+    (deps.checkRuntime ?? (() => assertAgentCompatibility({ nodeVersion: "99.0.0" })))();
+    add(
+      "runtime",
+      "pass",
+      `Bundled Pi ${AGENT_COMPATIBILITY.pi.version} and pi-xgate ${AGENT_COMPATIBILITY.piXgate.version} match this build`
+    );
+  } catch (error) {
+    add("runtime", "fail", error.message);
+  }
+  let credentials;
+  let walletAddress;
+  if (await keystoreExists()) {
+    const keystore = await loadKeystore();
+    credentials = { deviceId: keystore.deviceId, apiToken: keystore.apiToken };
+    walletAddress = keystore.walletAddress;
+    add("wallet", "pass", `Wallet ${keystore.walletAddress} (not unlocked)`);
+  } else {
+    add("wallet", "fail", "No wallet; run taskmarket wallet import");
+  }
+  let policy;
+  try {
+    policy = await loadAgentPolicy();
+    const foreign = policy.rails.filter(
+      (rail) => walletAddress && rail.wallet.toLowerCase() !== walletAddress.toLowerCase()
+    );
+    add(
+      "policy",
+      foreign.length > 0 ? "fail" : "pass",
+      foreign.length > 0 ? `Rail ${foreign[0].id} pays from ${foreign[0].wallet}, not this wallet` : `${policy.models.length} approved model(s), ${policy.rails.length} rail(s)`
+    );
+  } catch (error) {
+    add("policy", "fail", error.message);
+  }
+  const rpcUrls = /* @__PURE__ */ new Map();
+  if (policy) {
+    try {
+      const x402Policy = await loadX402Policy(getX402PolicyPath());
+      for (const rail of policy.rails)
+        rpcUrls.set(rail.network, rpcUrlForNetwork(x402Policy, rail.network));
+      add("payment_policy", "pass", `RPC configured for ${[...rpcUrls.keys()].join(", ")}`);
+    } catch (error) {
+      add("payment_policy", "fail", reason(error));
+    }
+  } else {
+    add("payment_policy", "skip", "No spending policy to check");
+  }
+  if (policy && rpcUrls.size > 0 && walletAddress) {
+    try {
+      const opened = await openAgentChannels();
+      const problems = [];
+      for (const rail of opened.rails) {
+        const channel = await channelView(rail);
+        if (channel.pendingOperation) {
+          problems.push(
+            `${channel.rail} has an unresolved ${channel.pendingOperation.kind} ${channel.pendingOperation.id}`
+          );
+        } else if (channel.state !== "open") {
+          problems.push(`${channel.rail} is ${channel.state}`);
+        }
+      }
+      add(
+        "channels",
+        problems.length > 0 ? "warn" : "pass",
+        problems.length > 0 ? problems.join("; ") : `${opened.rails.length} channel(s) open, nothing unresolved`
+      );
+    } catch (error) {
+      add("channels", "fail", reason(error));
+    }
+  } else {
+    add("channels", "skip", "Needs a wallet and a usable spending policy");
+  }
+  try {
+    const response = await get(`${apiBase.replace(/\/+$/, "")}/api/compute/pricing`);
+    await response.body?.cancel().catch(() => void 0);
+    add(
+      "api",
+      response.ok ? "pass" : "fail",
+      `${new URL(apiBase).origin} answered ${response.status}`
+    );
+  } catch (error) {
+    add("api", "fail", `${apiBase} is unreachable: ${reason(error)}`);
+  }
+  if (credentials) {
+    try {
+      const sandboxes = await listSandboxes(credentials, fetchImpl);
+      add(
+        "sandbox",
+        "pass",
+        `The sandbox broker answered; ${sandboxes.length} sandbox(es) on this wallet`
+      );
+    } catch (error) {
+      add("sandbox", "fail", `The sandbox broker is unavailable: ${reason(error)}`);
+    }
+  } else {
+    add("sandbox", "skip", "Needs a wallet");
+  }
+  const api = new URL(apiBase);
+  add(
+    "host_key",
+    api.protocol === "https:" ? "pass" : loopback(api) ? "warn" : "fail",
+    api.protocol === "https:" ? "Sandbox host keys are pinned per connection (ssh-ed25519 only) from the broker over HTTPS; never trusted on first use" : loopback(api) ? "The API is a local development server without TLS; host keys are only as trustworthy as it is" : `The API ${api.origin} is not HTTPS, so the sandbox host keys it returns cannot be trusted`
+  );
+  if (policy) {
+    for (const origin of new Set(policy.rails.map((rail) => rail.origin))) {
+      try {
+        const response = await get(`${origin}/v1/models`, {
+          headers: { accept: "application/json" }
+        });
+        await response.body?.cancel().catch(() => void 0);
+        add(
+          "xgate",
+          response.ok ? "pass" : "fail",
+          `${origin} catalog answered ${response.status}`
+        );
+      } catch (error) {
+        add("xgate", "fail", `${origin} is unreachable: ${reason(error)}`);
+      }
+    }
+    for (const [network, url] of rpcUrls) {
+      try {
+        const response = await get(url, {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "eth_chainId", params: [] })
+        });
+        const body = await response.json();
+        const expected = CHAIN_IDS[network];
+        add(
+          "rpc",
+          body.result === expected ? "pass" : "fail",
+          body.result === expected ? `${network} RPC reachable` : `${network} RPC answered chain ${String(body.result)}, expected ${expected}`
+        );
+      } catch (error) {
+        add("rpc", "fail", `${network} RPC is unreachable: ${reason(error)}`);
+      }
+    }
+  } else {
+    add("xgate", "skip", "No spending policy names an xgate origin");
+  }
+  return {
+    version: AGENT_VIEW_VERSION,
+    kind: "taskmarket.agent.doctor",
+    ok: !checks.some((check) => check.status === "fail"),
+    compatibility: {
+      node: nodeVersion,
+      nodeMinimum: AGENT_COMPATIBILITY.node.minimum,
+      pi: AGENT_COMPATIBILITY.pi.version,
+      piXgate: AGENT_COMPATIBILITY.piXgate.version,
+      protocol: AGENT_COMPATIBILITY.protocol
+    },
+    checks
+  };
+}
+function doctorLines(report) {
+  return [
+    `taskmarket agent doctor (view v${report.version}): ${report.ok ? "ready" : "problems found"}`,
+    ...report.checks.map(
+      (check) => `${check.status.toUpperCase().padEnd(4)} ${check.id}: ${check.summary}`
+    )
+  ];
+}
+export {
+  doctorLines,
+  runDoctor
+};

package/dist/{errors-F3EGNA4F.js → errors-2L357HGA.js}

@@ -1,7 +1,7 @@
 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-O27J7ZPH.js";
+} from "./chunk-YM4S6IE4.js";
 import "./chunk-S7SJMJ2I.js";
 export {
   AgentLaunchError