@lucid-agents/taskmarket 1.17.0 → 1.17.2

package/dist/chunk-52Q2DCZN.js

@@ -0,0 +1,1099 @@
+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 {
+  ApiError,
+  ComputeCreditBuyOutputSchema,
+  ComputeCreditPricingSchema,
+  ComputeCreditStatusOutputSchema,
+  X402PayError,
+  apiErrorEnvelopeOf,
+  apiGet,
+  apiOrigin,
+  apiPost,
+  apiUrl,
+  assertX402HeaderName,
+  assertX402HeaderValue,
+  createEvmPerRequestRail,
+  createMppTempoCredential,
+  createTaskmarketFeeRail,
+  createWalletAccountFromKeystore,
+  createX402Allocations,
+  createX402Payer,
+  failureMessage,
+  getTaskmarketHome,
+  getX402JournalPath,
+  getX402Payment,
+  getX402PolicyPath,
+  idempotencyHeaders,
+  legalReceiptHeadersForKeystore,
+  loadKeystore,
+  loadX402Policy,
+  parseFailureBody,
+  paymentProtocolOf,
+  readFailureBody,
+  readMppTempoChallenge,
+  reconcileX402Payment,
+  resolveIdempotencyKey,
+  selectedNetwork,
+  withIdempotentWrite,
+  withX402FileLock
+} from "./chunk-FRV3ZHUR.js";
+
+// src/lib/compute-credits.ts
+import { randomUUID as randomUUID4 } from "crypto";
+import { promises as fs2 } from "fs";
+import path2 from "path";
+
+// src/lib/x402-fee.ts
+import { randomUUID as randomUUID3 } from "crypto";
+
+// src/lib/paid-write.ts
+function paidWriteRequest(keystore, path3, body, idempotencyKey) {
+  return {
+    url: `${apiUrl()}${path3}`,
+    headers: {
+      "Content-Type": "application/json",
+      ...legalReceiptHeadersForKeystore(keystore, path3, "POST"),
+      ...idempotencyHeaders(idempotencyKey)
+    },
+    body: JSON.stringify(body)
+  };
+}
+function refusedPaidWrite(path3, status, read, idempotencyKey) {
+  return new ApiError(
+    status,
+    `POST ${path3} failed (${status}): ${read.text}`,
+    idempotencyKey,
+    apiErrorEnvelopeOf(read.body) ?? void 0
+  );
+}
+function failedAfterPayment(path3, status, read, idempotencyKey) {
+  return new ApiError(
+    status,
+    failureMessage(`POST ${path3} failed after payment`, status, read),
+    idempotencyKey,
+    apiErrorEnvelopeOf(read.body) ?? void 0
+  );
+}
+
+// src/lib/mpp.ts
+var RETRYABLE_STATUSES = /* @__PURE__ */ new Set([502, 503, 504]);
+function inFlight(path3, read, key) {
+  const envelope = apiErrorEnvelopeOf(read.body) ?? void 0;
+  const txHash = read.body?.taskmarket?.txHash;
+  return new ApiError(
+    409,
+    `POST ${path3}: the payment transfer${typeof txHash === "string" ? ` ${txHash}` : ""} was submitted but its outcome is not known yet. Do not pay again; re-run with TASKMARKET_IDEMPOTENCY_KEY=${key} to check this write.`,
+    key,
+    envelope
+  );
+}
+async function mppPost(path3, body, options = {}) {
+  const keystore = await loadKeystore();
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+  const idempotencyKey = resolveIdempotencyKey(options.idempotencyKey);
+  const chainId = options.chainId ?? selectedNetwork().chainId;
+  const request = paidWriteRequest(keystore, path3, { chainId, ...body }, idempotencyKey);
+  const send = (headers) => fetchImpl(request.url, {
+    method: "POST",
+    redirect: "error",
+    headers: { ...request.headers, ...headers },
+    body: request.body
+  });
+  return withIdempotentWrite(idempotencyKey, async () => {
+    const r1 = await send({});
+    if (r1.status !== 402) {
+      if (r1.ok) return { data: await r1.json(), idempotencyKey };
+      throw refusedPaidWrite(path3, r1.status, await readFailureBody(r1), idempotencyKey);
+    }
+    const challenge = readMppTempoChallenge(r1.headers);
+    if (!challenge) throw new Error("No payment methods accepted by server");
+    const account = options.account ?? await createWalletAccountFromKeystore(keystore);
+    const credential = await createMppTempoCredential({
+      challenge,
+      signer: { address: account.address, sign: (args) => account.sign(args) },
+      chainId,
+      nowSeconds: options.nowSeconds?.(),
+      expect: options.expect && {
+        amount: options.expect.amount,
+        recipient: options.expect.payTo
+      }
+    });
+    const now = options.nowSeconds ?? (() => Math.floor(Date.now() / 1e3));
+    const maxRetries = options.maxPaidRetries ?? 2;
+    for (let attempt = 0; ; attempt++) {
+      const canRetry = attempt < maxRetries && now() < credential.validBefore;
+      let r2;
+      try {
+        r2 = await send({ Authorization: credential.authorization });
+      } catch (error) {
+        if (canRetry) continue;
+        throw error;
+      }
+      if (r2.ok) return { data: await r2.json(), idempotencyKey };
+      const read = await readFailureBody(r2);
+      if (RETRYABLE_STATUSES.has(r2.status) && canRetry) continue;
+      const reason = apiErrorEnvelopeOf(read.body)?.reason;
+      if (r2.status === 409 && reason === "intent_in_flight")
+        throw inFlight(path3, read, idempotencyKey);
+      if (r2.status === 402) {
+        throw refusedPaidWrite(path3, r2.status, read, idempotencyKey);
+      }
+      throw failedAfterPayment(path3, r2.status, read, idempotencyKey);
+    }
+  });
+}
+
+// src/lib/x402-pay-client.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/lib/x402-http.ts
+import { createHash, randomUUID } from "crypto";
+import { promises as fs } from "fs";
+import path from "path";
+async function loadExternalHeaders(input) {
+  const result = {};
+  if (input.headersFile) {
+    const handle = await fs.open(input.headersFile, "r");
+    let raw;
+    try {
+      const stat = await handle.stat();
+      if (!stat.isFile())
+        throw new Error(`Headers file must be a regular file: ${input.headersFile}`);
+      if ((stat.mode & 63) !== 0) {
+        throw new Error(
+          `Headers file must not be accessible by group or others: ${input.headersFile}`
+        );
+      }
+      raw = await handle.readFile("utf8");
+    } finally {
+      await handle.close();
+    }
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("Headers file must contain a JSON object");
+    }
+    for (const [name, value] of Object.entries(parsed)) {
+      if (typeof value !== "string") throw new Error(`Header '${name}' must have a string value`);
+      result[assertX402HeaderName(name)] = assertX402HeaderValue(value);
+    }
+  }
+  for (const mapping of input.headerEnv ?? []) {
+    const separator = mapping.indexOf("=");
+    if (separator <= 0 || separator === mapping.length - 1) {
+      throw new Error(`--header-env must use HEADER=ENV_VAR: ${mapping}`);
+    }
+    const name = assertX402HeaderName(mapping.slice(0, separator));
+    const environmentVariable = mapping.slice(separator + 1);
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(environmentVariable)) {
+      throw new Error(`Invalid environment variable name: ${environmentVariable}`);
+    }
+    const value = process.env[environmentVariable];
+    if (value === void 0)
+      throw new Error(`Environment variable ${environmentVariable} is not set`);
+    if (result[name] !== void 0)
+      throw new Error(`HTTP header '${name}' was provided more than once`);
+    result[name] = assertX402HeaderValue(value);
+  }
+  return result;
+}
+function requestBodyTooLarge(maxBytes) {
+  return new X402PayError(`Request body exceeds ${maxBytes} bytes`, {
+    code: "request_body_too_large"
+  });
+}
+async function readBoundedBodyFile(bodyFile, maxBytes) {
+  const handle = await fs.open(bodyFile, "r");
+  try {
+    const stat = await handle.stat();
+    if (stat.isFile() && stat.size > maxBytes) throw requestBodyTooLarge(maxBytes);
+    const chunks = [];
+    let total = 0;
+    for (; ; ) {
+      const chunk = Buffer.alloc(Math.min(64 * 1024, maxBytes + 1 - total));
+      const { bytesRead } = await handle.read(chunk, 0, chunk.length, null);
+      if (bytesRead === 0) break;
+      total += bytesRead;
+      if (total > maxBytes) throw requestBodyTooLarge(maxBytes);
+      chunks.push(chunk.subarray(0, bytesRead));
+    }
+    return Buffer.concat(chunks, total).toString("utf8");
+  } finally {
+    await handle.close();
+  }
+}
+async function readX402RequestBody(input) {
+  const method = input.method.toUpperCase();
+  if (method !== "GET" && method !== "POST") throw new Error("x402 method must be GET or POST");
+  if (input.json !== void 0 && input.bodyFile) {
+    throw new Error("Use only one of --json or --body-file");
+  }
+  if (method === "GET" && (input.json !== void 0 || input.bodyFile)) {
+    throw new Error("GET x402 requests cannot include a body");
+  }
+  if (method === "POST" && input.json === void 0 && !input.bodyFile) {
+    throw new Error("POST x402 requests require --json or --body-file");
+  }
+  if (method !== "POST") return void 0;
+  const maxBytes = input.maxBytes ?? Number.MAX_SAFE_INTEGER;
+  let raw;
+  if (input.bodyFile) {
+    raw = await readBoundedBodyFile(input.bodyFile, maxBytes);
+  } else {
+    raw = input.json;
+    if (Buffer.byteLength(raw, "utf8") > maxBytes) throw requestBodyTooLarge(maxBytes);
+  }
+  try {
+    JSON.parse(raw);
+  } catch {
+    throw new Error("POST body is not valid JSON");
+  }
+  return Buffer.from(raw, "utf8");
+}
+async function writeExclusiveAtomic(outputPath, bytes) {
+  const directory = path.dirname(outputPath);
+  await fs.mkdir(directory, { recursive: true });
+  const temporaryPath = path.join(directory, `.${path.basename(outputPath)}-${randomUUID()}.tmp`);
+  try {
+    await fs.writeFile(temporaryPath, bytes, { flag: "wx", mode: 384 });
+    await fs.link(temporaryPath, outputPath);
+    await fs.unlink(temporaryPath);
+  } catch (error) {
+    if (error.code === "EEXIST") {
+      throw new Error(`Output file already exists: ${outputPath}`);
+    }
+    throw error;
+  } finally {
+    await fs.rm(temporaryPath, { force: true }).catch(() => void 0);
+  }
+}
+async function externalResponseData(response, options = {}) {
+  const bytes = response instanceof Response ? new Uint8Array(await response.arrayBuffer()) : response.body;
+  const contentType = response instanceof Response ? response.headers.get("content-type") ?? "application/octet-stream" : response.contentType;
+  const sha256 = createHash("sha256").update(bytes).digest("hex");
+  if (options.outputPath) {
+    await writeExclusiveAtomic(options.outputPath, bytes);
+    return {
+      status: response.status,
+      contentType,
+      bytes: bytes.length,
+      sha256,
+      outputPath: path.resolve(options.outputPath)
+    };
+  }
+  const inlineLimit = options.inlineLimitBytes ?? 1048576;
+  if (bytes.length > inlineLimit) {
+    throw new Error(
+      `Response is ${bytes.length} bytes; use --output for responses over ${inlineLimit}`
+    );
+  }
+  const mediaType = contentType.split(";", 1)[0].trim().toLowerCase();
+  const text = Buffer.from(bytes).toString("utf8");
+  if (mediaType === "application/json" || mediaType.endsWith("+json")) {
+    let body;
+    try {
+      body = JSON.parse(text);
+    } catch {
+      throw new Error("Response declared JSON but contained invalid JSON");
+    }
+    return { status: response.status, contentType, bytes: bytes.length, sha256, body };
+  }
+  if (mediaType.startsWith("text/")) {
+    return {
+      status: response.status,
+      contentType,
+      bytes: bytes.length,
+      sha256,
+      body: text,
+      bodyEncoding: "utf8"
+    };
+  }
+  return {
+    status: response.status,
+    contentType,
+    bytes: bytes.length,
+    sha256,
+    body: Buffer.from(bytes).toString("base64"),
+    bodyEncoding: "base64"
+  };
+}
+
+// src/lib/x402-pay-client.ts
+var X402_CLI_BODY_LIMIT_BYTES = 64 * 1024 * 1024;
+function cliX402Rails() {
+  return [createEvmPerRequestRail(), createTaskmarketFeeRail()];
+}
+function createCliX402Payer(options = {}) {
+  const policyPath = getX402PolicyPath();
+  return createX402Payer({
+    journalPath: getX402JournalPath(),
+    loadPolicy: (loadOptions) => loadX402Policy(policyPath, loadOptions),
+    getAccount: async () => options.account ?? await createWalletAccountFromKeystore(await loadKeystore()),
+    rails: cliX402Rails(),
+    fetch: options.fetchImpl,
+    limits: {
+      maxRequestBodyBytes: X402_CLI_BODY_LIMIT_BYTES,
+      maxResponseBodyBytes: X402_CLI_BODY_LIMIT_BYTES
+    },
+    ...options.firstParty ? { firstParty: { origin: apiOrigin() } } : {}
+  });
+}
+async function executeX402PayRequest(options) {
+  const method = (options.method ?? "GET").toUpperCase();
+  const body = await readX402RequestBody({
+    method,
+    json: options.json,
+    bodyFile: options.bodyFile,
+    maxBytes: X402_CLI_BODY_LIMIT_BYTES
+  });
+  const payer = createCliX402Payer({ account: options.account, fetchImpl: options.fetchImpl });
+  const result = await payer.request(
+    {
+      apiVersion: 1,
+      invocationId: options.invocationId ?? randomUUID2(),
+      url: options.rawUrl,
+      method,
+      headers: options.headers,
+      body,
+      policyRuleId: options.policyRuleId,
+      nonInteractive: Boolean(options.nonInteractive)
+    },
+    {
+      confirmPayment: options.confirmPayment,
+      confirmDirectApproval: options.confirmDirectApproval
+    }
+  );
+  const payment = result.payment ? await getX402Payment(result.payment.paymentId, getX402JournalPath()) : void 0;
+  let responseData;
+  try {
+    responseData = await externalResponseData(result.response, {
+      outputPath: options.outputPath
+    });
+  } catch (error) {
+    if (payment) {
+      throw new X402PayError(
+        error instanceof Error ? error.message : "Failed to process external response",
+        {
+          code: "request_failed",
+          cause: error,
+          invocationId: result.invocationId,
+          payment,
+          pending: false,
+          status: result.response.status
+        }
+      );
+    }
+    throw error;
+  }
+  if (result.response.status < 200 || result.response.status > 299) {
+    throw new X402PayError(`External service returned HTTP ${result.response.status}`, {
+      code: "request_failed",
+      invocationId: result.invocationId,
+      payment,
+      pending: false,
+      status: result.response.status
+    });
+  }
+  return { payment, response: responseData };
+}
+async function reconcileX402PaymentById(paymentId) {
+  const policyPath = getX402PolicyPath();
+  return reconcileX402Payment({
+    journalPath: getX402JournalPath(),
+    paymentId,
+    loadPolicy: () => loadX402Policy(policyPath),
+    rails: cliX402Rails()
+  });
+}
+
+// src/lib/x402-fee.ts
+function bodyOf(response) {
+  return parseFailureBody(Buffer.from(response.body).toString("utf8"));
+}
+function isSuccess(status) {
+  return status >= 200 && status <= 299;
+}
+function successData(response) {
+  return JSON.parse(Buffer.from(response.body).toString("utf8"));
+}
+function prePaymentFailure(error) {
+  const sent = error.payment !== void 0 && error.payment.state !== "failed_before_dispatch";
+  if (error.pending || sent) return error;
+  if (error.code === "challenge_invalid" || error.code === "no_supported_rail") {
+    return new Error("No payment methods accepted by server");
+  }
+  if ((error.code === "request_failed" || error.code === "signer_unavailable") && error.cause !== void 0) {
+    return error.cause;
+  }
+  return error;
+}
+async function x402FeePost(path3, body, options = {}) {
+  if (paymentProtocolOf(selectedNetwork().chainId) === "mpp") {
+    if (options.allocationId !== void 0)
+      throw new Error("x402 allocations cannot pay for writes on a Tempo network");
+    return mppPost(path3, body, {
+      idempotencyKey: options.idempotencyKey,
+      expect: options.expect,
+      account: options.account,
+      fetchImpl: options.fetchImpl
+    });
+  }
+  const keystore = await loadKeystore();
+  const idempotencyKey = resolveIdempotencyKey(options.idempotencyKey);
+  const request = paidWriteRequest(keystore, path3, body, idempotencyKey);
+  return withIdempotentWrite(idempotencyKey, async () => {
+    const payer = createCliX402Payer({
+      firstParty: true,
+      account: options.account,
+      fetchImpl: options.fetchImpl
+    });
+    let result;
+    try {
+      result = await payer.request({
+        apiVersion: 1,
+        // A fresh invocation per run: the backend recognises a repeated write by its idempotency
+        // key, so a re-run must reach it rather than be answered from the local journal.
+        invocationId: options.invocationId ?? randomUUID3(),
+        url: request.url,
+        method: "POST",
+        headers: request.headers,
+        body: new TextEncoder().encode(request.body),
+        nonInteractive: true,
+        ...options.allocationId !== void 0 ? { allocationId: options.allocationId } : {},
+        ...options.feeKind !== void 0 ? { feeKind: options.feeKind } : {},
+        ...options.expect !== void 0 ? { expect: options.expect } : {}
+      });
+    } catch (error) {
+      if (!(error instanceof X402PayError)) throw error;
+      if (error.response !== void 0) {
+        if (isSuccess(error.response.status)) {
+          return { data: successData(error.response), idempotencyKey };
+        }
+        throw failedAfterPayment(
+          path3,
+          error.response.status,
+          bodyOf(error.response),
+          idempotencyKey
+        );
+      }
+      throw prePaymentFailure(error);
+    }
+    const { response } = result;
+    if (isSuccess(response.status)) {
+      return { data: successData(response), idempotencyKey };
+    }
+    if (result.payment !== void 0) {
+      throw failedAfterPayment(path3, response.status, bodyOf(response), idempotencyKey);
+    }
+    throw refusedPaidWrite(path3, response.status, bodyOf(response), idempotencyKey);
+  });
+}
+
+// src/lib/compute-credits.ts
+var COMPUTE_CREDIT_PATH = "/api/compute/credits";
+var COMPUTE_CREDIT_STATUS_PATH = "/api/compute/credits/status";
+var COMPUTE_PRICING_PATH = "/api/compute/pricing";
+var USDC_DECIMALS = 6;
+var CONFIG_VERSION = 1;
+var COMPUTE_PURCHASE_ARRIVAL_WINDOW_MS = 15 * 60 * 1e3;
+var COMPUTE_CREDIT_LOCK_WAIT_MS = 2 * 60 * 1e3;
+var COMPUTE_AUTO_TOP_UP_MAX_CHUNKS_PER_DAY = 10;
+var ComputeCreditError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ComputeCreditError";
+  }
+};
+function getComputeCreditConfigPath() {
+  return path2.join(getTaskmarketHome(), "compute-credits.json");
+}
+function pendingDirectory() {
+  return path2.join(getTaskmarketHome(), "compute-credit-purchases");
+}
+function pendingPath(idempotencyKey) {
+  return path2.join(pendingDirectory(), `${idempotencyKey}.json`);
+}
+async function withComputeCreditLock(fn) {
+  const timeoutMessage = `compute credit lock: waited ${COMPUTE_CREDIT_LOCK_WAIT_MS} ms`;
+  let entered = false;
+  try {
+    return await withX402FileLock(
+      path2.join(getTaskmarketHome(), "compute-credits.lock"),
+      () => {
+        entered = true;
+        return fn();
+      },
+      { waitMs: COMPUTE_CREDIT_LOCK_WAIT_MS, timeoutMessage }
+    );
+  } catch (error) {
+    if (entered || !(error instanceof Error) || error.message !== timeoutMessage) throw error;
+    throw new ComputeCreditError(
+      "busy",
+      "Another compute credit command on this device is still running; try again shortly"
+    );
+  }
+}
+async function writePrivateJson(file, value) {
+  await fs2.mkdir(path2.dirname(file), { recursive: true, mode: 448 });
+  const temporary = `${file}.${process.pid}.${randomUUID4()}.tmp`;
+  await fs2.writeFile(temporary, `${JSON.stringify(value, null, 2)}
+`, { mode: 384 });
+  await fs2.rename(temporary, file);
+}
+async function loadComputeCreditConfig() {
+  let text;
+  try {
+    text = await fs2.readFile(getComputeCreditConfigPath(), "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+  const config = JSON.parse(text);
+  if (config.version !== CONFIG_VERSION || typeof config.allocationId !== "string") {
+    throw new ComputeCreditError(
+      "not_set_up",
+      `${getComputeCreditConfigPath()} is not a compute credit configuration this CLI can read`
+    );
+  }
+  return config;
+}
+async function listPendingComputePurchases() {
+  let names;
+  try {
+    names = await fs2.readdir(pendingDirectory());
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+  const records = [];
+  for (const name of names.filter((entry) => entry.endsWith(".json")).sort()) {
+    let text;
+    try {
+      text = await fs2.readFile(path2.join(pendingDirectory(), name), "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT") continue;
+      throw error;
+    }
+    records.push(JSON.parse(text));
+  }
+  return records.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
+async function forgetPending(idempotencyKey) {
+  await fs2.rm(pendingPath(idempotencyKey), { force: true });
+}
+function usdToAtomic(value) {
+  const match = /^(\d{1,9})(?:\.(\d{1,6}))?$/.exec(value.trim());
+  if (!match) {
+    throw new ComputeCreditError(
+      "invalid_caps",
+      `Not a dollar amount: ${value} (use digits, at most 6 decimals)`
+    );
+  }
+  const atomic = BigInt(match[1]) * 10n ** BigInt(USDC_DECIMALS) + BigInt((match[2] ?? "").padEnd(USDC_DECIMALS, "0"));
+  if (atomic <= 0n) throw new ComputeCreditError("invalid_caps", "A cap must be above zero");
+  return atomic.toString();
+}
+function atomicToUsd(atomic) {
+  const value = BigInt(atomic);
+  const scale = 10n ** BigInt(USDC_DECIMALS);
+  const fraction = (value % scale).toString().padStart(USDC_DECIMALS, "0").replace(/0+$/, "");
+  return fraction ? `${value / scale}.${fraction}` : `${value / scale}`;
+}
+async function fetchComputePricing() {
+  const parsed = ComputeCreditPricingSchema.safeParse(await apiGet(COMPUTE_PRICING_PATH));
+  if (!parsed.success) {
+    throw new ComputeCreditError("invalid_response", "The compute pricing response is malformed");
+  }
+  return parsed.data;
+}
+function railOf(pricing) {
+  const rail = pricing.rails.find((entry) => entry.rail === "x402-exact-usdc");
+  if (!rail || !/^0x[0-9a-fA-F]{40}$/.test(rail.payTo ?? "")) {
+    throw new ComputeCreditError("no_rail", "The API offers no x402 USDC rail for compute credit");
+  }
+  return { network: rail.network, asset: rail.asset, payTo: rail.payTo };
+}
+function usdAtomic(amountUsd) {
+  return (BigInt(amountUsd) * 10n ** BigInt(USDC_DECIMALS)).toString();
+}
+function assertDenomination(pricing, amountUsd) {
+  if (!pricing.denominations.some((entry) => entry.amountUsd === amountUsd)) {
+    throw new ComputeCreditError(
+      "invalid_amount",
+      `$${amountUsd} is not a compute credit size; choose one of ${pricing.denominations.map((entry) => `$${entry.amountUsd}`).join(", ")}`
+    );
+  }
+}
+async function planComputeCreditSetup(input, pricing) {
+  const { network, asset } = railOf(pricing);
+  const perDay = BigInt(usdToAtomic(input.perDayUsd));
+  const perMonth = BigInt(usdToAtomic(input.perMonthUsd));
+  const total = BigInt(usdToAtomic(input.totalUsd ?? atomicToUsd((perMonth * 12n).toString())));
+  if (perDay > perMonth || perMonth > total) {
+    throw new ComputeCreditError(
+      "invalid_caps",
+      "The caps must satisfy per day <= per month <= total"
+    );
+  }
+  let autoTopUp;
+  if (input.autoTopUp) {
+    const { thresholdCredits, amountUsd, maxChunksPerDay } = input.autoTopUp;
+    assertDenomination(pricing, amountUsd);
+    if (!/^\d+(\.\d+)?$/.test(thresholdCredits) || Number(thresholdCredits) <= 0) {
+      throw new ComputeCreditError(
+        "invalid_caps",
+        "The top-up threshold must be credits above zero"
+      );
+    }
+    if (!Number.isInteger(maxChunksPerDay) || maxChunksPerDay < 1 || maxChunksPerDay > COMPUTE_AUTO_TOP_UP_MAX_CHUNKS_PER_DAY) {
+      throw new ComputeCreditError(
+        "invalid_caps",
+        `The daily chunk cap must be a whole number from 1 to ${COMPUTE_AUTO_TOP_UP_MAX_CHUNKS_PER_DAY}`
+      );
+    }
+    const autoPerDay = BigInt(amountUsd) * BigInt(maxChunksPerDay) * 10n ** BigInt(USDC_DECIMALS);
+    if (autoPerDay > perDay) {
+      throw new ComputeCreditError(
+        "invalid_caps",
+        "Auto-top-up chunks a day times the chunk size must fit within the daily cap"
+      );
+    }
+    autoTopUp = { ...input.autoTopUp, perDayUsd: atomicToUsd(autoPerDay.toString()) };
+  }
+  const existing = await loadComputeCreditConfig();
+  return {
+    network,
+    asset,
+    caps: {
+      perDayUsd: atomicToUsd(perDay.toString()),
+      perMonthUsd: atomicToUsd(perMonth.toString()),
+      totalUsd: atomicToUsd(total.toString())
+    },
+    ...autoTopUp ? { autoTopUp } : {},
+    ...existing ? { replaces: existing.allocationId } : {}
+  };
+}
+function allocations() {
+  return createX402Allocations({ journalPath: getX402JournalPath() });
+}
+async function applyComputeCreditSetup(plan, approvalNote, now = /* @__PURE__ */ new Date()) {
+  if (!approvalNote.trim()) {
+    throw new ComputeCreditError("not_approved", "Opening a compute allocation needs approval");
+  }
+  return withComputeCreditLock(() => applySetupLocked(plan, approvalNote, now));
+}
+async function applySetupLocked(plan, approvalNote, now) {
+  const replaces = (await loadComputeCreditConfig())?.allocationId;
+  const store = allocations();
+  const allocationId = `compute-credits-${randomUUID4()}`;
+  await store.open(
+    {
+      id: allocationId,
+      kind: "compute",
+      exposure: "compute",
+      network: plan.network,
+      asset: plan.asset,
+      caps: {
+        amount: usdToAtomic(plan.caps.totalUsd),
+        perDay: usdToAtomic(plan.caps.perDayUsd),
+        perMonth: usdToAtomic(plan.caps.perMonthUsd)
+      }
+    },
+    { note: approvalNote }
+  );
+  let autoTopUp;
+  if (plan.autoTopUp) {
+    const childId = `${allocationId}-auto`;
+    await store.open({
+      id: childId,
+      kind: "compute",
+      exposure: "compute",
+      parentId: allocationId,
+      network: plan.network,
+      asset: plan.asset,
+      caps: {
+        amount: usdToAtomic(plan.caps.totalUsd),
+        perDay: usdToAtomic(plan.autoTopUp.perDayUsd)
+      }
+    });
+    autoTopUp = {
+      allocationId: childId,
+      thresholdCredits: plan.autoTopUp.thresholdCredits,
+      amountUsd: plan.autoTopUp.amountUsd,
+      maxChunksPerDay: plan.autoTopUp.maxChunksPerDay
+    };
+  }
+  const config = {
+    version: CONFIG_VERSION,
+    allocationId,
+    network: plan.network,
+    asset: plan.asset,
+    approvedAt: now.toISOString(),
+    ...autoTopUp ? { autoTopUp } : {}
+  };
+  await writePrivateJson(getComputeCreditConfigPath(), config);
+  if (replaces && replaces !== allocationId) {
+    await store.close(replaces).catch((error) => {
+      if (error instanceof X402PayError && error.code === "allocation_not_found") return;
+      throw error;
+    });
+  }
+  return config;
+}
+async function disableComputeAutoTopUp() {
+  return withComputeCreditLock(async () => {
+    const config = await requireConfig();
+    if (config.autoTopUp) await allocations().close(config.autoTopUp.allocationId);
+    const rest = { ...config };
+    delete rest.autoTopUp;
+    await writePrivateJson(getComputeCreditConfigPath(), rest);
+    return rest;
+  });
+}
+async function requireConfig() {
+  const config = await loadComputeCreditConfig();
+  if (!config) {
+    throw new ComputeCreditError(
+      "not_set_up",
+      "No compute allocation yet. Run `taskmarket agent credits setup` to approve daily and monthly caps"
+    );
+  }
+  return config;
+}
+async function invocationStatus(invocationId, seams) {
+  const payer = createCliX402Payer({ firstParty: true, ...seams });
+  try {
+    return await payer.status(invocationId);
+  } catch (error) {
+    if (error instanceof X402PayError && error.code === "invocation_not_found") return void 0;
+    throw error;
+  }
+}
+function provenUncharged(status) {
+  if (!status) return true;
+  if (status.state === "in_progress") return false;
+  return status.charge === "none" || status.charge === "released";
+}
+async function buyComputeCredit(input, seams = {}) {
+  return withComputeCreditLock(async () => {
+    const resolved = await resolvePendingLocked(seams);
+    if (!input.auto) {
+      const granted = resolved.find((outcome) => outcome.outcome === "granted");
+      if (granted?.outcome === "granted") {
+        throw new ComputeCreditError(
+          "earlier_purchase_granted",
+          `An earlier $${granted.purchase.amountUsd} purchase whose response was lost has been granted (${granted.purchase.credits} credits). Nothing new was bought; run buy again to buy more`
+        );
+      }
+      const pending = await listPendingComputePurchases();
+      if (pending.length > 0) {
+        const reasons = new Map(
+          resolved.flatMap(
+            (outcome) => outcome.outcome === "pending" ? [[outcome.idempotencyKey, outcome.reason]] : []
+          )
+        );
+        const described = pending.map(
+          (record) => `$${record.amountUsd} purchase ${record.idempotencyKey} from ${record.createdAt} (${reasons.get(record.idempotencyKey) ?? "unresolved"})`
+        ).join("; ");
+        throw new ComputeCreditError(
+          "purchase_pending",
+          `Nothing new was bought: an earlier purchase may have been paid and is not settled yet: ${described}. Run \`taskmarket agent credits reconcile\` to settle it by its idempotency key, which never pays again. If it stays unresolved, \`taskmarket agent credits reconcile --release <key>\` stops waiting for it on this device; it is never resent, and the backend still grants it if it was paid`
+        );
+      }
+    }
+    return { ...await purchaseLocked(input, seams), resolved };
+  });
+}
+async function purchaseLocked(input, seams) {
+  const config = await requireConfig();
+  const allocationId = input.auto ? config.autoTopUp?.allocationId : config.allocationId;
+  if (!allocationId) {
+    throw new ComputeCreditError("not_set_up", "Auto-top-up was not approved at setup");
+  }
+  const pricing = await fetchComputePricing();
+  assertDenomination(pricing, input.amountUsd);
+  const { payTo } = railOf(pricing);
+  const keystore = await loadKeystore();
+  const pending = {
+    idempotencyKey: randomUUID4(),
+    invocationId: randomUUID4(),
+    amountUsd: input.amountUsd,
+    auto: Boolean(input.auto),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writePrivateJson(pendingPath(pending.idempotencyKey), pending);
+  try {
+    const outcome = await x402FeePost(
+      COMPUTE_CREDIT_PATH,
+      { deviceId: keystore.deviceId, apiToken: keystore.apiToken, amountUsd: input.amountUsd },
+      {
+        idempotencyKey: pending.idempotencyKey,
+        invocationId: pending.invocationId,
+        allocationId,
+        expect: { amount: usdAtomic(input.amountUsd), payTo },
+        ...seams
+      }
+    );
+    const parsed = ComputeCreditBuyOutputSchema.safeParse(outcome.data);
+    if (!parsed.success) {
+      throw new ComputeCreditError("invalid_response", "The purchase response is malformed");
+    }
+    await forgetPending(pending.idempotencyKey);
+    return parsed.data;
+  } catch (error) {
+    let uncharged = false;
+    try {
+      uncharged = provenUncharged(await invocationStatus(pending.invocationId, seams));
+    } catch {
+    }
+    if (uncharged) await forgetPending(pending.idempotencyKey);
+    throw error;
+  }
+}
+function apiErrorCode(error) {
+  return /\b(purchase_void|purchase_pending|in_flight|key_conflict|disabled)\b/.exec(
+    error.message
+  )?.[1];
+}
+async function resolvePendingComputePurchases(seams = {}) {
+  return withComputeCreditLock(() => resolvePendingLocked(seams));
+}
+async function resolvePendingLocked(seams) {
+  const records = await listPendingComputePurchases();
+  if (records.length === 0) return [];
+  const keystore = await loadKeystore();
+  const payer = createCliX402Payer({ firstParty: true, ...seams });
+  const outcomes = [];
+  for (const record of records) {
+    const key = record.idempotencyKey;
+    let status = await invocationStatus(record.invocationId, seams);
+    if (status?.state === "in_progress") {
+      outcomes.push({ idempotencyKey: key, outcome: "pending", reason: "in_progress" });
+      continue;
+    }
+    if (status?.uncertain || status?.charge === "reserved") {
+      status = await payer.reconcile(record.invocationId).catch(() => status);
+    }
+    if (provenUncharged(status)) {
+      await forgetPending(key);
+      outcomes.push({ idempotencyKey: key, outcome: "not_charged" });
+      continue;
+    }
+    try {
+      const replay = await apiPost(
+        COMPUTE_CREDIT_PATH,
+        { deviceId: keystore.deviceId, apiToken: keystore.apiToken, amountUsd: record.amountUsd },
+        { idempotencyKey: key }
+      );
+      const parsed = ComputeCreditBuyOutputSchema.safeParse(replay.data);
+      if (!parsed.success) {
+        outcomes.push({ idempotencyKey: key, outcome: "pending", reason: "invalid_response" });
+        continue;
+      }
+      await forgetPending(key);
+      outcomes.push({ idempotencyKey: key, outcome: "granted", purchase: parsed.data.purchase });
+    } catch (error) {
+      if (!(error instanceof ApiError)) throw error;
+      const code = apiErrorCode(error);
+      if (code === "purchase_void") {
+        await forgetPending(key);
+        outcomes.push({ idempotencyKey: key, outcome: "void" });
+      } else if (error.status === 402 && Date.now() - Date.parse(record.createdAt) > COMPUTE_PURCHASE_ARRIVAL_WINDOW_MS) {
+        await forgetPending(key);
+        outcomes.push({ idempotencyKey: key, outcome: "not_charged" });
+      } else {
+        outcomes.push({
+          idempotencyKey: key,
+          outcome: "pending",
+          reason: code ?? (error.status === 402 ? "awaiting_backend" : `http_${error.status}`)
+        });
+      }
+    }
+  }
+  return outcomes;
+}
+async function releasePendingComputePurchase(idempotencyKey, seams = {}) {
+  return withComputeCreditLock(async () => {
+    const record = (await listPendingComputePurchases()).find(
+      (entry) => entry.idempotencyKey === idempotencyKey
+    );
+    if (!record) {
+      throw new ComputeCreditError("not_pending", `No pending purchase ${idempotencyKey}`);
+    }
+    const status = await invocationStatus(record.invocationId, seams);
+    if (status?.state === "in_progress") {
+      throw new ComputeCreditError("busy", "That purchase is still being sent; try again shortly");
+    }
+    await forgetPending(idempotencyKey);
+    return record;
+  });
+}
+async function readComputeCreditBalance() {
+  return (await readStatus()).balance.availableCredits;
+}
+async function readStatus() {
+  const keystore = await loadKeystore();
+  const outcome = await apiPost(COMPUTE_CREDIT_STATUS_PATH, {
+    deviceId: keystore.deviceId,
+    apiToken: keystore.apiToken
+  });
+  const parsed = ComputeCreditStatusOutputSchema.safeParse(outcome.data);
+  if (!parsed.success) {
+    throw new ComputeCreditError("invalid_response", "The compute credit status is malformed");
+  }
+  return parsed.data;
+}
+async function readComputeCreditStatus() {
+  return readStatus();
+}
+async function allocationSummary(id) {
+  if (!id) return void 0;
+  const status = await allocations().get(id);
+  return {
+    allocationId: id,
+    closed: status.allocation.closedAt !== void 0,
+    caps: {
+      perDayUsd: status.allocation.caps.perDay && atomicToUsd(status.allocation.caps.perDay),
+      perMonthUsd: status.allocation.caps.perMonth && atomicToUsd(status.allocation.caps.perMonth),
+      totalUsd: atomicToUsd(status.allocation.caps.amount)
+    },
+    usedUsd: {
+      today: atomicToUsd(status.usage.day),
+      thisMonth: atomicToUsd(status.usage.month),
+      total: atomicToUsd(status.usage.used)
+    }
+  };
+}
+async function computeCreditStatus(seams = {}) {
+  const { resolved } = await withComputeCreditLock(async () => ({
+    resolved: await resolvePendingLocked(seams)
+  }));
+  const [status, pricing, config] = await Promise.all([
+    readStatus(),
+    fetchComputePricing(),
+    loadComputeCreditConfig()
+  ]);
+  const topUp = await onComputeBalanceObserved(
+    { availableCredits: status.balance.availableCredits },
+    seams
+  ).catch(async (error) => ({ topUp: await failedTopUp(error, "check_failed") }));
+  const pending = await listPendingComputePurchases();
+  const after = topUp.topUp.action === "bought" ? await readStatus() : status;
+  return {
+    balance: after.balance,
+    topUp: topUp.topUp,
+    rate: {
+      rateCardVersion: pricing.rateCardVersion,
+      usdPerCredit: pricing.usdPerCredit,
+      salesApproval: pricing.salesApproval,
+      machineTypes: pricing.machineTypes
+    },
+    debits: after.debits,
+    purchases: after.purchases,
+    allocation: await allocationSummary(config?.allocationId),
+    autoTopUp: config?.autoTopUp ? {
+      thresholdCredits: config.autoTopUp.thresholdCredits,
+      amountUsd: config.autoTopUp.amountUsd,
+      maxChunksPerDay: config.autoTopUp.maxChunksPerDay,
+      allocation: await allocationSummary(config.autoTopUp.allocationId)
+    } : null,
+    resolved,
+    pending
+  };
+}
+function failureCode(error) {
+  if (error instanceof X402PayError || error instanceof ComputeCreditError) return error.code;
+  if (error instanceof ApiError) return apiErrorCode(error) ?? `http_${error.status}`;
+  if (error instanceof TypeError) return "network";
+  return "unknown";
+}
+async function failedTopUp(error, reason) {
+  const pending = reason === "payment_failed" && (await listPendingComputePurchases()).length > 0;
+  return {
+    action: "skipped",
+    reason: pending ? "outcome_unknown" : reason,
+    code: failureCode(error),
+    message: error instanceof Error ? error.message : String(error)
+  };
+}
+function decimalLess(a, b) {
+  const scale = (value) => {
+    const [whole, fraction = ""] = value.split(".");
+    return BigInt(whole + fraction.padEnd(18, "0").slice(0, 18));
+  };
+  return scale(a) < scale(b);
+}
+async function checkComputeBalance(seams = {}) {
+  return withComputeCreditLock(() => checkBalanceLocked(seams));
+}
+async function checkBalanceLocked(seams) {
+  const resolved = await resolvePendingLocked(seams);
+  const [status, config] = await Promise.all([readStatus(), loadComputeCreditConfig()]);
+  let topUp;
+  let balance = status.balance;
+  const auto = config?.autoTopUp;
+  if (!auto) {
+    topUp = { action: "none", reason: "disabled" };
+  } else if (!decimalLess(balance.availableCredits, auto.thresholdCredits)) {
+    topUp = { action: "none", reason: "above_threshold" };
+  } else if ((await listPendingComputePurchases()).length > 0) {
+    topUp = { action: "none", reason: "purchase_pending" };
+  } else {
+    try {
+      const bought = await purchaseLocked({ amountUsd: auto.amountUsd, auto: true }, seams);
+      balance = bought.balance;
+      topUp = { action: "bought", purchase: bought.purchase };
+    } catch (error) {
+      if (error instanceof X402PayError && error.code === "allocation_exhausted") {
+        topUp = {
+          action: "skipped",
+          reason: error.allocation?.cap === "perDay" ? "daily_cap" : "allocation_cap"
+        };
+      } else if (error instanceof X402PayError && error.code === "allocation_closed") {
+        topUp = { action: "skipped", reason: "allocation_closed" };
+      } else {
+        topUp = await failedTopUp(error, "payment_failed");
+      }
+    }
+  }
+  return { balance, topUp, resolved };
+}
+async function onComputeBalanceObserved(observation, seams = {}) {
+  const auto = (await loadComputeCreditConfig())?.autoTopUp;
+  if (!auto) return { topUp: { action: "none", reason: "disabled" } };
+  const short = observation.creditWarning === "low_credit" || observation.creditWarning === "credit_exhausted";
+  if (!short && (observation.availableCredits === void 0 || !decimalLess(observation.availableCredits, auto.thresholdCredits))) {
+    return { topUp: { action: "none", reason: "above_threshold" } };
+  }
+  const checked = await checkComputeBalance(seams);
+  return { topUp: checked.topUp, balance: checked.balance };
+}
+
+export {
+  paidWriteRequest,
+  refusedPaidWrite,
+  failedAfterPayment,
+  mppPost,
+  loadExternalHeaders,
+  executeX402PayRequest,
+  reconcileX402PaymentById,
+  x402FeePost,
+  ComputeCreditError,
+  loadComputeCreditConfig,
+  listPendingComputePurchases,
+  usdToAtomic,
+  atomicToUsd,
+  fetchComputePricing,
+  assertDenomination,
+  planComputeCreditSetup,
+  applyComputeCreditSetup,
+  disableComputeAutoTopUp,
+  buyComputeCredit,
+  resolvePendingComputePurchases,
+  releasePendingComputePurchase,
+  readComputeCreditBalance,
+  readComputeCreditStatus,
+  computeCreditStatus,
+  checkComputeBalance,
+  onComputeBalanceObserved
+};