@dvmkit/sdk 0.0.0 → 0.1.0-rc.1

package/dist/chunk-7IH5SG2A.js

@@ -0,0 +1,1038 @@
+import {
+  initCallerLoggers,
+  redactUrl
+} from "./chunk-KXWROQGK.js";
+
+// src/sdk/server/job-store.ts
+function accumulateAskedTopUp(prior, ask) {
+  const poisoned = (reason) => ({
+    micro: UNCAPPABLE_ASK_TOTAL,
+    currency: prior.currency,
+    reason: prior.reason ?? reason
+  });
+  if (prior.micro === UNCAPPABLE_ASK_TOTAL) {
+    return { micro: prior.micro, currency: prior.currency, reason: prior.reason };
+  }
+  if (ask.micro === void 0) return poisoned("ask_unpriceable");
+  if (prior.micro === void 0) {
+    return { micro: ask.micro, currency: ask.currency, reason: prior.reason };
+  }
+  if (prior.currency !== ask.currency) return poisoned("ask_currency_switch");
+  return { micro: prior.micro + ask.micro, currency: prior.currency, reason: prior.reason };
+}
+var UNCAPPABLE_ASK_TOTAL = -1;
+function isReceiptIssuingStore(store) {
+  return "claimReceiptSeq" in store && "saveReceipt" in store;
+}
+function isStreamableJobStore(store) {
+  return "appendOutgoing" in store && "recordInbound" in store && "verifyAndCredit" in store && "getVerifiedInbound" in store && "subscribeMessages" in store && "subscribeNotifications" in store && "getCounters" in store && "getMessages" in store && "cancelJob" in store && "initStreaming" in store;
+}
+
+// src/sdk/step-cache.ts
+var StepCache = class _StepCache {
+  cache = /* @__PURE__ */ new Map();
+  /** Check if a step result is cached. */
+  has(id) {
+    return this.cache.has(id);
+  }
+  /** Get a cached step result. Throws if not present. */
+  get(id) {
+    if (!this.cache.has(id)) {
+      throw new Error(`StepCache: no cached result for step "${id}"`);
+    }
+    return this.cache.get(id);
+  }
+  /** Cache a step result. */
+  set(id, value) {
+    this.cache.set(id, value);
+  }
+  /** Export all cached steps for persistence. */
+  serialize() {
+    return [...this.cache.entries()].map(([id, value]) => ({ id, value }));
+  }
+  /** Restore a StepCache from persisted records. */
+  static deserialize(records) {
+    const cache = new _StepCache();
+    for (const { id, value } of records) {
+      cache.set(id, value);
+    }
+    return cache;
+  }
+};
+
+// src/sdk/server/job.ts
+function toJobRecord(job) {
+  return {
+    id: job.id,
+    tags: job.tags,
+    capability: job.capability,
+    input: job.input,
+    params: job.params,
+    requesterId: job.requesterId,
+    requesterTokenHash: job.requesterTokenHash,
+    requesterToken: job.requesterToken,
+    requestFingerprint: job.requestFingerprint,
+    requesterPubkey: job.requesterPubkey,
+    requestId: job.requestId,
+    authRequestPath: job.authRequestPath,
+    status: job.status,
+    summary: job.summary,
+    messages: job.messages,
+    seq: job.seq,
+    paidMsats: job.paidMsats,
+    paymentMint: job.paymentMint,
+    paymentRail: job.paymentRail,
+    paymentTxHash: job.paymentTxHash,
+    paymentTransactionHash: job.paymentTransactionHash,
+    nativeAmount: job.nativeAmount,
+    nativeAsset: job.nativeAsset,
+    cashuFlow: job.cashuFlow,
+    creditId: job.creditId,
+    drawId: job.drawId,
+    fundingReceipt: job.fundingReceipt,
+    fundingCredit: job.fundingCredit,
+    receivedProofs: job.receivedProofs,
+    pendingPaymentMsats: job.pendingPaymentMsats,
+    pendingMppChallengeIds: job.pendingMppChallengeIds,
+    pendingX402Nonce: job.pendingX402Nonce,
+    pendingX402AmountUsdcMicro: job.pendingX402AmountUsdcMicro,
+    pendingPaymentFiatMicro: job.pendingPaymentFiatMicro,
+    pendingPaymentFiatCurrency: job.pendingPaymentFiatCurrency,
+    askedTopUpMicro: job.askedTopUpMicro,
+    askedTopUpCurrency: job.askedTopUpCurrency,
+    topUpCapUnenforcedReason: job.topUpCapUnenforcedReason,
+    requiredMsats: job.requiredMsats,
+    receipt: job.receipt,
+    stepCache: job.stepCache.serialize(),
+    state: job.state,
+    createdAt: job.createdAt,
+    lastActivityAt: job.lastActivityAt
+  };
+}
+function fromJobRecord(record) {
+  return {
+    id: record.id,
+    tags: record.tags,
+    capability: record.capability,
+    input: record.input,
+    params: record.params,
+    requesterId: record.requesterId,
+    requesterTokenHash: record.requesterTokenHash,
+    status: record.status,
+    summary: record.summary,
+    messages: [...record.messages],
+    seq: record.seq,
+    paidMsats: record.paidMsats,
+    paymentMint: record.paymentMint,
+    paymentRail: record.paymentRail,
+    paymentTxHash: record.paymentTxHash,
+    paymentTransactionHash: record.paymentTransactionHash,
+    nativeAmount: record.nativeAmount,
+    nativeAsset: record.nativeAsset,
+    cashuFlow: record.cashuFlow,
+    creditId: record.creditId,
+    drawId: record.drawId,
+    fundingReceipt: record.fundingReceipt,
+    fundingCredit: record.fundingCredit,
+    receivedProofs: [...record.receivedProofs],
+    pendingPaymentMsats: record.pendingPaymentMsats,
+    pendingMppChallengeIds: record.pendingMppChallengeIds ? [...record.pendingMppChallengeIds] : void 0,
+    requesterToken: record.requesterToken,
+    requestFingerprint: record.requestFingerprint,
+    requesterPubkey: record.requesterPubkey,
+    requestId: record.requestId,
+    authRequestPath: record.authRequestPath,
+    pendingX402Nonce: record.pendingX402Nonce,
+    pendingX402AmountUsdcMicro: record.pendingX402AmountUsdcMicro,
+    pendingPaymentFiatMicro: record.pendingPaymentFiatMicro,
+    pendingPaymentFiatCurrency: record.pendingPaymentFiatCurrency,
+    askedTopUpMicro: record.askedTopUpMicro,
+    askedTopUpCurrency: record.askedTopUpCurrency,
+    topUpCapUnenforcedReason: record.topUpCapUnenforcedReason,
+    requiredMsats: record.requiredMsats,
+    receipt: record.receipt,
+    listeners: /* @__PURE__ */ new Set(),
+    abort: new AbortController(),
+    messageAppender: void 0,
+    messageAppenderTail: void 0,
+    stepCache: StepCache.deserialize(record.stepCache),
+    state: record.state,
+    pendingPrompts: /* @__PURE__ */ new Map(),
+    pendingPayment: null,
+    replayHighSeq: null,
+    replayProviderSkip: 0,
+    replayPaymentIndex: 0,
+    createdAt: record.createdAt,
+    lastActivityAt: record.lastActivityAt
+  };
+}
+function abortJob(job, reason) {
+  job.abort.abort(new JobCancelledError(reason));
+}
+var JobCancelledError = class extends Error {
+  constructor(message = "Job cancelled") {
+    super(message);
+    this.name = "JobCancelledError";
+  }
+};
+function providerMessage(job, type, content) {
+  if (job.replayProviderSkip > 0) {
+    job.replayProviderSkip--;
+    return;
+  }
+  const msg = localMessage(job, "provider", type, content);
+  if (type === "payment-request") {
+    const paymentRequest = content;
+    const pendingPaymentDelta = typeof paymentRequest.amount_msats === "number" ? paymentRequest.amount_msats : void 0;
+    const pendingMppChallengeIds = paymentRequest.tempo?.challenges?.map((challenge) => challenge.id).filter((id) => typeof id === "string");
+    job.messageAppender?.(msg, {
+      pendingPaymentDelta,
+      pendingMppChallengeIds,
+      pendingX402Nonce: typeof paymentRequest.x402?.nonce === "string" ? paymentRequest.x402.nonce : void 0,
+      pendingX402AmountUsdcMicro: typeof paymentRequest.x402?.required_usdc_micro === "string" ? paymentRequest.x402.required_usdc_micro : void 0,
+      // internal-review: read off the job rather than the content — the fiat envelope
+      // is ledger state, not part of the wire shape, and `requestPayment` has
+      // already pinned it on the job by the time this fires (same ordering the
+      // `pendingPaymentMsats` comment above describes).
+      pendingPaymentFiatMicro: job.pendingPaymentFiatMicro,
+      pendingPaymentFiatCurrency: job.pendingPaymentFiatCurrency
+    });
+    return;
+  }
+  job.messageAppender?.(msg);
+}
+function localMessage(job, from, type, content) {
+  job.seq++;
+  const msg = {
+    seq: job.seq,
+    from,
+    timestamp: Math.floor(Date.now() / 1e3),
+    type,
+    content
+  };
+  job.messages.push(msg);
+  for (const listener of job.listeners) {
+    listener(msg);
+  }
+  return msg;
+}
+function isTerminal(status) {
+  return status === "completed" || status === "failed" || status === "cancelled";
+}
+function isYieldMessage(msg) {
+  return msg.type === "prompt" || msg.type === "payment-request" || msg.type === "working" || msg.type === "complete" || msg.type === "cancel";
+}
+
+// src/sdk/server/memory-job-store.ts
+var MemoryJobStore = class {
+  data = /* @__PURE__ */ new Map();
+  messages = /* @__PURE__ */ new Map();
+  nextSeq = /* @__PURE__ */ new Map();
+  messageSubscribers = /* @__PURE__ */ new Map();
+  notifySubscribers = /* @__PURE__ */ new Map();
+  reactivationLocks = /* @__PURE__ */ new Set();
+  requestIdClaims = /* @__PURE__ */ new Map();
+  /** Per-DVM monotonic receipt counter (internal-review) — the `receipt_counter` row. */
+  receiptCounter = 0;
+  /** Receipt sequence already allocated to a job, keyed by job id. */
+  receiptSeqs = /* @__PURE__ */ new Map();
+  get(id) {
+    const record = this.data.get(id);
+    return Promise.resolve(record ? structuredClone(record) : void 0);
+  }
+  findJobByPaymentTxHash(txHash) {
+    for (const record of this.data.values()) {
+      if (record.paymentTxHash === txHash) return Promise.resolve(structuredClone(record));
+    }
+    return Promise.resolve(void 0);
+  }
+  findJobByRequestId(requestId, requesterPubkey) {
+    for (const record of this.data.values()) {
+      if (record.requestId === requestId && record.requesterPubkey === requesterPubkey) {
+        return Promise.resolve(structuredClone(record));
+      }
+    }
+    return Promise.resolve(void 0);
+  }
+  claimRequestId(claim) {
+    const key = requestIdClaimKey(claim.requesterPubkey, claim.requestId);
+    const existing = this.requestIdClaims.get(key);
+    if (!existing) {
+      this.requestIdClaims.set(key, { ...claim, holderToken: claim.claimToken });
+      return Promise.resolve({ jobId: claim.jobId, replayed: false });
+    }
+    if (existing.holderToken !== void 0 || existing.requestFingerprint !== claim.requestFingerprint || existing.requesterId !== claim.requesterId) {
+      return Promise.resolve(void 0);
+    }
+    this.requestIdClaims.set(key, { ...existing, holderToken: claim.claimToken });
+    return Promise.resolve({ jobId: existing.jobId, replayed: true });
+  }
+  resumeRequestId(claim) {
+    const key = requestIdClaimKey(claim.requesterPubkey, claim.requestId);
+    const existing = this.requestIdClaims.get(key);
+    if (!existing || existing.holderToken !== void 0 || existing.requestFingerprint !== claim.requestFingerprint || existing.requesterId !== claim.requesterId) {
+      return Promise.resolve(void 0);
+    }
+    this.requestIdClaims.set(key, { ...existing, holderToken: claim.claimToken });
+    return Promise.resolve({ jobId: existing.jobId, replayed: true });
+  }
+  releaseRequestIdClaim(claim) {
+    const key = requestIdClaimKey(claim.requesterPubkey, claim.requestId);
+    const existing = this.requestIdClaims.get(key);
+    if (existing?.holderToken === claim.claimToken) {
+      this.requestIdClaims.set(key, { ...existing, holderToken: void 0 });
+    }
+    return Promise.resolve();
+  }
+  save(record) {
+    const existing = this.data.get(record.id);
+    if (!existing && record.requestId && record.requesterPubkey) {
+      for (const prior of this.data.values()) {
+        if (prior.requestId === record.requestId && prior.requesterPubkey === record.requesterPubkey) {
+          return Promise.reject(new Error("duplicate caller request id"));
+        }
+      }
+    }
+    if (existing && isTerminal(existing.status) && existing.status !== record.status) {
+      return Promise.resolve();
+    }
+    const snapshot = structuredClone(record);
+    if (existing?.receipt) snapshot.receipt = existing.receipt;
+    this.data.set(record.id, snapshot);
+    const cur = this.nextSeq.get(record.id) ?? 1;
+    this.nextSeq.set(record.id, Math.max(cur, record.seq + 1));
+    if (isTerminal(record.status)) {
+      this.messages.delete(record.id);
+    }
+    return Promise.resolve();
+  }
+  delete(id) {
+    this.data.delete(id);
+    this.messages.delete(id);
+    this.nextSeq.delete(id);
+    this.receiptSeqs.delete(id);
+    return Promise.resolve();
+  }
+  claimReceiptSeq(jobId) {
+    if (!this.data.has(jobId)) {
+      return Promise.reject(new Error(`claimReceiptSeq: job ${jobId} not found`));
+    }
+    const existing = this.receiptSeqs.get(jobId);
+    if (existing !== void 0) return Promise.resolve(existing);
+    this.receiptCounter += 1;
+    this.receiptSeqs.set(jobId, this.receiptCounter);
+    return Promise.resolve(this.receiptCounter);
+  }
+  saveReceipt(jobId, receipt) {
+    const record = this.data.get(jobId);
+    if (!record) return Promise.resolve(void 0);
+    record.receipt ??= structuredClone(receipt);
+    return Promise.resolve(structuredClone(record.receipt));
+  }
+  appendOutgoing(jobId, message, opts) {
+    const record = this.data.get(jobId);
+    if (!record) return Promise.reject(new Error(`appendOutgoing: job ${jobId} not found`));
+    const seq = this.allocateSeq(jobId);
+    const fullMessage = { ...message, seq };
+    this.messagesFor(jobId).push({ message: fullMessage, status: "verified" });
+    if (opts?.pendingPaymentDelta !== void 0) {
+      if (opts.pendingPaymentDelta !== 0) {
+        record.pendingPaymentMsats = (record.pendingPaymentMsats ?? 0) + opts.pendingPaymentDelta;
+      }
+      record.pendingMppChallengeIds = opts.pendingMppChallengeIds;
+      record.pendingX402Nonce = opts.pendingX402Nonce;
+      record.pendingX402AmountUsdcMicro = opts.pendingX402AmountUsdcMicro;
+      if (opts.pendingPaymentFiatMicro === void 0) {
+        record.pendingPaymentFiatMicro = void 0;
+        record.pendingPaymentFiatCurrency = void 0;
+      } else {
+        record.pendingPaymentFiatMicro = record.pendingPaymentFiatCurrency === opts.pendingPaymentFiatCurrency ? (record.pendingPaymentFiatMicro ?? 0) + opts.pendingPaymentFiatMicro : opts.pendingPaymentFiatMicro;
+        record.pendingPaymentFiatCurrency = opts.pendingPaymentFiatCurrency;
+      }
+      const asked = accumulateAskedTopUp(
+        {
+          micro: record.askedTopUpMicro,
+          currency: record.askedTopUpCurrency,
+          reason: record.topUpCapUnenforcedReason
+        },
+        { micro: opts.pendingPaymentFiatMicro, currency: opts.pendingPaymentFiatCurrency }
+      );
+      record.askedTopUpMicro = asked.micro;
+      record.askedTopUpCurrency = asked.currency;
+      record.topUpCapUnenforcedReason = asked.reason;
+    }
+    record.lastActivityAt = Date.now();
+    if (seq > record.seq) record.seq = seq;
+    this.notify(jobId, fullMessage);
+    return Promise.resolve(seq);
+  }
+  recordInbound(jobId, message) {
+    const record = this.data.get(jobId);
+    if (!record) return Promise.reject(new Error(`recordInbound: job ${jobId} not found`));
+    const seq = this.allocateSeq(jobId);
+    const fullMessage = { ...message, seq };
+    this.messagesFor(jobId).push({ message: fullMessage, status: "pending-verification" });
+    record.lastActivityAt = Date.now();
+    if (seq > record.seq) record.seq = seq;
+    this.fireNotifyOnly(jobId);
+    return Promise.resolve(seq);
+  }
+  verifyAndCredit(jobId, seq, credit) {
+    const record = this.data.get(jobId);
+    if (!record) return Promise.reject(new Error(`verifyAndCredit: job ${jobId} not found`));
+    const stored = this.messagesFor(jobId).find((m) => m.message.seq === seq);
+    if (!stored)
+      return Promise.reject(new Error(`verifyAndCredit: message ${jobId}/${seq} not found`));
+    if (stored.status !== "pending-verification") {
+      return Promise.resolve({
+        counters: snapshotCounters(record),
+        alreadyVerified: true,
+        ...creditBinding(record)
+      });
+    }
+    stored.status = "verified";
+    if (credit) {
+      record.paidMsats += credit.paidMsatsDelta;
+      if (credit.clearPending || (record.pendingPaymentMsats ?? 0) <= credit.paidMsatsDelta) {
+        record.pendingPaymentFiatMicro = void 0;
+        record.pendingPaymentFiatCurrency = void 0;
+      }
+      if (credit.clearPending) {
+        record.pendingPaymentMsats = void 0;
+      } else {
+        record.pendingPaymentMsats = Math.max(
+          0,
+          (record.pendingPaymentMsats ?? 0) - credit.paidMsatsDelta
+        );
+        if (record.pendingPaymentMsats === 0) record.pendingPaymentMsats = void 0;
+      }
+      record.creditId ??= credit.creditId;
+      record.drawId ??= credit.drawId;
+      if (credit.paymentMint) record.paymentMint = credit.paymentMint;
+      if (credit.paymentRail) record.paymentRail = credit.paymentRail;
+      if (credit.paymentTxHash) record.paymentTxHash = credit.paymentTxHash;
+      if (credit.nativeAmount !== void 0) {
+        record.nativeAmount = credit.accumulateNative ? (record.nativeAmount ?? 0) + credit.nativeAmount : credit.nativeAmount;
+      }
+      if (credit.nativeAsset) record.nativeAsset = credit.nativeAsset;
+      if (credit.cashuFlow) record.cashuFlow = credit.cashuFlow;
+      if (credit.clearPendingX402Binding) {
+        record.pendingX402Nonce = void 0;
+        record.pendingX402AmountUsdcMicro = void 0;
+      }
+    }
+    record.lastActivityAt = Date.now();
+    this.notify(jobId, stored.message);
+    return Promise.resolve({
+      counters: snapshotCounters(record),
+      alreadyVerified: false,
+      ...creditBinding(record)
+    });
+  }
+  getVerifiedInbound(jobId, seq) {
+    const record = this.data.get(jobId);
+    const stored = this.messagesFor(jobId).find((m) => m.message.seq === seq);
+    if (!record || stored?.status !== "verified") return Promise.resolve(void 0);
+    return Promise.resolve({
+      counters: snapshotCounters(record),
+      alreadyVerified: true,
+      ...creditBinding(record)
+    });
+  }
+  markInboundFailed(jobId, seq, _reason) {
+    const stored = this.messagesFor(jobId).find((m) => m.message.seq === seq);
+    if (stored?.status === "pending-verification") {
+      stored.status = "failed-verify";
+    }
+    return Promise.resolve();
+  }
+  findStaleJobs(processingThresholdMs, awaitingThresholdMs, limit, capabilities) {
+    const capabilitySet = capabilities === null ? null : new Set(capabilities);
+    const matches = [];
+    for (const record of this.data.values()) {
+      const isProcessing = record.status === "processing" || record.status === "working";
+      const isAwaiting = record.status === "awaiting-input";
+      const eligibleStatus = isProcessing && record.lastActivityAt <= processingThresholdMs || isAwaiting && record.lastActivityAt <= awaitingThresholdMs;
+      const eligibleCapability = capabilitySet === null || capabilitySet.has(record.capability);
+      if (eligibleStatus && eligibleCapability) {
+        matches.push(structuredClone(record));
+      }
+    }
+    matches.sort((a, b) => a.lastActivityAt - b.lastActivityAt);
+    return Promise.resolve(matches.slice(0, limit));
+  }
+  heartbeatActiveJobs(jobIds, now) {
+    for (const id of jobIds) {
+      const record = this.data.get(id);
+      if (record && (record.status === "processing" || record.status === "working")) {
+        record.lastActivityAt = now;
+      }
+    }
+    return Promise.resolve();
+  }
+  cancelStaleJob(jobId, expectedActivityBefore, reason, terminalStatus) {
+    return this.terminateJob(jobId, reason, terminalStatus, expectedActivityBefore);
+  }
+  cancelJob(jobId, reason) {
+    return this.terminateJob(jobId, reason, "cancelled", null);
+  }
+  getCounters(jobId) {
+    const record = this.data.get(jobId);
+    if (!record) return Promise.resolve(void 0);
+    return Promise.resolve(snapshotCounters(record));
+  }
+  claimForProcessing(jobId) {
+    const record = this.data.get(jobId);
+    if (record?.status !== "awaiting-input") return Promise.resolve(false);
+    record.status = "processing";
+    record.lastActivityAt = Date.now();
+    return Promise.resolve(true);
+  }
+  async tryReactivationLock(jobId, fn) {
+    if (this.reactivationLocks.has(jobId)) return { acquired: false };
+    this.reactivationLocks.add(jobId);
+    try {
+      const result = await fn();
+      return { acquired: true, result };
+    } finally {
+      this.reactivationLocks.delete(jobId);
+    }
+  }
+  async subscribeMessages(jobId, afterSeq, onMessage) {
+    const sub = { afterSeq, cb: onMessage };
+    let subs = this.messageSubscribers.get(jobId);
+    if (!subs) {
+      subs = /* @__PURE__ */ new Set();
+      this.messageSubscribers.set(jobId, subs);
+    }
+    subs.add(sub);
+    const existing = await this.getMessages(jobId, afterSeq);
+    for (const msg of existing) {
+      if (msg.seq > sub.afterSeq) {
+        sub.afterSeq = msg.seq;
+        onMessage(msg);
+      }
+    }
+    const subSet = subs;
+    return () => {
+      subSet.delete(sub);
+      if (subSet.size === 0) this.messageSubscribers.delete(jobId);
+    };
+  }
+  subscribeNotifications(jobId, onNotify) {
+    let subs = this.notifySubscribers.get(jobId);
+    if (!subs) {
+      subs = /* @__PURE__ */ new Set();
+      this.notifySubscribers.set(jobId, subs);
+    }
+    subs.add(onNotify);
+    const subSet = subs;
+    return Promise.resolve(() => {
+      subSet.delete(onNotify);
+      if (subSet.size === 0) this.notifySubscribers.delete(jobId);
+    });
+  }
+  getMessages(jobId, afterSeq) {
+    const stored = this.messagesFor(jobId);
+    return Promise.resolve(
+      stored.filter((m) => m.status === "verified" && m.message.seq > afterSeq).map((m) => m.message)
+    );
+  }
+  initStreaming() {
+    return Promise.resolve();
+  }
+  shutdownStreaming() {
+    this.messageSubscribers.clear();
+    this.notifySubscribers.clear();
+    return Promise.resolve();
+  }
+  // ── Internal helpers ──────────────────────────────────────────────────
+  /**
+   * Shared body of `cancelStaleJob` (activity cutoff supplied) and `cancelJob`
+   * (`null` cutoff — unconditional). Mirrors `PostgresJobStore.terminateJob`:
+   * the terminal status and the final `cancel` message land together and the
+   * notify fires before the incremental log is cleaned up.
+   */
+  terminateJob(jobId, reason, terminalStatus, expectedActivityBefore) {
+    const record = this.data.get(jobId);
+    if (!record) return Promise.resolve(false);
+    const eligible = (record.status === "processing" || record.status === "working" || record.status === "awaiting-input") && (expectedActivityBefore === null || record.lastActivityAt <= expectedActivityBefore);
+    if (!eligible) return Promise.resolve(false);
+    const seq = this.allocateSeq(jobId);
+    const cancelMsg = {
+      seq,
+      from: "provider",
+      timestamp: Math.floor(Date.now() / 1e3),
+      type: "cancel",
+      content: { reason }
+    };
+    this.messagesFor(jobId).push({ message: cancelMsg, status: "verified" });
+    record.status = terminalStatus;
+    record.summary = record.summary ?? reason;
+    record.messages = [...record.messages, cancelMsg];
+    record.seq = seq;
+    record.lastActivityAt = Date.now();
+    this.notify(jobId, cancelMsg);
+    this.messages.delete(jobId);
+    return Promise.resolve(true);
+  }
+  allocateSeq(jobId) {
+    const seq = this.nextSeq.get(jobId) ?? 1;
+    this.nextSeq.set(jobId, seq + 1);
+    return seq;
+  }
+  messagesFor(jobId) {
+    let list = this.messages.get(jobId);
+    if (!list) {
+      list = [];
+      this.messages.set(jobId, list);
+    }
+    return list;
+  }
+  notify(jobId, message) {
+    const subs = this.messageSubscribers.get(jobId);
+    if (subs) {
+      for (const sub of subs) {
+        if (message.seq > sub.afterSeq) {
+          sub.afterSeq = message.seq;
+          sub.cb(message);
+        }
+      }
+    }
+    this.fireNotifyOnly(jobId);
+  }
+  fireNotifyOnly(jobId) {
+    const subs = this.notifySubscribers.get(jobId);
+    if (subs) for (const cb of subs) cb();
+  }
+};
+function requestIdClaimKey(requesterPubkey, requestId) {
+  return `${requesterPubkey}\0${requestId}`;
+}
+function creditBinding(record) {
+  return {
+    ...record.creditId !== void 0 && { creditId: record.creditId },
+    ...record.drawId !== void 0 && { drawId: record.drawId }
+  };
+}
+function snapshotCounters(record) {
+  return {
+    status: record.status,
+    paidMsats: record.paidMsats,
+    pendingPaymentMsats: record.pendingPaymentMsats,
+    summary: record.summary
+  };
+}
+
+// src/sdk/logger.ts
+function createConsoleLogger(jobId) {
+  const fmt = (message, data) => {
+    const parts = [`[${jobId}] ${message}`];
+    if (data) parts.push(data);
+    return parts;
+  };
+  return {
+    debug(message, data) {
+      console.debug(...fmt(message, data));
+    },
+    info(message, data) {
+      console.info(...fmt(message, data));
+    },
+    warn(message, data) {
+      console.warn(...fmt(message, data));
+    },
+    error(message, data) {
+      console.error(...fmt(message, data));
+    }
+  };
+}
+function createNoopLogger() {
+  const noop2 = () => {
+  };
+  return { debug: noop2, info: noop2, warn: noop2, error: noop2 };
+}
+
+// src/observability/context.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { randomBytes, randomUUID } from "crypto";
+var storage = new AsyncLocalStorage();
+var defaultService = "unknown";
+function setDefaultService(service) {
+  defaultService = service;
+}
+function randomTraceId() {
+  const buf = randomBytes(16);
+  const now = Date.now();
+  buf.writeUInt16BE(Math.floor(now / 4294967296), 0);
+  buf.writeUInt32BE(now % 4294967296, 2);
+  buf[6] = buf[6] & 15 | 112;
+  buf[8] = buf[8] & 63 | 128;
+  return buf.toString("hex");
+}
+function randomSpanId() {
+  return randomUUID().replace(/-/g, "").slice(0, 16);
+}
+function withTraceContext(ctx, fn) {
+  return storage.run(ctx, fn);
+}
+function currentContext(service) {
+  const ctx = storage.getStore();
+  if (ctx) return ctx;
+  return {
+    traceId: randomTraceId(),
+    spanId: null,
+    dimensions: {},
+    service: service ?? defaultService
+  };
+}
+function pinDimension(key, value) {
+  const ctx = storage.getStore();
+  if (ctx) {
+    ctx.dimensions = { ...ctx.dimensions, [key]: value };
+  }
+}
+function rawContext() {
+  return storage.getStore();
+}
+
+// src/observability/datasets.ts
+var SPANS_DATASETS = [
+  { name: "platform", retentionDays: 90 },
+  { name: "cashu", retentionDays: 90 },
+  { name: "lightning", retentionDays: 90 },
+  { name: "stripe", retentionDays: 90 },
+  { name: "x402", retentionDays: 90 },
+  { name: "tempo", retentionDays: 90 },
+  { name: "isolate", retentionDays: 90 },
+  { name: "audit", retentionDays: 365 },
+  { name: "cron", retentionDays: 30 }
+];
+var DATASET_NAMES = new Set(SPANS_DATASETS.map((d) => d.name));
+
+// src/observability/with-span.ts
+import { hostname } from "os";
+
+// src/observability/stdout-sink.ts
+var SENSITIVE_KEY_RE = /secret|token|password|private|bearer|seed|preimage|api[_-]?key|signing[_-]?key|priv[_-]?key/i;
+var isTTY = typeof process.stdout.isTTY === "boolean" && process.stdout.isTTY;
+var RED = isTTY ? "\x1B[31m" : "";
+var YELLOW = isTTY ? "\x1B[33m" : "";
+var RESET = isTTY ? "\x1B[0m" : "";
+function formatSpanLine(span) {
+  const ts = new Date(span.started_at_ms).toISOString();
+  const levelStr = colorLevel(span.level);
+  const parts = [`[${ts}]`, span.dataset, `${levelStr}:`, span.name];
+  if (span.trace_id) {
+    parts.push(`trace=${span.trace_id}`);
+  }
+  for (const [k, v] of Object.entries(span.dimensions)) {
+    parts.push(formatKV(k, v));
+  }
+  for (const [k, v] of Object.entries(span.attributes)) {
+    parts.push(formatKV(k, v));
+  }
+  const durationMs = span.ended_at_ms - span.started_at_ms;
+  if (durationMs > 0) {
+    parts.push(`duration=${durationMs}ms`);
+  }
+  if (span.error_message) {
+    parts.push(`error=${truncate(span.error_message, 120)}`);
+  }
+  return parts.join(" ");
+}
+function writeSpanLine(span) {
+  const line = formatSpanLine(span);
+  process.stdout.write(line + "\n");
+}
+function colorLevel(level) {
+  if (level === "error") return `${RED}error${RESET}`;
+  if (level === "warn") return `${YELLOW}warn${RESET}`;
+  return level;
+}
+function formatKV(key, value) {
+  if (SENSITIVE_KEY_RE.test(key)) return `${key}=[REDACTED]`;
+  return `${key}=${truncate(stringify(value), 80)}`;
+}
+function stringify(value) {
+  if (typeof value === "string") return value;
+  if (value === void 0) return "undefined";
+  if (value === null) return "null";
+  if (typeof value === "function") return "[function]";
+  if (typeof value === "symbol") return value.toString();
+  if (typeof value === "bigint") return value.toString();
+  return JSON.stringify(value);
+}
+function truncate(s, max) {
+  if (s.length <= max) return s;
+  return s.slice(0, max - 3) + "...";
+}
+
+// src/observability/with-span.ts
+var emitter = null;
+function setEmitter(fn) {
+  emitter = fn;
+}
+var cachedHost = hostname();
+var serviceVersion = process.env.GIT_SHA ?? process.env.FLY_IMAGE_REF ?? "dev";
+async function withSpan(opts, fn) {
+  const spanId = randomSpanId();
+  const existingCtx = rawContext();
+  const ctx = existingCtx ?? currentContext();
+  const startMs = opts.startMs ?? Date.now();
+  let status = "ok";
+  let level = opts.level;
+  let errorMessage = null;
+  let errorStack = null;
+  if (opts.err) {
+    status = "error";
+    errorMessage = opts.err.message;
+    errorStack = opts.err.stack ?? null;
+  }
+  const childCtx = {
+    traceId: ctx.traceId,
+    spanId,
+    dimensions: { ...ctx.dimensions, ...opts.dims },
+    service: ctx.service,
+    tracestate: ctx.tracestate
+  };
+  const emitRow = () => {
+    const endMs = opts.endMs ?? Date.now();
+    const row = {
+      span_id: spanId,
+      trace_id: ctx.traceId,
+      parent_span_id: ctx.spanId,
+      dataset: opts.dataset,
+      name: opts.name,
+      level: level ?? (status === "error" ? "error" : "info"),
+      status,
+      started_at_ms: startMs,
+      ended_at_ms: endMs,
+      service: ctx.service,
+      service_version: serviceVersion,
+      host: cachedHost,
+      pid: process.pid,
+      dimensions: childCtx.dimensions,
+      attributes: opts.attrs ?? {},
+      error_message: errorMessage,
+      error_stack: errorStack,
+      sample_rate: 1
+    };
+    writeSpanLine(row);
+    if (emitter) emitter(row);
+  };
+  try {
+    const result = await withTraceContext(childCtx, () => fn());
+    if (opts.inspect) {
+      const overrides = opts.inspect(result);
+      if (overrides) {
+        if (overrides.status) status = overrides.status;
+        if (overrides.level) level = overrides.level;
+        if (overrides.errorMessage !== void 0) errorMessage = overrides.errorMessage;
+        if (overrides.attrs) Object.assign(opts.attrs ??= {}, overrides.attrs);
+      }
+    }
+    emitRow();
+    return result;
+  } catch (err) {
+    status = "error";
+    if (err instanceof Error) {
+      errorMessage = err.message;
+      errorStack = err.stack ?? null;
+    } else {
+      errorMessage = String(err);
+    }
+    if (opts.onError) {
+      const overrides = opts.onError(err);
+      if (overrides) Object.assign(opts.attrs ??= {}, overrides);
+    }
+    emitRow();
+    throw err;
+  }
+}
+
+// src/observability/loggers.ts
+var noop = () => {
+};
+var loggers = buildNoopLoggers();
+function initLoggers(writer, service) {
+  setEmitter((row) => {
+    writer.enqueue(row);
+  });
+  setDefaultService(service);
+  const result = {};
+  for (const ds of SPANS_DATASETS) {
+    result[ds.name] = createLogger(ds.name, {});
+  }
+  loggers = result;
+  initCallerLoggers(result);
+  return result;
+}
+function createLogger(dataset, bakedDims) {
+  const logger = {
+    info(name, attrs) {
+      void withSpan({ dataset, name, level: "info", attrs, dims: bakedDims }, noop).catch(noop);
+    },
+    warn(name, attrs) {
+      void withSpan({ dataset, name, level: "warn", attrs, dims: bakedDims }, noop).catch(noop);
+    },
+    error(name, attrs) {
+      const err = attrs?.err instanceof Error ? attrs.err : void 0;
+      const cleanAttrs = attrs ? { ...attrs } : void 0;
+      if (cleanAttrs) delete cleanAttrs.err;
+      void withSpan(
+        { dataset, name, level: "error", attrs: cleanAttrs, dims: bakedDims, err },
+        noop
+      ).catch(noop);
+    },
+    async span(name, attrs, fn, opts) {
+      return withSpan({ dataset, name, attrs, dims: bakedDims, onError: opts?.onError }, fn);
+    },
+    timer(name, attrs) {
+      const startMs = Date.now();
+      return {
+        [Symbol.dispose]() {
+          const endMs = Date.now();
+          void withSpan({ dataset, name, attrs, dims: bakedDims, startMs, endMs }, noop).catch(
+            noop
+          );
+        }
+      };
+    },
+    set(dims) {
+      for (const [k, v] of Object.entries(dims)) {
+        pinDimension(k, v);
+      }
+    },
+    extend(dims) {
+      return createLogger(dataset, { ...bakedDims, ...dims });
+    },
+    tracked(name, fn) {
+      return ((...args) => logger.span(name, {}, () => fn(...args)));
+    }
+  };
+  return logger;
+}
+function buildNoopLoggers() {
+  const noopLogger = {
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    info() {
+    },
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    warn() {
+    },
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    error() {
+    },
+    async span(_name, _attrs, fn, _opts) {
+      return fn();
+    },
+    timer() {
+      return { [Symbol.dispose]() {
+      } };
+    },
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    set() {
+    },
+    extend() {
+      return noopLogger;
+    },
+    tracked(_name, fn) {
+      return fn;
+    }
+  };
+  const result = {};
+  for (const ds of SPANS_DATASETS) {
+    result[ds.name] = noopLogger;
+  }
+  return result;
+}
+
+// src/sdk/server/instrumented-fetch.ts
+function createInstrumentedFetch(signal) {
+  return async (input, init) => {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    const method = init?.method ?? (input instanceof Request ? input.method : "GET");
+    const requestSignal = init?.signal ?? (input instanceof Request ? input.signal : void 0);
+    const merged = mergeSignals(signal, requestSignal);
+    return loggers.isolate.span(
+      "dvm.fetch",
+      { url: redactUrl(url), method: method.toUpperCase() },
+      async () => {
+        const response = await globalThis.fetch(input, merged ? { ...init, signal: merged } : init);
+        return response;
+      }
+    );
+  };
+}
+function mergeSignals(a, b) {
+  if (!a) return b ?? void 0;
+  if (!b) return a;
+  return AbortSignal.any([a, b]);
+}
+
+// src/sdk/store.ts
+var MemoryKVStore = class {
+  data = /* @__PURE__ */ new Map();
+  /** Retrieve a value by key. Returns undefined if not found or expired. */
+  get(key) {
+    const entry = this.data.get(key);
+    if (!entry) return Promise.resolve(void 0);
+    if (entry.expiry !== void 0 && Date.now() > entry.expiry) {
+      this.data.delete(key);
+      return Promise.resolve(void 0);
+    }
+    return Promise.resolve(entry.value);
+  }
+  /** Store a value. Optionally set a TTL in seconds. */
+  set(key, value, opts) {
+    const expiry = opts?.ttl !== void 0 ? Date.now() + opts.ttl * 1e3 : void 0;
+    this.data.set(key, { value, expiry });
+    return Promise.resolve();
+  }
+  /** Delete a key. */
+  delete(key) {
+    this.data.delete(key);
+    return Promise.resolve();
+  }
+  /** List keys, optionally filtered by prefix. Excludes expired entries. */
+  list(prefix) {
+    const now = Date.now();
+    const keys = [];
+    for (const [key, entry] of this.data) {
+      if (entry.expiry !== void 0 && now > entry.expiry) {
+        this.data.delete(key);
+        continue;
+      }
+      if (prefix === void 0 || key.startsWith(prefix)) {
+        keys.push(key);
+      }
+    }
+    return Promise.resolve(keys);
+  }
+};
+
+export {
+  StepCache,
+  toJobRecord,
+  fromJobRecord,
+  abortJob,
+  JobCancelledError,
+  providerMessage,
+  localMessage,
+  isTerminal,
+  isYieldMessage,
+  accumulateAskedTopUp,
+  UNCAPPABLE_ASK_TOTAL,
+  isReceiptIssuingStore,
+  isStreamableJobStore,
+  MemoryJobStore,
+  createConsoleLogger,
+  createNoopLogger,
+  withTraceContext,
+  pinDimension,
+  withSpan,
+  loggers,
+  initLoggers,
+  createInstrumentedFetch,
+  MemoryKVStore
+};