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

package/recipes/runtimes/agentcore/code/{{PKG}}/unifiedMain.ts.tmpl

@@ -0,0 +1,620 @@
+/**
+ * Unified A2A seller agent entrypoint — ONE file for BOTH deploy runtimes.
+ * Generated by `bag recipe code agent`.
+ *
+ * This is the VALUABLE agent AND the SOLE key-holder/signer. The same
+ * process satisfies both hosted-agent container contracts at once:
+ *
+ * - **AWS Bedrock AgentCore** (`--provider aws`): `@a2a-js/sdk` express app
+ *   — agent card at `/.well-known/agent-card.json` + JSON-RPC `message/send`
+ *   — plus `GET /ping` for the AgentCore liveness contract (contract port
+ *   9000).
+ * - **Azure AI Foundry Hosted Agents** (`--provider azure`): pass-through
+ *   `POST /invocations` + `POST /responses` (Foundry's Responses protocol
+ *   for managed incoming A2A) plus `GET /readiness` (contract port 8088).
+ *
+ * The server listens on BOTH contract ports (9000 and 8088; `AGENT_PORT`
+ * prepends a local override), so the SAME image deploys to either cloud with
+ * zero source changes — the per-cloud build only pins the CPU arch.
+ *
+ * A2A skills (executor.ts, shared by every carrier):
+ *
+ *     negotiate     → read the FIXED list price → CLAMP to [min,max] → EIP-191 SIGN
+ *                     the offer (no LLM, no tools) → return the signed offer (or reject)
+ *     notify_funded → re-verify the funded job on-chain (fast) → ACK accepted at once,
+ *                     then in the BACKGROUND: LLM work → manifest → storage →
+ *                     submitResult (SIGN + broadcast). The buyer polls the chain for
+ *                     the deliverable. Each notify also sweeps other FUNDED jobs
+ *                     (buyer-push fallback). While background work is in flight the
+ *                     `/ping` handler reports HEALTHY_BUSY so AgentCore keeps the
+ *                     scale-to-zero runtime warm until it lands.
+ *
+ * On Foundry the skills ride as a JSON text envelope (`{"skill": ...}`)
+ * because Foundry's incoming A2A is text-modality only — {@link SkillRouter}
+ * parses it and dispatches through the SAME `SellerAgentExecutor.dispatch`.
+ *
+ * ## How x402 buyers reach /x402 on either runtime
+ *
+ * Neither hosted-agent gateway allows anonymous ingress, and both strip or
+ * gate the buyer's half of the HTTP exchange — so the anonymous buyer talks
+ * to an external gateway that wraps each request in `http-envelope-v1`
+ * (outer HTTP always 200) and forwards it with the runtime's own auth.
+ * {@link createEnvelopeMiddleware} unwraps the tunnel onto the in-process
+ * {@link X402Seller} below. See docs/guides/self-hosted-x402-gateway.md
+ * (AWS) and self-hosted-x402-gateway-azure.md (Azure).
+ *
+ * Secrets: on AgentCore, `loadRuntimeSecrets()` pulls the Secrets Manager
+ * bundle named by BNBAGENT_RUNTIME_SECRET_ID; on Azure the provider-managed
+ * Foundry CustomKeys connection injects the same variables before the
+ * process starts (the loader no-ops when the pointer is absent).
+ *
+ * ## Boundaries (do NOT cross — they are the whole point)
+ *
+ * - The agent does ALL deterministic SIGNING (quote-sign + submit + settle +
+ *   automatic Pieverse LLM-credit auto-renew). ALL signing is FIXED code in
+ *   `signing.ts` — NEVER an LLM-callable tool (money never in the LLM).
+ * - The price is a FIXED list price from studio.toml (clamped before
+ *   signing) — the LLM never prices; it only PRODUCES the work text in the
+ *   delivery step.
+ * - Chain access for the LLM is READ-ONLY tools only (`tools.ts`).
+ * - `settle` (claim payment after the dispute window) is operator-driven —
+ *   run `bag erc8183 settle <job_id>`; it is deliberately NOT an A2A skill.
+ */
+
+import { createHash, randomUUID } from "node:crypto";
+import { pathToFileURL } from "node:url";
+import {
+  GetSecretValueCommand,
+  SecretsManagerClient,
+} from "@aws-sdk/client-secrets-manager";
+import { DefaultRequestHandler, InMemoryTaskStore } from "@a2a-js/sdk/server";
+import {
+  agentCardHandler,
+  jsonRpcHandler,
+  UserBuilder,
+} from "@a2a-js/sdk/server/express";
+import {
+  loadStudioToml,
+  type TomlTable,
+} from "@bnbagent/studio-runtime/config";
+import {
+  ensureAltanaSessionLoaded,
+  ensureKeystoreMaterialized,
+  ensureTwakMaterialized,
+  getWallet,
+} from "@bnbagent/studio-runtime/wallet";
+import {
+  createEnvelopeMiddleware,
+  X402_SELL_PATH,
+  type X402HttpRequest,
+  type X402RunWork,
+  X402Seller,
+} from "@bnbagent/studio-runtime/x402";
+import { generateText, stepCountIs } from "ai";
+import express from "express";
+import { buildAgentCard } from "./agentCard.js";
+import { SellerAgentExecutor } from "./executor.js";
+import { buildModel } from "./model.js";
+import type { RunWork } from "./sellerCore.js";
+import { LLM_READ_TOOLS } from "./tools.js";
+
+const APP_NAME = "agent";
+
+/**
+ * Deliverable `generator` label: this seller's own name, read from
+ * studio.toml `[project].name` (minus the `-agent` suffix) so each delivered
+ * manifest is self-identifying. Best-effort — falls back to `APP_NAME` if
+ * the config can't be read.
+ */
+function generatorTag(): string {
+  let name = "";
+  try {
+    const cfg = loadStudioToml();
+    name = String(((cfg.project ?? {}) as Record<string, unknown>).name ?? "");
+  } catch {
+    // a metadata label must never break delivery
+    return APP_NAME;
+  }
+  return name.endsWith("-agent")
+    ? name.slice(0, -"-agent".length)
+    : name || APP_NAME;
+}
+
+// ── Runtime secrets ───────────────────────────────────────────────────────────
+// Keep plaintext secrets OUT of agentcore.json. When BNBAGENT_RUNTIME_SECRET_ID
+// is set (deployed AgentCore runtime), pull a JSON {ENV_NAME: value} blob from
+// AWS Secrets Manager into the process env BEFORE anything reads it (keystore
+// unlock, provider key, buildModel, Cognito OAuth env). No-op locally (where
+// .env.local already populated the environment) and on Azure Foundry (where
+// the CustomKeys connection injects the variables before the process starts).
+// In a deployed AgentCore runtime the managed secret bundle is authoritative
+// and replaces any stale spec-level value left by an earlier runtime revision.
+async function loadRuntimeSecrets(): Promise<void> {
+  const secretId = process.env.BNBAGENT_RUNTIME_SECRET_ID;
+  if (!secretId) {
+    return;
+  }
+  const resp = await new SecretsManagerClient({}).send(
+    new GetSecretValueCommand({ SecretId: secretId }),
+  );
+  const bundle = JSON.parse(resp.SecretString ?? "{}") as Record<
+    string,
+    unknown
+  >;
+  for (const [key, value] of Object.entries(bundle)) {
+    process.env[key] = String(value);
+  }
+  const pieverseKey = process.env.PIEVERSE_LLM_API_KEY;
+  if (pieverseKey) {
+    const fingerprint = createHash("sha256")
+      .update(pieverseKey, "utf-8")
+      .digest("hex")
+      .slice(0, 12);
+    console.info(
+      `[runtime-secrets] PIEVERSE_LLM_API_KEY source=secretsmanager sha256=${fingerprint}…`,
+    );
+  }
+}
+
+/** studio.toml `[network].default` (best-effort; used by the funded sweep). */
+function defaultNetwork(): string {
+  try {
+    const cfg = loadStudioToml();
+    return String(
+      ((cfg.network ?? {}) as Record<string, unknown>).default ?? "bsc-testnet",
+    );
+  } catch {
+    return "bsc-testnet";
+  }
+}
+
+// ── One-shot LLM helper (the executor's delivery work hook) ──────────────────
+// LLM credit auto-renew (Pieverse path): `buildModel()` (in model.ts) returns
+// a model wrapped with a middleware that auto-tops up the active Pieverse key
+// before each generate call when [llm.auto_renew] is enabled. That top-up is
+// the ONLY automatic signing path outside signing.ts — it is budget-gated and
+// is NOT an LLM tool. It rides transparently into the delivery step.
+//
+// The LLM runs only in an authorized value step: verified ERC-8183 delivery
+// or x402 work after its payment/free gate. `negotiate` is rule-based and
+// never touches the LLM. The read-only chain tools are
+// attached so the work can read on-chain context if it needs to — drop them
+// from `tools.ts` if your work doesn't read chain. Signing / settle are NEVER
+// tools — they are fixed code in signing.ts, triggered by the A2A skills,
+// never callable by the LLM. (The one deliberate exception: the x402-buyer
+// recipe's PAID fetch tools — see the `tools:` note below — the LLM picks the
+// URL, but who gets paid and the per-call/daily caps stay locked in
+// studio.toml.)
+export function buildRunWork(): RunWork {
+  // The model is resolved LAZILY on first delivery, not at boot: a seller
+  // with no provider key yet must still serve negotiate (which never calls
+  // the LLM) — missing-key errors surface at notify_funded delivery time.
+  let model: ReturnType<typeof buildModel> | undefined;
+  return async (prompt, { abortSignal }) => {
+    model ??= buildModel(); // managed model with the auto-renew hook (delivery only)
+    const result = await generateText({
+      model,
+      system:
+        "You are a seller agent. The runtime has already authorized this task " +
+        "through its configured commerce rail. Complete the user's task now; " +
+        "do not ask for a job ID or additional payment. " +
+        "Be concrete and concise. Use the read-only chain tools when on-chain " +
+        "context helps. If a paid-data tool such as `buy_with_x402` is available " +
+        "to you, USE IT to fetch the data a task needs — those merchants (e.g. " +
+        "CoinMarketCap) charge via on-chain wallet payment, NOT an API key; never " +
+        "reply that you cannot complete the task for lack of an API key.",
+      prompt,
+      // LLM_READ_TOOLS = read-only chain tools (wallet, balances,
+      // ERC-8004/8183 queries). Edit `tools.ts` to add/remove. These are
+      // READ-ONLY — the agent never signs via a tool; all signing is in
+      // signing.ts (fixed code).
+      // To let the agent BUY paid data at work time (e.g. CMC market data
+      // after `bag x402 trust cmc` + `bag recipe code x402-buyer`), spread
+      // the emitted tool set — payee + per-call/daily caps stay locked in
+      // studio.toml:
+      //   import { X402_BUYER_TOOLS } from "./x402Buyer.js";
+      //   tools: { ...LLM_READ_TOOLS, ...X402_BUYER_TOOLS },
+      tools: LLM_READ_TOOLS,
+      stopWhen: stepCountIs(8), // bounded tool-call loop, then final text
+      abortSignal,
+    });
+    return result.text.trim();
+  };
+}
+
+function hasErc8183Rail(cfg: TomlTable): boolean {
+  const payments = asTable(cfg.payments);
+  return asTable(payments?.erc8183) !== null;
+}
+
+function asTable(value: unknown): TomlTable | null {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    ? (value as TomlTable)
+    : null;
+}
+
+function flatHeaders(
+  headers: Record<string, string | string[] | undefined>,
+): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const [name, value] of Object.entries(headers)) {
+    if (typeof value === "string") out[name] = value;
+    else if (value !== undefined) out[name] = value[0] ?? "";
+  }
+  return out;
+}
+
+function flatQuery(query: Record<string, unknown>): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const [name, value] of Object.entries(query)) {
+    if (typeof value === "string") out[name] = value;
+  }
+  return out;
+}
+
+function x402Work(runWork: RunWork): X402RunWork {
+  return ({ prompt }) => runWork(prompt, { sessionId: "x402" });
+}
+
+// ── Foundry text-carrier adapters ────────────────────────────────────────────
+
+/**
+ * The skill-router shim routing Foundry invocations to seller skills.
+ *
+ * Foundry's pass-through host receives a JSON body whose `input` is the
+ * serialized skill envelope. We parse that text and dispatch it
+ * DETERMINISTICALLY through `SellerAgentExecutor.dispatch` (signing.ts fixed
+ * code; LLM only inside the notify_funded background work). The result is
+ * serialised back to text. A non-envelope message returns the same "unknown
+ * skill" reply the @a2a-js path gives — there is no free-form chat skill.
+ */
+export class SkillRouter {
+  readonly name: string;
+  readonly description =
+    "ERC-8183 seller agent (negotiate + notify_funded) over A2A.";
+  private readonly executor: SellerAgentExecutor;
+
+  constructor(executor: SellerAgentExecutor, opts: { name?: string } = {}) {
+    this.executor = executor;
+    this.name = opts.name ?? "seller_agent";
+  }
+
+  /** Route one inbound text turn to the seller skills; returns JSON text. */
+  async run(text: string | null | undefined): Promise<string> {
+    const envelope = extractEnvelope(text);
+    const result =
+      envelope === null
+        ? {
+            error:
+              'expected a JSON skill envelope, e.g. {"skill": "negotiate", ...}',
+            skills: ["negotiate", "notify_funded"],
+          }
+        : await this.executor.dispatch(envelope);
+    return JSON.stringify(result);
+  }
+}
+
+/**
+ * Parse inbound user text into a `{"skill": ...}` dict, or null.
+ *
+ * Foundry's incoming A2A is text-modality only, so the buyer sends the skill
+ * envelope as a JSON string. Non-JSON / non-object text → null (the caller
+ * replies with a deterministic "unknown skill").
+ */
+export function extractEnvelope(
+  text: string | null | undefined,
+): Record<string, unknown> | null {
+  if (!text) {
+    return null;
+  }
+  let obj: unknown;
+  try {
+    obj = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  return obj !== null && typeof obj === "object" && !Array.isArray(obj)
+    ? (obj as Record<string, unknown>)
+    : null;
+}
+
+/** Extract the latest text turn from an OpenAI Responses request. Foundry's
+ * incoming A2A adapter is text-only and projects the caller message here. */
+export function responsesInputText(input: unknown): string | null {
+  if (typeof input === "string") {
+    return input;
+  }
+  if (!Array.isArray(input)) {
+    return null;
+  }
+  const texts: string[] = [];
+  for (const item of input) {
+    if (typeof item === "string") {
+      texts.push(item);
+      continue;
+    }
+    if (!item || typeof item !== "object") {
+      continue;
+    }
+    const content = (item as Record<string, unknown>).content;
+    if (typeof content === "string") {
+      texts.push(content);
+      continue;
+    }
+    if (!Array.isArray(content)) {
+      continue;
+    }
+    for (const part of content) {
+      if (part && typeof part === "object") {
+        const text = (part as Record<string, unknown>).text;
+        if (typeof text === "string") texts.push(text);
+      }
+    }
+  }
+  return texts.at(-1) ?? null;
+}
+
+function responseId(prefix: string): string {
+  return `${prefix}_${randomUUID().replaceAll("-", "")}`;
+}
+
+function responseEnvelope(text: string, model: string) {
+  const responseIdValue = responseId("resp");
+  const messageId = responseId("msg");
+  const part = { type: "output_text", annotations: [], logprobs: [], text };
+  const item = {
+    id: messageId,
+    type: "message",
+    status: "completed",
+    role: "assistant",
+    content: [part],
+  };
+  return {
+    id: responseIdValue,
+    object: "response",
+    created_at: Math.floor(Date.now() / 1000),
+    status: "completed",
+    error: null,
+    incomplete_details: null,
+    instructions: null,
+    max_output_tokens: null,
+    model,
+    output: [item],
+    output_text: text,
+    parallel_tool_calls: true,
+    previous_response_id: null,
+    reasoning: { effort: null, summary: null },
+    store: true,
+    temperature: 1,
+    text: { format: { type: "text" } },
+    tool_choice: "auto",
+    tools: [],
+    top_p: 1,
+    truncation: "disabled",
+    usage: {
+      input_tokens: 0,
+      input_tokens_details: { cached_tokens: 0 },
+      output_tokens: 0,
+      output_tokens_details: { reasoning_tokens: 0 },
+      total_tokens: 0,
+    },
+    metadata: {},
+  };
+}
+
+function sendStreamingResponse(
+  res: express.Response,
+  response: ReturnType<typeof responseEnvelope>,
+): void {
+  const item = response.output[0];
+  const part = item.content[0];
+  const events = [
+    { type: "response.created", sequence_number: 0, response: { ...response, status: "in_progress", output: [] } },
+    { type: "response.output_item.added", sequence_number: 1, output_index: 0, item: { ...item, status: "in_progress", content: [] } },
+    { type: "response.content_part.added", sequence_number: 2, output_index: 0, item_id: item.id, content_index: 0, part: { ...part, text: "" } },
+    { type: "response.output_text.delta", sequence_number: 3, output_index: 0, item_id: item.id, content_index: 0, delta: part.text },
+    { type: "response.output_text.done", sequence_number: 4, output_index: 0, item_id: item.id, content_index: 0, text: part.text },
+    { type: "response.content_part.done", sequence_number: 5, output_index: 0, item_id: item.id, content_index: 0, part },
+    { type: "response.output_item.done", sequence_number: 6, output_index: 0, item },
+    { type: "response.completed", sequence_number: 7, response },
+  ];
+  res.status(200);
+  res.setHeader("content-type", "text/event-stream");
+  res.setHeader("cache-control", "no-cache");
+  for (const event of events) {
+    res.write(`event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`);
+  }
+  res.end("data: [DONE]\n\n");
+}
+
+// ── serving ───────────────────────────────────────────────────────────────────
+
+async function main(): Promise<void> {
+  await loadRuntimeSecrets();
+
+  // Wallet material is NEVER bundled into the deploy artifact. `bag deploy`
+  // injects it via the runtime secret channel (Secrets Manager bundle on
+  // AgentCore, CustomKeys env on Foundry) and these calls (run once at cold
+  // start, before any signing) materialize it on disk. Each is a no-op for
+  // the other wallet kind and locally, where the wallet already lives on
+  // disk:
+  //  - evm-local: WALLET_KEYSTORE_JSON → keystore file (unlocked with WALLET_PASSWORD)
+  //  - twak:      TWAK_WALLET_JSON / TWAK_CREDENTIALS_JSON → $TMPDIR/twak-home/.twak
+  //               (exported as TWAK_HOME_DIR; twak reads TWAK_WALLET_PASSWORD itself)
+  ensureKeystoreMaterialized();
+  ensureTwakMaterialized();
+  await ensureAltanaSessionLoaded();
+
+  const cfg = loadStudioToml();
+  const rails = { erc8183: hasErc8183Rail(cfg) };
+  const host = process.env.AGENT_BIND_HOST || "0.0.0.0";
+  // Both hosted-agent contract ports are always bound (AgentCore A2A: 9000,
+  // Foundry invocations: 8088) so one image serves either cloud. AGENT_PORT
+  // (or PORT) prepends a primary override for local runs; the primary port
+  // must bind (fatal), the remaining contract ports are best-effort.
+  const override = Number(process.env.AGENT_PORT || process.env.PORT || "");
+  const ports = [
+    ...new Set([
+      ...(Number.isInteger(override) && override > 0 ? [override] : []),
+      9000,
+      8088,
+    ]),
+  ];
+  const port = ports[0] as number;
+  const runWork = buildRunWork();
+
+  // The executor backs the seller skills with signing.ts fixed code (NEVER an
+  // LLM tool). The SAME executor serves every carrier: @a2a-js JSON-RPC,
+  // Foundry invocations (SkillRouter), and Foundry Responses.
+  const executor = new SellerAgentExecutor({
+    runWork,
+    generator: generatorTag(),
+    network: defaultNetwork(),
+    commerceSkills: rails.erc8183,
+  });
+  const agentCard = buildAgentCard({ commerceSkills: rails.erc8183 });
+  const seller = await X402Seller.create({
+    cfg,
+    runWork: x402Work(runWork),
+    walletAddress: getWallet().address,
+    // The 402 challenge's resource URL must be the BUYER-facing address:
+    // BNBAGENT_PUBLIC_URL (the operator's gateway base URL, no /x402 suffix —
+    // synced with the runtime secrets; Foundry reserves the AGENT_*/FOUNDRY_*
+    // env namespaces, hence the BNBAGENT_ prefix; the legacy AGENT_PUBLIC_URL
+    // is still honored) or AgentCore's own runtime URL; never a hosted-agent
+    // invoke endpoint. Unset, the localhost fallback only suits local runs.
+    resourceUrl: `${
+      process.env.BNBAGENT_PUBLIC_URL ??
+      process.env.AGENT_PUBLIC_URL ??
+      process.env.AGENTCORE_RUNTIME_URL ??
+      `http://localhost:${port}`
+    }${X402_SELL_PATH}`,
+  });
+  const router = new SkillRouter(executor, { name: generatorTag() });
+
+  const handler = new DefaultRequestHandler(
+    agentCard,
+    new InMemoryTaskStore(),
+    executor,
+  );
+
+  const app = express();
+
+  // GET /ping status fed to AgentCore: HEALTHY_BUSY while a background
+  // delivery is in flight, else HEALTHY.
+  //
+  // notify_funded acks immediately and runs the slow work (LLM + on-chain
+  // submit) in the background. Reporting HEALTHY_BUSY tells AgentCore the
+  // runtime is still working, so the scale-to-zero runtime is NOT reaped on
+  // idle before delivery lands (bounded by the session max-lifetime; ≤8h).
+  app.get("/ping", (_req, res) => {
+    res.json({ status: executor.isBusy() ? "HEALTHY_BUSY" : "HEALTHY" });
+  });
+  // Required Foundry Hosted Agent health contract. The platform will not
+  // create a session or forward invocations until this returns HTTP 200.
+  app.get("/readiness", (_req, res) => {
+    res.json({ status: "READY" });
+  });
+
+  if (seller.state !== "disabled") {
+    app.all(
+      X402_SELL_PATH,
+      express.text({ type: "*/*", limit: "1mb" }),
+      async (req, res) => {
+        const request: X402HttpRequest = {
+          method: req.method,
+          path: req.path,
+          query: flatQuery(req.query),
+          headers: flatHeaders(req.headers),
+          body:
+            typeof req.body === "string"
+              ? req.body
+              : JSON.stringify(req.body ?? ""),
+        };
+        const out = await seller.handle(request);
+        res.status(out.status).set(out.headers).send(out.body);
+      },
+    );
+  }
+
+  app.use(express.json({ limit: "8mb" }));
+  app.use(createEnvelopeMiddleware({ port }));
+
+  // Foundry Invocations is a pass-through JSON contract. bnbagent-deploy's
+  // positional invoke helper normalizes text to {"input":"..."}; advanced
+  // callers may send the same shape directly.
+  app.post("/invocations", async (req, res) => {
+    const input = (req.body ?? {}) as Record<string, unknown>;
+    const text = typeof input.input === "string" ? input.input : null;
+    res.json({ output: await router.run(text) });
+  });
+  // The managed platform selects Foundry's Responses protocol so the agent
+  // can be exposed through incoming A2A. Keep this adapter small and
+  // deterministic: Foundry converts A2A text to Responses input, and the
+  // seller result becomes one assistant output_text item.
+  app.post("/responses", async (req, res) => {
+    const input = (req.body ?? {}) as Record<string, unknown>;
+    const output = await router.run(responsesInputText(input.input));
+    const response = responseEnvelope(
+      output,
+      typeof input.model === "string" ? input.model : APP_NAME,
+    );
+    if (input.stream === true) {
+      sendStreamingResponse(res, response);
+    } else {
+      res.json(response);
+    }
+  });
+
+  app.use(
+    "/.well-known/agent-card.json",
+    agentCardHandler({ agentCardProvider: handler }),
+  );
+  app.use(
+    jsonRpcHandler({
+      requestHandler: handler,
+      userBuilder: UserBuilder.noAuthentication,
+    }),
+  );
+
+  // Bind every port: the primary (first) port is fatal on failure; the
+  // remaining contract ports are best-effort so a local run does not die
+  // when the other cloud's contract port happens to be taken.
+  const servers = ports.map((p, i) => {
+    const server = app.listen(p, host, () => {
+      console.log(
+        `[seller-agent] serving on ${host}:${p}${i === 0 ? "" : " (secondary contract port)"} (x402: ${seller.state})`,
+      );
+    });
+    if (i > 0) {
+      server.on("error", (e) => {
+        console.warn(
+          `[seller-agent] secondary contract port ${p} unavailable: ${(e as Error).message}`,
+        );
+      });
+    }
+    return server;
+  });
+  process.once("SIGTERM", () => {
+    let open = servers.length;
+    for (const server of servers) {
+      server.close(() => {
+        open -= 1;
+        if (open === 0) process.exit(0);
+      });
+    }
+  });
+}
+
+// Run only as an entrypoint (`node unifiedMain.js` / the hosted runtime),
+// never on import — tests import the builders above without starting a
+// server.
+const isMain =
+  process.argv[1] !== undefined &&
+  import.meta.url === pathToFileURL(process.argv[1]).href;
+if (isMain) {
+  main().catch((e) => {
+    console.error("[seller-agent] fatal:", e);
+    process.exit(1);
+  });
+}

package/recipes/runtimes/agentcore/recipe.toml

@@ -1,6 +1,6 @@
 [recipe]
 name = "runtimes/agentcore"
-description = "Runtime adapter for AWS Bedrock AgentCore. A project selects one or more public faces on one runtime and signer: A2A emits main.ts, MCP emits mcpMain.ts, and A2A+MCP emits the A2A-native dualMain.ts plus mcpMain.ts as its MCP server library. X402 is an optional sibling route on whichever entrypoint is selected. The chain tools (tools.ts) + model factory (model.ts) are shared by every mode."
+description = "Runtime adapter for AWS Bedrock AgentCore. A project selects one or more public faces on one runtime and signer: A2A emits the cloud-portable unifiedMain.ts (also speaks Foundry invocations/responses), MCP emits mcpMain.ts, and A2A+MCP emits the A2A-native dualMain.ts plus mcpMain.ts as its MCP server library. X402 is an optional sibling route on whichever entrypoint is selected. The chain tools (tools.ts) + model factory (model.ts) are shared by every mode."
 status = "a2a|mcp|both"
 
 # Emits the AgentCore serving layer for the chosen protocol:
@@ -79,10 +79,10 @@ node = [
 default = "a2a-codezip"
 
 [modes.a2a-codezip]
-files = ["{{PKG}}/main.ts", "{{PKG}}/executor.ts", "{{PKG}}/sellerCore.ts", "{{PKG}}/agentCard.ts"]
+files = ["{{PKG}}/unifiedMain.ts", "{{PKG}}/executor.ts", "{{PKG}}/sellerCore.ts", "{{PKG}}/agentCard.ts"]
 
 [modes.a2a-container]
-files = ["{{PKG}}/main.ts", "{{PKG}}/executor.ts", "{{PKG}}/sellerCore.ts", "{{PKG}}/agentCard.ts", "{{PKG}}/Dockerfile", "{{PKG}}/.dockerignore"]
+files = ["{{PKG}}/unifiedMain.ts", "{{PKG}}/executor.ts", "{{PKG}}/sellerCore.ts", "{{PKG}}/agentCard.ts", "{{PKG}}/Dockerfile", "{{PKG}}/.dockerignore"]
 
 [modes.mcp-codezip]
 files = ["{{PKG}}/mcpMain.ts"]