@bnbagent/studio-cli 0.0.9 → 0.0.11-alpha.1

package/recipes/runtimes/azure-foundry/code/{{PKG}}/Dockerfile.tmpl

@@ -1,35 +1,33 @@
-# Azure AI Foundry Hosted Agent image — SHIPPED BY `bag init`.
-# NOTE: deliberately NO `# syntax=docker/dockerfile:1` directive AND no BuildKit-only
-# instruction flags (`FROM --platform=…`, `RUN --mount=…`) — the file stays
-# classic-builder-compatible so any builder (a "classic" builder rejects
-# `FROM --platform=…` with "unable to understand line FROM --platform=…") can
-# process it. The target arch is pinned OUTSIDE the Dockerfile instead: the
-# pinned bnbagent-deploy (which `bag deploy --provider azure` delegates all cloud
-# execution to) builds this Dockerfile LOCALLY with Docker for linux/amd64
-# (`--platform` on the build command) and pushes the image to the
-# auto-provisioned Azure Container Registry; Foundry Agent Service pulls +
-# runs it, assigning a dedicated agent identity + endpoint.
+# Agent image — SHIPPED BY `bag init`, ONE Dockerfile for BOTH deploy clouds.
 #
-# Why a custom image: azure-foundry deploys are container-only (the deploy
-# provider rejects Node zip), and a twak wallet additionally shells out to the
-# `twak` CLI (npm @trustwallet/cli) for every signing / on-chain intent, so
-# the image must carry it globally.
-FROM docker.io/library/node:22-slim
+# Why a custom image: the managed Node runtimes ship only the project's own
+# bundle, and every signing / on-chain intent for a twak wallet shells out to
+# the `twak` CLI (npm @trustwallet/cli), which must be installed globally in
+# the image. `bag deploy` hands this file to the pinned bnbagent-deploy,
+# which builds the image locally with Docker and pushes it to the target
+# cloud's registry (ECR for AgentCore, ACR for Azure Foundry).
+#
+# Arch is NOT pinned here: each deploy provider pins it on the build command
+# (`--platform linux/arm64` for AgentCore, `--platform linux/amd64` for
+# Foundry), so the same Dockerfile cross-builds for either cloud. Keep this
+# file classic-builder compatible: no `# syntax=` directive and no
+# BuildKit-only instructions (`RUN --mount=...`), so a plain `docker build`
+# works everywhere.
+FROM public.ecr.aws/docker/library/node:22-slim
 
-# The pinned twak CLI + pnpm.
+# The pinned twak CLI.
 #
 # ARCH WARNING: `npm install` MUST run with this image's own node (as below).
 # Installing on the host (or any other arch) and COPYing node_modules in
 # breaks at runtime: twak's `@napi-rs/keyring` native binding is selected at
-# install time per-arch (known npm optional-deps bug) — a cross-arch-installed
-# tree crashes at runtime. Multi-arch images must install per-arch too.
+# install time per-arch (known npm optional-deps bug) — an x64-installed tree
+# crashes under arm64 node. Multi-arch images must install per-arch too.
 RUN npm install -g @trustwallet/cli@{{TWAK_CLI_VERSION}} pnpm@{{PNPM_VERSION}} \
  && npm cache clean --force
 
 WORKDIR /app
 # Install deps first (layer cache), then build. The lockfile is copied when
-# present; a project without one falls back to a plain install. (No BuildKit
-# cache mounts here — see the classic-builder note above.)
+# present; a project without one falls back to a plain install.
 COPY package.json pnpm-lock.yaml* pnpm-workspace.yaml ./
 COPY vendor ./vendor
 RUN pnpm install
@@ -40,8 +38,12 @@ RUN pnpm build
 # Runtime deps only in the final tree (drops typescript etc.).
 RUN pnpm prune --prod
 
-# {{CONTAINER_PORT}} / {{ENTRYPOINT}} are rendered by `bag init` from the
-# provider contract (Foundry uses 8088 + dist/foundryMain.js).
+# Hosted-runtime port contracts (the unified entrypoint binds BOTH 9000 and
+# 8088 itself; AGENT_PORT only prepends a primary override):
+#   AgentCore A2A → 0.0.0.0:9000 at /        MCP → 0.0.0.0:8000/mcp
+#   Foundry invocations/responses → 0.0.0.0:8088
+# `bag init` renders {{CONTAINER_PORT}} / {{ENTRYPOINT}} from the selected
+# protocol. ({{ENTRYPOINT}} is the BUILT entrypoint, e.g. dist/unifiedMain.js.)
 ENV AGENT_PORT={{CONTAINER_PORT}}
 EXPOSE {{CONTAINER_PORT}}
 CMD ["node", "{{ENTRYPOINT}}"]

package/recipes/runtimes/azure-foundry/code/{{PKG}}/agentCard.ts.tmpl

@@ -1,14 +1,14 @@
 /**
  * A2A AgentCard — the seller agent's outward, discoverable identity.
  *
- * Built by `main.ts` and served at `/.well-known/agent-card.json`. On
- * AgentCore, `$AGENTCORE_RUNTIME_URL` overrides `card.url` at boot;
- * azure-foundry/local runs keep the client-routable local placeholder.
+ * Built by `main.ts` and served at `/.well-known/agent-card.json`. When
+ * deployed, `main.ts` overwrites `card.url` at boot with the deployed
+ * AgentCore runtime URL (`$AGENTCORE_RUNTIME_URL`), so the `url` here is only
+ * a local-dev placeholder.
  *
  * The card advertises exactly two skills — `negotiate` and `notify_funded` —
- * and the OAuth2 (Cognito) security scheme buyers must satisfy when deployed
- * behind AgentCore: A2A endpoints require an inbound OAuth2 bearer (there is
- * no anonymous mode).
+ * and the OAuth2 (Cognito) security scheme buyers must satisfy: AgentCore A2A
+ * endpoints require an inbound OAuth2 bearer (there is no anonymous mode).
  * The token URL + scope come from the Cognito user pool
  * `bag deploy provision-cognito` creates (env `OAUTH_TOKEN_URL` /
  * `OAUTH_SCOPE`, injected at deploy); the runtime's inbound JWT authorizer
@@ -93,8 +93,10 @@ function oauth2Scheme(): SecurityScheme | null {
   };
 }
 
-/** Build the A2A AgentCard advertising the two seller skills (+ OAuth2 if set). */
-export function buildAgentCard(): AgentCard {
+/** Build the A2A AgentCard, gating ERC-8183 skills on the configured rail. */
+export function buildAgentCard(
+  opts: { commerceSkills?: boolean } = {},
+): AgentCard {
   const name = agentName();
   const extra: Partial<AgentCard> = {};
   const scheme = oauth2Scheme();
@@ -106,13 +108,14 @@ export function buildAgentCard(): AgentCard {
   return {
     name,
     description: `ERC-8183 seller agent (${name}) — negotiate + notify_funded over A2A.`,
-    // $AGENTCORE_RUNTIME_URL wins when deployed behind AgentCore.
+    // main.ts overwrites this with $AGENTCORE_RUNTIME_URL at boot.
     // Local-dev fallback: a client-routable localhost URL (not the 0.0.0.0
     // bind address). Host via AGENT_HOST (default localhost); port via the
-    // same PORT → AGENT_PORT → 9000 resolution main.ts serves on.
+    // same AGENT_PORT → 9000 resolution main.ts serves on. Do not honor the
+    // AgentCore HTTP $PORT=8080 convention for this A2A runtime.
     url:
       process.env.AGENTCORE_RUNTIME_URL ??
-      `http://${process.env.AGENT_HOST ?? "localhost"}:${process.env.PORT || process.env.AGENT_PORT || "9000"}/`,
+      `http://${process.env.AGENT_HOST ?? "localhost"}:${process.env.AGENT_PORT || "9000"}/`,
     version: "1.0.0",
     protocolVersion: "0.3.0",
     preferredTransport: "JSONRPC",
@@ -125,7 +128,8 @@ export function buildAgentCard(): AgentCard {
     capabilities: { streaming: false },
     defaultInputModes: ["application/json"],
     defaultOutputModes: ["application/json"],
-    skills: [NEGOTIATE, NOTIFY_FUNDED],
+    skills:
+      opts.commerceSkills === false ? [] : [NEGOTIATE, NOTIFY_FUNDED],
     ...extra,
   };
 }

package/recipes/runtimes/azure-foundry/code/{{PKG}}/executor.ts.tmpl

@@ -1,38 +1,38 @@
 /**
- * A2A executor — the seller agent's outward surface (two fixed-code skills).
+ * A2A executor — the seller agent's outward A2A surface (two fixed-code
+ * skills).
  *
- * The agent serves A2A directly through the runtime's A2A entrypoint. For
- * azure-foundry this is the cloud-neutral `@a2a-js/sdk` express app;
- * AgentCore wraps the same protocol on its own runtime contract.
- * {@link SellerAgentExecutor.execute} reads the inbound message's data part
- * and dispatches on its `skill`:
+ * The agent serves A2A directly (an `@a2a-js/sdk` express app on the
+ * AgentCore A2A runtime contract). This module is ONLY the a2a wire:
+ * {@link SellerAgentExecutor} inherits all of the seller logic +
+ * background-delivery machinery from `sellerCore.ts` `SellerCore` (which
+ * imports nothing from `@a2a-js/sdk`) and adds the a2a-specific
+ * {@link SellerAgentExecutor.execute} / {@link SellerAgentExecutor.cancelTask}
+ * entrypoints plus the request/response wire helpers. `execute` reads the
+ * inbound message's data part and dispatches on its `skill`:
  *
- *     negotiate     → `signing.signQuote` (rule-based price clamp + EIP-191 sign)
- *     notify_funded → `signing.verifySignedJob` (fast on-chain gate) → ACK at
+ *     negotiate     → `SellerCore.negotiate` (rule-based price clamp + EIP-191 sign)
+ *     notify_funded → `SellerCore.notifyFunded` (fast on-chain gate) → ACK at
  *                     once, then in the BACKGROUND: LLM work → `signing.submitResult`
  *
  * `notify_funded` is the buyer's "I funded job X — please deliver"
  * notification. Because the work takes time, the executor does NOT block the
- * caller: it verifies the funded job synchronously (a couple of eth_calls)
- * to ACK accepted/rejected, then runs the slow LLM work + on-chain `submit`
- * in a background task and replies immediately. The buyer reads the
+ * caller: the core verifies the funded job synchronously (a couple of
+ * eth_calls) to ACK accepted/rejected, then runs the slow LLM work + on-chain
+ * `submit` in a background task and replies immediately. The buyer reads the
  * deliverable back from the CHAIN (SUBMITTED / `getDeliverableUrl`) — the
  * chain is the source of truth. While any background delivery is in flight
- * {@link SellerAgentExecutor.isBusy} reports busy; AgentCore's entrypoint
- * feeds that to `/ping` as `HEALTHY_BUSY` so the scale-to-zero runtime stays
+ * `isBusy` (from `SellerCore`) reports busy, which `main.ts` feeds to
+ * AgentCore's `/ping` as `HEALTHY_BUSY` so the scale-to-zero runtime stays
  * warm until the work lands (within the session max-lifetime).
  *
  * ALL signing is FIXED code in `signing.ts` — NEVER an LLM-callable tool
  * (money is never in the LLM; the LLM only produces the work text, via the
- * `runWork` hook). On each notification the executor also opportunistically
- * sweeps OTHER funded jobs assigned to this provider — the buyer-push
- * fallback for jobs whose buyer funded on-chain but never sent
- * `notify_funded` (deduped against in-flight jobs). Negotiate stays
- * sweep-free so quotes are fast. A periodic poller — which also covers the
- * scale-to-zero cold window when no one is invoking — is the v2 robust path.
+ * `runWork` hook). See `sellerCore.ts` for the negotiate / notifyFunded /
+ * sweep logic.
  *
- * You own this file — specialise the work hook / dispatch, but keep signing
- * OUT of the LLM tool list.
+ * You own this file — specialise the work hook / dispatch in `sellerCore.ts`,
+ * but keep signing OUT of the LLM tool list.
  */
 
 import { randomUUID } from "node:crypto";
@@ -43,140 +43,35 @@ import {
   type ExecutionEventBus,
   type RequestContext,
 } from "@a2a-js/sdk/server";
-import { ERC8183JobOps } from "@bnbagent/sdk/erc8183";
-import { SubmitPermanentlyUnsupportedError } from "@bnbagent/studio-runtime/erc8183";
-import { getWallet } from "@bnbagent/studio-runtime/wallet";
-import * as defaultSigning from "./signing.js";
+import { SellerCore } from "./sellerCore.js";
 
 const log = {
-  info: (msg: string) => console.log(`[seller-agent.a2a] ${msg}`),
-  warn: (msg: string) => console.warn(`[seller-agent.a2a] WARNING ${msg}`),
   error: (msg: string, e?: unknown) =>
     console.error(`[seller-agent.a2a] ERROR ${msg}`, e ?? ""),
 };
 
 /**
- * The LLM work hook: produce the deliverable text for a prompt. Built in
- * `main.ts` / `foundryMain.ts`; called ONLY inside the background delivery.
- */
-export type RunWork = (
-  prompt: string,
-  opts: { sessionId: string; abortSignal?: AbortSignal },
-) => Promise<string>;
-
-/** The `signing.ts` surface the executor drives (injectable for tests). */
-export interface SigningApi {
-  listPrice(): bigint;
-  clampPrice(proposedWei: bigint): bigint;
-  signQuote(
-    request: Record<string, unknown>,
-    clampedPriceWei: bigint,
-  ): Promise<Record<string, unknown>>;
-  verifySignedJob(
-    jobId: number,
-  ): Promise<{ ok: boolean; reason: string; permanent: boolean }>;
-  jobSpec(
-    jobId: number,
-  ): Promise<{ task: string; terms: Record<string, unknown> } | null>;
-  submitResult(
-    jobId: number,
-    responseContent: string,
-    metadata?: Record<string, unknown> | null,
-  ): Promise<{ submitTx: string; deliverableUrl: string | null }>;
-}
-
-/** Pending-job scanner used by the sweep (injectable for tests). */
-export type PendingJobsFetcher = (
-  network: string,
-) => Promise<Record<string, unknown>>;
-
-const defaultPendingJobs: PendingJobsFetcher = async (network) => {
-  const ops = await ERC8183JobOps.create({
-    walletProvider: getWallet(),
-    network,
-  });
-  return (await ops.getPendingJobs()) as Record<string, unknown>;
-};
-
-export interface SellerAgentExecutorOpts {
-  runWork: RunWork;
-  generator: string;
-  network?: string | null;
-  /** Test seam: replace the signing module (default: `./signing.js`). */
-  signing?: SigningApi;
-  /** Test seam: replace the sweep's pending-job scan. */
-  pendingJobs?: PendingJobsFetcher;
-}
-
-/**
- * ERC-8183 seller A2A executor: negotiate + notify_funded, backed by
- * signing.ts.
+ * ERC-8183 seller A2A executor: the a2a wire over `SellerCore`.
  *
- * `runWork(prompt, { sessionId })` is the LLM work hook (built in `main.ts` /
- * `foundryMain.ts`); it is called inside the background delivery
- * (`notify_funded` → `doWorkAndSubmit`) to produce the deliverable text.
+ * All seller logic (negotiate, notifyFunded, background delivery, `isBusy`,
+ * the constructor bookkeeping, the `runWork` hook) lives in
+ * `sellerCore.ts` `SellerCore`; this class adds only the A2A entrypoints and
+ * request/response wire helpers.
  *
  * The agent exposes ONLY the two paid, structured skills — there is no
  * free-form chat skill. A plain text message (no `{"skill": ...}` DataPart)
  * is rejected: negotiate / notify_funded always need a structured DataPart,
  * so prose never triggers an LLM call or a paid action.
  */
-export class SellerAgentExecutor implements AgentExecutor {
-  private readonly runWork: RunWork;
-  private readonly generator: string;
-  private readonly network: string;
-  private readonly signing: SigningApi;
-  private readonly pendingJobs: PendingJobsFetcher;
-  // Background delivery bookkeeping (see notifyFunded / isBusy):
-  //  tasks    — live background promises (busy-status source).
-  //  inflight — job ids in flight OR already terminally handled this
-  //             process (notify/sweep dedup; retained on success so a
-  //             slower sweep never re-delivers a just-submitted job).
-  private readonly tasks = new Set<Promise<void>>();
-  private readonly inflight = new Set<number>();
-
-  constructor(opts: SellerAgentExecutorOpts) {
-    this.runWork = opts.runWork;
-    this.generator = opts.generator;
-    this.network = opts.network ?? "bsc-testnet";
-    this.signing = opts.signing ?? defaultSigning;
-    this.pendingJobs = opts.pendingJobs ?? defaultPendingJobs;
-  }
-
-  /**
-   * True while any background delivery is in flight.
-   *
-   * AgentCore's entrypoint feeds this to `/ping` (`HEALTHY_BUSY` when busy)
-   * so a scale-to-zero runtime is not reaped on idle while work runs. The
-   * azure/local uvicorn-style process stays up on its own, so there it is
-   * informational only.
-   */
-  isBusy(): boolean {
-    return this.tasks.size > 0;
-  }
-
-  /** Await every in-flight background task (test helper — not on the wire). */
-  async drain(): Promise<void> {
-    while (this.tasks.size > 0) {
-      await Promise.allSettled([...this.tasks]);
-    }
-  }
-
-  // ── protocol-agnostic skill dispatch ──────────────────────────────────────
-
+export class SellerAgentExecutor extends SellerCore implements AgentExecutor {
   /**
-   * Run the skill named by `data.skill` and return its result dict.
-   *
-   * The single source of truth for the seller's behaviour, independent of
-   * the wire protocol. The @a2a-js path ({@link execute}) reads a DataPart
-   * into `data` and writes the result back as a DataPart; the Azure Foundry
-   * Invocations host (`foundryMain.ts`) parses a text-encoded JSON envelope
-   * into `data` and serialises the result back to text. Both call HERE so
-   * negotiate / notify_funded behave identically on every runtime.
+   * Text-carrier entrypoint (Foundry invocations / responses SkillRouter).
    *
-   * Never throws: a skill failure (or an unknown / missing skill) is
-   * returned as an `{"error": ...}` dict so the caller can always reply (an
-   * escaped exception would hang the A2A caller with no response).
+   * Same skill switch as {@link execute}, but NEVER throws: on a text
+   * carrier there is no JSON-RPC error channel, so a fault is returned as an
+   * `{"error": ...}` dict and the caller can always reply. The A2A path
+   * keeps its own switch below because its fault semantics differ (faults
+   * become JSON-RPC -32603 via A2AError).
    */
   async dispatch(
     data: Record<string, unknown>,
@@ -205,13 +100,45 @@ export class SellerAgentExecutor implements AgentExecutor {
     }
   }
 
-  // ── A2A entrypoints ─────────────────────────────────────────────────────
-
+  // ── A2A entrypoints ───────────────────────────────────────────────────────
   execute = async (
     context: RequestContext,
     eventBus: ExecutionEventBus,
   ): Promise<void> => {
-    const result = await this.dispatch(inbound(context));
+    const data = inbound(context);
+    const skill = data.skill;
+    let result: Record<string, unknown>;
+    try {
+      if (skill === "negotiate") {
+        result = await this.negotiate(data);
+      } else if (skill === "notify_funded") {
+        result = await this.notifyFunded(data);
+      } else {
+        // Includes a plain text message (no DataPart → skill is undefined):
+        // the seller has no free-form skill, so prose is rejected here.
+        result = {
+          error: `unknown skill: ${JSON.stringify(skill)}`,
+          skills: this.skills(),
+        };
+        if (skill === undefined) {
+          // Most common cause: the caller put the JSON envelope in a
+          // "text" part. Structured skill calls must ride in a DataPart.
+          result.hint =
+            'send the skill envelope as an A2A data part: parts:[{"kind":"data","data":{"skill":"negotiate",...}}]';
+        }
+      }
+    } catch (e) {
+      // A genuine internal fault is surfaced as a JSON-RPC error, NOT masked
+      // as a successful result. Throwing `A2AError.internalError` is caught
+      // by @a2a-js/sdk's request handler and serialized to a proper -32603
+      // carrying the request id. CLASSIFIED business outcomes are
+      // returned as a result above (peer of the MCP runtime: faults →
+      // isError, business outcomes → result).
+      log.error(`skill ${JSON.stringify(skill)} failed`, e);
+      const name = e instanceof Error ? e.constructor.name : "Error";
+      const msg = e instanceof Error ? e.message : String(e);
+      throw A2AError.internalError(`${name}: ${msg}`);
+    }
     reply(eventBus, context, result);
   };
 
@@ -221,251 +148,11 @@ export class SellerAgentExecutor implements AgentExecutor {
   ): Promise<void> => {
     // negotiate is synchronous; notify_funded acks then delivers on-chain in
     // the background — once submitted it is anchored on-chain and cannot be
-    // cancelled via A2A. Nothing to cancel here.
+    // cancelled via A2A. Nothing to cancel here. (@a2a-js/sdk hands cancel
+    // only a taskId — no message to reply to — so this surfaces as the
+    // standard JSON-RPC unsupported-operation error.)
     throw A2AError.unsupportedOperation("cancel");
   };
-
-  // ── skills ────────────────────────────────────────────────────────────────
-
-  /**
-   * Rule-based quote → SDK `NegotiationResult` envelope (no LLM).
-   *
-   * The price is the FIXED list price from studio.toml, clamped to
-   * `[min,max]` BEFORE signing — a misconfigured or hostile request can
-   * never sign out of bounds. The buyer parses this envelope verbatim and
-   * anchors it on-chain via `createJob` + `fund`.
-   */
-  private async negotiate(
-    data: Record<string, unknown>,
-  ): Promise<Record<string, unknown>> {
-    let request = data.request;
-    if (request === null || typeof request !== "object" || Array.isArray(request)) {
-      const picked: Record<string, unknown> = {};
-      for (const k of ["task_description", "terms"]) {
-        if (k in data) picked[k] = data[k];
-      }
-      request = picked;
-    }
-    const clamped = this.signing.clampPrice(this.signing.listPrice());
-    return this.signing.signQuote(request as Record<string, unknown>, clamped);
-  }
-
-  /** The seller's two advertised skills. */
-  skills(): string[] {
-    return ["negotiate", "notify_funded"];
-  }
-
-  /**
-   * Buyer notification: "I funded job X — please deliver."
-   *
-   * Verify the funded job synchronously (a couple of eth_calls) to ACK
-   * accepted/rejected at once, then run the slow LLM work + on-chain
-   * `submit` in a BACKGROUND task and reply IMMEDIATELY. The buyer reads
-   * the deliverable back from the CHAIN (SUBMITTED / `getDeliverableUrl`) —
-   * the chain is the source of truth (see erc8183-buyer-push.md).
-   *
-   * An accepted notification also kicks a background sweep (deduped against
-   * in-flight jobs), so a buyer that funded but forgot to notify is still
-   * served while we're warm. A rejected / malformed notification spawns
-   * nothing.
-   */
-  private async notifyFunded(
-    data: Record<string, unknown>,
-  ): Promise<Record<string, unknown>> {
-    const raw = data.job_id;
-    if (raw === undefined || raw === null || String(raw) === "") {
-      this.spawn(() => this.sweep()); // bare notify → just scan stragglers
-      return {
-        status: "accepted",
-        note: "no job_id — scanning funded jobs in the background; poll the chain for results",
-      };
-    }
-    let jobId: number;
-    try {
-      jobId = parseJobId(raw);
-    } catch {
-      return { status: "rejected", error: `invalid job_id: ${JSON.stringify(raw)}` };
-    }
-    let verified = false;
-    try {
-      const v = await this.signing.verifySignedJob(jobId);
-      if (!v.ok && v.permanent) {
-        return { status: "rejected", job_id: jobId, reason: v.reason };
-      }
-      verified = v.ok;
-    } catch (e) {
-      // pre-verify is best-effort; the background delivery re-verifies
-      log.warn(
-        `pre-verify of job ${jobId} failed (${e instanceof Error ? e.message : e}); accepting, will re-verify in background`,
-      );
-    }
-    this.spawnJob(jobId, { verified });
-    this.spawn(() => this.sweep()); // straggler fallback alongside the named job
-    return {
-      status: "accepted",
-      job_id: jobId,
-      note: "delivery started; poll the chain (SUBMITTED / get_deliverable_url) for the result",
-    };
-  }
-
-  // ── background delivery ───────────────────────────────────────────────────
-
-  /** Run `work` as a tracked background task (keeps {@link isBusy} true). */
-  private spawn(work: () => Promise<void>): void {
-    const task = work().catch((e) => {
-      // a background task must never crash the process
-      log.error("background task failed", e);
-    });
-    this.tasks.add(task);
-    task.finally(() => this.tasks.delete(task));
-  }
-
-  /**
-   * Background-deliver `jobId` once, deduped against in-flight jobs.
-   *
-   * `inflight` is updated SYNCHRONOUSLY here (before scheduling) so a
-   * concurrent notify + sweep can never double-deliver the same job.
-   */
-  private spawnJob(jobId: number, opts: { verified: boolean }): void {
-    if (this.inflight.has(jobId)) return;
-    this.inflight.add(jobId);
-    this.spawn(() => this.runJob(jobId, opts));
-  }
-
-  /**
-   * Background runner: deliver one job, log the outcome, free the slot.
-   *
-   * `verified` jobs (pre-verified in `notifyFunded`) skip straight to the
-   * work; unverified ones (the sweep) run the full verify gate first.
-   */
-  private async runJob(
-    jobId: number,
-    { verified }: { verified: boolean },
-  ): Promise<void> {
-    let terminal = false;
-    try {
-      const result = verified
-        ? await this.doWorkAndSubmit(jobId)
-        : await this.fulfillJob(jobId);
-      log.info(`notify_funded job ${jobId} → ${JSON.stringify(result)}`);
-      // A terminal outcome (delivered, or a permanent skip) must STAY in
-      // `inflight`: keeping it lets the dedup gate in spawnJob reject a
-      // slower concurrent sweep that still sees this job as FUNDED, so the
-      // just-submitted job is never re-delivered. Clearing on success
-      // reopened that race — the sweep re-ran the work and then failed the
-      // on-chain FUNDED gate (Job status is SUBMITTED). Only transient
-      // failures fall through to delete so a later sweep can retry them.
-      terminal = Boolean(result.ok || result.skip);
-    } catch (e) {
-      // a background job must never crash the process
-      log.error(`background delivery of job ${jobId} failed`, e);
-    } finally {
-      if (!terminal) {
-        this.inflight.delete(jobId);
-      }
-    }
-  }
-
-  // ── internals ─────────────────────────────────────────────────────────────
-
-  /**
-   * Verify the signed deal on-chain, then deliver (the sweep's per-job
-   * worker).
-   *
-   * VERIFY before working: confirm the funded job carries the exact quote
-   * THIS agent signed (ecrecover + budget ≥ price). A permanent failure
-   * (not our signature, tampered terms, underfunded, expired) returns
-   * `skip: true`; a transient one returns `ok: false` to retry.
-   */
-  private async fulfillJob(jobId: number): Promise<Record<string, unknown>> {
-    const v = await this.signing.verifySignedJob(jobId);
-    if (!v.ok) {
-      return { ok: false, job_id: jobId, skip: v.permanent, reason: v.reason };
-    }
-    return this.doWorkAndSubmit(jobId);
-  }
-
-  /**
-   * LLM work → sign + submit. Assumes `jobId` is already verified.
-   *
-   * DEVELOPER HOOK: the LLM block produces the deliverable text — specialise
-   * it for your seller. `signing.submitResult` re-runs the SDK `verifyJob`
-   * (defense in depth) and THROWS on a failed submit, so an `ok: true`
-   * result always carries a landed tx hash.
-   */
-  private async doWorkAndSubmit(
-    jobId: number,
-  ): Promise<Record<string, unknown>> {
-    const spec = await this.signing.jobSpec(jobId);
-    const task =
-      spec !== null
-        ? JSON.stringify({ task: spec.task, terms: spec.terms })
-        : `job ${jobId}`;
-    const prompt =
-      "You accepted and were paid for the following job. Produce the " +
-      "deliverable now. Be complete and self-contained.\n\n" +
-      `JOB CONTEXT:\n${task}`;
-    const work = await this.runWork(prompt, { sessionId: String(jobId) });
-
-    let res: { submitTx: string; deliverableUrl: string | null };
-    try {
-      res = await this.signing.submitResult(jobId, work, {
-        job_id: jobId,
-        generator: this.generator,
-        built_with: "https://github.com/bnb-chain/bnbagent-studio",
-      });
-    } catch (e) {
-      if (
-        e instanceof SubmitPermanentlyUnsupportedError ||
-        (e instanceof Error && e.name === "SubmitPermanentlyUnsupportedError")
-      ) {
-        // Deterministic for this wallet kind: submit can NEVER succeed →
-        // permanent skip (a transient error would burn one LLM call / retry).
-        return { ok: false, job_id: jobId, skip: true, reason: e.message };
-      }
-      throw e;
-    }
-    return {
-      ok: true,
-      job_id: jobId,
-      tx_hash: res.submitTx,
-      deliverable_url: res.deliverableUrl,
-    };
-  }
-
-  /**
-   * Best-effort background fallback: deliver any FUNDED jobs for this
-   * provider.
-   *
-   * Catches jobs whose buyer funded on-chain but never sent `notify_funded`.
-   * Each job is handed to `spawnJob` (deduped against in-flight jobs, so a
-   * concurrent notify never double-delivers); `verifySignedJob` returns
-   * non-OK for an already-SUBMITTED job (idempotent, no state file). Errors
-   * here are logged and never surface to the caller.
-   */
-  private async sweep(): Promise<void> {
-    let pending: Record<string, unknown>;
-    try {
-      pending = await this.pendingJobs(this.network);
-    } catch (e) {
-      // the sweep is best-effort
-      log.warn(`funded-job sweep failed: ${e instanceof Error ? e.message : e}`);
-      return;
-    }
-    const jobs = Array.isArray(pending?.jobs) ? pending.jobs : [];
-    for (const job of jobs) {
-      const jid =
-        job !== null && typeof job === "object" && !Array.isArray(job)
-          ? (job as Record<string, unknown>).jobId
-          : undefined;
-      if (jid === undefined || jid === null) continue;
-      try {
-        this.spawnJob(parseJobId(jid), { verified: false });
-      } catch {
-        // unparseable id — skip
-      }
-    }
-  }
 }
 
 // ── wire helpers ──────────────────────────────────────────────────────────────
@@ -494,11 +181,3 @@ function reply(
   eventBus.publish(message);
   eventBus.finished();
 }
-
-/** Normalise an envelope `job_id` (`0x..` / decimal string / number) to int. */
-export function parseJobId(raw: unknown): number {
-  if (typeof raw === "number" && Number.isInteger(raw)) return raw;
-  if (typeof raw === "bigint") return Number(raw);
-  // BigInt() parses both `0x..` hex and decimal strings, and throws on junk.
-  return Number(BigInt(String(raw).trim()));
-}