@bnbagent/studio-cli 0.0.13 → 0.0.14-alpha.2

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

@@ -30,6 +30,7 @@ import * as cr from "@bnbagent/studio-runtime/tools";
 import { loadStudioToml } from "@bnbagent/studio-runtime/config";
 import { tool, type ToolSet } from "ai";
 import { z } from "zod";
+import { READ_TOOL_CATALOG } from "./readToolCatalog.js";
 
 /**
  * The project-wide default network (`[network].default`) — tool calls that
@@ -46,51 +47,34 @@ function defaultNetwork(): string {
   }
 }
 
-const networkArg = z
-  .string()
-  .optional()
-  .describe("studio network name (defaults to the project's [network].default)");
-
 export const LLM_READ_TOOLS: ToolSet = {
   // --- Wallet & chain basics ---
   wallet_info: tool({
-    description:
-      "Describe the agent's active wallet (address, kind, key location).",
-    inputSchema: z.object({}),
+    description: READ_TOOL_CATALOG.wallet_info.description,
+    inputSchema: z.object(READ_TOOL_CATALOG.wallet_info.inputSchema),
     execute: async () => cr.walletInfo(),
   }),
   balance_native: tool({
-    description:
-      "Native BNB balance of an address (defaults to the agent's own wallet).",
-    inputSchema: z.object({
-      address: z.string().optional().describe("0x address; omit for own wallet"),
-      network: networkArg,
-    }),
+    description: READ_TOOL_CATALOG.balance_native.description,
+    inputSchema: z.object(READ_TOOL_CATALOG.balance_native.inputSchema),
     execute: async ({ address, network }) =>
       cr.balanceNative(address ?? null, network ?? defaultNetwork()),
   }),
   balance_u: tool({
     // requires [u_token] in studio.toml
-    description:
-      "$U (payment token) balance of an address (defaults to the agent's own wallet).",
-    inputSchema: z.object({
-      address: z.string().optional().describe("0x address; omit for own wallet"),
-      network: networkArg,
-    }),
+    description: READ_TOOL_CATALOG.balance_u.description,
+    inputSchema: z.object(READ_TOOL_CATALOG.balance_u.inputSchema),
     execute: async ({ address, network }) =>
       cr.balanceU(address ?? null, network ?? defaultNetwork()),
   }),
   network_info: tool({
-    description: "Chain id / RPC / token info for a studio network.",
-    inputSchema: z.object({ network: networkArg }),
+    description: READ_TOOL_CATALOG.network_info.description,
+    inputSchema: z.object(READ_TOOL_CATALOG.network_info.inputSchema),
     execute: async ({ network }) => cr.networkInfo(network ?? defaultNetwork()),
   }),
   tx_status: tool({
-    description: "Status + receipt summary of a transaction hash.",
-    inputSchema: z.object({
-      tx_hash: z.string().describe("0x transaction hash"),
-      network: networkArg,
-    }),
+    description: READ_TOOL_CATALOG.tx_status.description,
+    inputSchema: z.object(READ_TOOL_CATALOG.tx_status.inputSchema),
     execute: async ({ tx_hash, network }) =>
       cr.txStatus(tx_hash, network ?? defaultNetwork()),
   }),
@@ -106,21 +90,15 @@ export const LLM_READ_TOOLS: ToolSet = {
   // --- ERC-8004 identity (read-only lookups the LLM may want for context) ---
   agent_info: tool({
     // requires [erc8004] in studio.toml
-    description: "ERC-8004 identity record for an agent id.",
-    inputSchema: z.object({
-      agent_id: z.number().int().describe("ERC-8004 agent id"),
-      network: networkArg,
-    }),
+    description: READ_TOOL_CATALOG.agent_info.description,
+    inputSchema: z.object(READ_TOOL_CATALOG.agent_info.inputSchema),
     execute: async ({ agent_id, network }) =>
       cr.agentInfo(agent_id, network ?? defaultNetwork()),
   }),
   agent_by_address: tool({
     // requires [erc8004] in studio.toml
-    description: "Look up an ERC-8004 agent registration by wallet address.",
-    inputSchema: z.object({
-      address: z.string().describe("0x wallet address"),
-      network: networkArg,
-    }),
+    description: READ_TOOL_CATALOG.agent_by_address.description,
+    inputSchema: z.object(READ_TOOL_CATALOG.agent_by_address.inputSchema),
     execute: async ({ address, network }) =>
       cr.agentByAddress(address, network ?? defaultNetwork()),
   }),
@@ -128,22 +106,15 @@ export const LLM_READ_TOOLS: ToolSet = {
   // --- ERC-8183 jobs (READ-ONLY status/list — writes live in signing.ts) ---
   job_status: tool({
     // requires [erc8183] in studio.toml
-    description: "Read-only ERC-8183 job summary (status, budget, deliverable URL).",
-    inputSchema: z.object({
-      job_id: z.number().int().describe("on-chain job id"),
-      network: networkArg,
-    }),
+    description: READ_TOOL_CATALOG.job_status.description,
+    inputSchema: z.object(READ_TOOL_CATALOG.job_status.inputSchema),
     execute: async ({ job_id, network }) =>
       cr.jobStatus(job_id, network ?? defaultNetwork()),
   }),
   job_list: tool({
     // requires [erc8183] in studio.toml
-    description: "List recent ERC-8183 jobs (optionally only this agent's).",
-    inputSchema: z.object({
-      limit: z.number().int().optional(),
-      mine: z.boolean().optional().describe("only jobs assigned to this agent"),
-      network: networkArg,
-    }),
+    description: READ_TOOL_CATALOG.job_list.description,
+    inputSchema: z.object(READ_TOOL_CATALOG.job_list.inputSchema),
     execute: async ({ limit, mine, network }) =>
       cr.jobList({ limit, mine, network: network ?? defaultNetwork() }),
   }),

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

@@ -225,7 +225,8 @@ export function buildRunWork(): RunWork {
 
 function hasErc8183Rail(cfg: TomlTable): boolean {
   const payments = asTable(cfg.payments);
-  return asTable(payments?.erc8183) !== null;
+  const rail = asTable(payments?.erc8183);
+  return rail !== null && rail.enabled !== false;
 }
 
 function asTable(value: unknown): TomlTable | null {

package/recipes/runtimes/agentcore/recipe.toml

@@ -32,7 +32,7 @@ node = [
     # BNBAGENT_RUNTIME_SECRET_ID is set (default secretsmanager mode + platform).
     "@aws-sdk/client-secrets-manager@^3.600.0",
     "@bnbagent/studio-runtime",
-    "@bnbagent/sdk@0.5.5",
+    "@bnbagent/sdk@0.5.6",
     # The LLM work hook (generateText + tools) and the model factory.
     "ai@^7.0.29",
     # Tool input schemas (AI SDK tools + MCP registerTool).

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

@@ -60,6 +60,7 @@ import {
   loadStudioToml,
   type TomlTable,
 } from "@bnbagent/studio-runtime/config";
+import { maskUrlSecrets } from "@bnbagent/studio-runtime/audit";
 import * as cr from "@bnbagent/studio-runtime/tools";
 import {
   ensureAltanaSessionLoaded,
@@ -84,13 +85,31 @@ import {
   limitCommerceOperation,
   requestLimitContext,
 } from "./requestLimits.js";
+import {
+  DeliveryTimeoutError,
+  deliveryTimeoutSeconds,
+  minimumDeliveryWindowSeconds,
+  withTimeout,
+} from "./deliveryPolicy.js";
 import * as signing from "./signing.js";
+import { READ_TOOL_CATALOG, type ReadToolName } from "./readToolCatalog.js";
 
 const APP_NAME = "agent";
+function safeLogText(value: unknown): string {
+  const text =
+    value instanceof Error
+      ? (value.stack ?? `${value.name}: ${value.message}`)
+      : String(value ?? "");
+  return maskUrlSecrets(text);
+}
+
 const log = {
-  info: (msg: string) => console.log(`[seller-agent.mcp] ${msg}`),
+  info: (msg: string) => console.log(`[seller-agent.mcp] ${safeLogText(msg)}`),
   error: (msg: string, e?: unknown) =>
-    console.error(`[seller-agent.mcp] ERROR ${msg}`, e ?? ""),
+    console.error(
+      `[seller-agent.mcp] ERROR ${safeLogText(msg)}`,
+      safeLogText(e),
+    ),
 };
 
 function protocolFailure(scope: string, error: unknown): never {
@@ -166,7 +185,8 @@ function generatorTag(): string {
 
 function hasErc8183Rail(cfg: TomlTable): boolean {
   const payments = asTable(cfg.payments);
-  return asTable(payments?.erc8183) !== null;
+  const rail = asTable(payments?.erc8183);
+  return rail !== null && rail.enabled !== false;
 }
 
 function asTable(value: unknown): TomlTable | null {
@@ -198,39 +218,46 @@ function flatQuery(query: Record<string, unknown>): Record<string, string> {
 // Deferred construction keeps negotiate and unpaid payment challenge paths from
 // building the model, and keeps this module importable without the provider
 // env until a deliverable is actually produced.
-type RunLlm = (prompt: string) => Promise<string>;
-let cachedRunLlm: RunLlm | null = null;
-
-async function runLlm(prompt: string): Promise<string> {
-  if (cachedRunLlm === null) {
-    const { buildModel } = await import("./model.js");
-    const { LLM_READ_TOOLS } = await import("./tools.js");
-    const model = buildModel(); // managed model w/ budget-gated LLM-credit auto-renew
-    cachedRunLlm = async (p: string) => {
-      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: p,
-        // READ-ONLY chain tools; signing is never an LLM tool. To add
-        // PAID x402 fetch tools (bag x402 trust + x402-buyer recipe):
-        //   import { X402_BUYER_TOOLS } from "./x402Buyer.js";
-        //   tools: { ...LLM_READ_TOOLS, ...X402_BUYER_TOOLS },
-        tools: LLM_READ_TOOLS,
-        stopWhen: stepCountIs(8),
-      });
-      return result.text.trim();
-    };
-  }
-  return cachedRunLlm(prompt);
+export type McpRunWork = (
+  prompt: string,
+  context: { sessionId: string; abortSignal?: AbortSignal },
+) => Promise<string>;
+
+/** The MCP delivery hook. Replace this builder for protocol-only projects. */
+export function buildRunWork(): McpRunWork {
+  let run: McpRunWork | null = null;
+  return async (prompt, context) => {
+    if (run === null) {
+      const { buildModel } = await import("./model.js");
+      const { LLM_READ_TOOLS } = await import("./tools.js");
+      const model = buildModel(); // managed model w/ budget-gated LLM-credit auto-renew
+      run = async (p, { abortSignal: signal }) => {
+        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: p,
+          // READ-ONLY chain tools; signing is never an LLM tool. To add
+          // PAID x402 fetch tools (bag x402 trust + x402-buyer recipe):
+          //   import { X402_BUYER_TOOLS } from "./x402Buyer.js";
+          //   tools: { ...LLM_READ_TOOLS, ...X402_BUYER_TOOLS },
+          tools: LLM_READ_TOOLS,
+          stopWhen: stepCountIs(8),
+          abortSignal: signal,
+        });
+        return result.text.trim();
+      };
+    }
+    return run(prompt, context);
+  };
 }
 
 // ── MCP server ────────────────────────────────────────────────────────────────
@@ -282,9 +309,10 @@ async function reportProgress(
 
 /** Build the seller MCP server, gating commerce tools on the ERC-8183 rail. */
 export function buildMcpServer(
-  opts: { commerceSkills?: boolean } = {},
+  opts: { commerceSkills?: boolean; runWork?: McpRunWork } = {},
 ): McpServer {
   const server = new McpServer({ name: "bnbagent-seller", version: "1.0.0" });
+  const runWork = opts.runWork ?? buildRunWork();
 
   // ── Commerce tools (signing is FIXED code in signing.ts) ──────────────────
   if (opts.commerceSkills !== false) {
@@ -366,6 +394,8 @@ export function buildMcpServer(
         });
       }
 
+      const deadlineMs = Date.now() + deliveryTimeoutSeconds() * 1000;
+
       // 1/4 — verify the funded job carries THIS agent's signed quote
       // (eth_calls). Honour the `permanent` flag: a permanent failure is
       // terminal ("rejected"); a transient one (chain read hiccup) is
@@ -373,7 +403,10 @@ export function buildMcpServer(
       await reportProgress(extra, 1, 4);
       let verdict: { ok: boolean; reason: string; permanent: boolean };
       try {
-        verdict = await signing.verifySignedJob(jid);
+        verdict = await withTimeout(
+          signing.verifySignedJob(jid, minimumDeliveryWindowSeconds()),
+          Math.max(0.001, (deadlineMs - Date.now()) / 1000),
+        );
       } catch (e) {
         // a failed verify is transient; tell the buyer to retry
         log.error(`verify of job ${jid} failed`, e);
@@ -393,37 +426,68 @@ export function buildMcpServer(
         });
       }
 
-      // 2/4 — produce the deliverable (THE ONLY LLM CALL; specialise the
-      // prompt here)
-      await reportProgress(extra, 2, 4);
-      let work: string;
-      try {
-        const spec = await signing.jobSpec(jid);
-        const task =
-          spec !== null
-            ? JSON.stringify({ task: spec.task, terms: spec.terms })
-            : `job ${jid}`;
-        const prompt =
-          "You accepted and were paid for the following job. Produce the deliverable " +
-          `now. Be complete and self-contained.\n\nJOB CONTEXT:\n${task}`;
-        work = await runLlm(prompt);
-      } catch (e) {
-        return protocolFailure(`delivery preparation for job ${jid} failed`, e);
-      }
-      // Unexpected LLM/RPC faults are logged in full, then surfaced through
-      // MCP's isError channel with a generic public message. Only the
-      // deterministic SubmitPermanentlyUnsupportedError is a classified
-      // "rejected" business result.
-      // 3/4 — sign + broadcast the on-chain submit (re-verifies FUNDED inside)
-      await reportProgress(extra, 3, 4);
+      // Bound only the cancellable work phase. Once submit starts, its
+      // broadcast outcome can be ambiguous: the request still has a total
+      // deadline, but a submit timeout is UNKNOWN and must be reconciled on
+      // chain rather than reported as safe to retry.
+      const controller = new AbortController();
+      let submitStarted = false;
       let res: { submitTx: string; deliverableUrl: string | null };
       try {
-        res = await signing.submitResult(jid, work, {
-          job_id: jid,
-          generator: generatorTag(),
-          built_with: "https://github.com/bnb-chain/bnbagent-studio",
-        });
+        const work = await withTimeout(
+          (async () => {
+            // 2/4 — produce the deliverable (THE ONLY LLM CALL).
+            await reportProgress(extra, 2, 4);
+            const spec = await signing.jobSpec(jid);
+            const task =
+              spec !== null
+                ? JSON.stringify({ task: spec.task, terms: spec.terms })
+                : `job ${jid}`;
+            const prompt =
+              "You accepted and were paid for the following job. Produce the deliverable " +
+              `now. Be complete and self-contained.\n\nJOB CONTEXT:\n${task}`;
+            return runWork(prompt, {
+              sessionId: String(jid),
+              abortSignal: controller.signal,
+            });
+          })(),
+          Math.max(0.001, (deadlineMs - Date.now()) / 1000),
+          controller,
+        );
+
+        // 3/4 — sign + broadcast submit (re-verifies FUNDED inside). Await
+        // the definitive result within the remaining request window. The
+        // opaque SDK operation cannot be cancelled after broadcast.
+        await reportProgress(extra, 3, 4);
+        const remainingSeconds = (deadlineMs - Date.now()) / 1000;
+        if (remainingSeconds <= 0) {
+          throw new DeliveryTimeoutError("delivery deadline reached");
+        }
+        submitStarted = true;
+        res = await withTimeout(
+          signing.submitResult(jid, work, {
+            job_id: jid,
+            generator: generatorTag(),
+            built_with: "https://github.com/bnb-chain/bnbagent-studio",
+          }),
+          remainingSeconds,
+        );
       } catch (e) {
+        if (e instanceof DeliveryTimeoutError) {
+          if (submitStarted) {
+            return toolResult({
+              status: "unknown",
+              job_id: jid,
+              reason:
+                "submit outcome is unknown; poll the job on-chain and do not retry until reconciled",
+            });
+          }
+          return toolResult({
+            status: "retry",
+            job_id: jid,
+            reason: `delivery timed out after ${deliveryTimeoutSeconds()}s`,
+          });
+        }
         if (
           e instanceof Error &&
           e.name === "SubmitPermanentlyUnsupportedError"
@@ -436,7 +500,7 @@ export function buildMcpServer(
             reason: "seller wallet does not support result submission",
           });
         }
-        return protocolFailure(`submit of job ${jid} failed`, e);
+        return protocolFailure(`delivery of job ${jid} failed`, e);
       }
 
       // 4/4 — done
@@ -452,95 +516,76 @@ export function buildMcpServer(
   }
 
   // ── Read-only chain tools ──────────────────────────────────────────────────
-  const network = z.string().optional().describe("studio network name");
-  const roConfig = (description: string, inputSchema: z.ZodRawShape) => ({
-    description,
-    inputSchema,
+  const roConfig = <Name extends ReadToolName>(name: Name) => ({
+    description: READ_TOOL_CATALOG[name].description,
+    inputSchema: READ_TOOL_CATALOG[name].inputSchema,
     annotations: READONLY_ANNOTATIONS,
   });
+  type ReadArgs<Name extends ReadToolName> = z.infer<
+    z.ZodObject<(typeof READ_TOOL_CATALOG)[Name]["inputSchema"]>
+  >;
 
   server.registerTool(
     "wallet_info",
-    roConfig("Active wallet summary.", {}),
+    roConfig("wallet_info"),
     async () => toolResult(await cr.walletInfo()),
   );
   server.registerTool(
     "wallet_list",
-    roConfig("All local wallet addresses.", {}),
+    roConfig("wallet_list"),
     async () => toolResult(await cr.walletList()),
   );
   server.registerTool(
     "wallet_address",
-    roConfig("The active wallet address.", {}),
+    roConfig("wallet_address"),
     async () => toolResult({ address: await cr.walletAddress() }),
   );
   server.registerTool(
     "balance_native",
-    roConfig("Native BNB balance (defaults to own wallet).", {
-      address: z.string().optional(),
-      network,
-    }),
-    async (a) =>
+    roConfig("balance_native"),
+    async (a: ReadArgs<"balance_native">) =>
       toolResult(
         await cr.balanceNative(a.address ?? null, a.network ?? defaultNetwork()),
       ),
   );
   server.registerTool(
     "balance_u",
-    roConfig("$U payment-token balance (defaults to own wallet).", {
-      address: z.string().optional(),
-      network,
-    }),
-    async (a) =>
+    roConfig("balance_u"),
+    async (a: ReadArgs<"balance_u">) =>
       toolResult(
         await cr.balanceU(a.address ?? null, a.network ?? defaultNetwork()),
       ),
   );
   server.registerTool(
     "pieverse_usage",
-    roConfig(
-      "Pieverse LLM usage/credit summary (SIWE personal_sign; no on-chain effect).",
-      { days: z.number().int().optional() },
-    ),
-    async (a) => toolResult(await cr.pieverseUsage(a.days ?? 7)),
+    roConfig("pieverse_usage"),
+    async (a: ReadArgs<"pieverse_usage">) =>
+      toolResult(await cr.pieverseUsage(a.days ?? 7)),
   );
   server.registerTool(
     "agent_info",
-    roConfig("ERC-8004 identity record for an agent id.", {
-      agent_id: z.number().int(),
-      network,
-    }),
-    async (a) =>
+    roConfig("agent_info"),
+    async (a: ReadArgs<"agent_info">) =>
       toolResult(await cr.agentInfo(a.agent_id, a.network ?? defaultNetwork())),
   );
   server.registerTool(
     "agent_by_address",
-    roConfig("ERC-8004 registration lookup by wallet address.", {
-      address: z.string(),
-      network,
-    }),
-    async (a) =>
+    roConfig("agent_by_address"),
+    async (a: ReadArgs<"agent_by_address">) =>
       toolResult(
         await cr.agentByAddress(a.address, a.network ?? defaultNetwork()),
       ),
   );
   server.registerTool(
     "job_status",
-    roConfig("Read-only ERC-8183 job summary.", {
-      job_id: z.number().int(),
-      network,
-    }),
-    async (a) =>
+    roConfig("job_status"),
+    async (a: ReadArgs<"job_status">) =>
       toolResult(await cr.jobStatus(a.job_id, a.network ?? defaultNetwork())),
   );
   server.registerTool(
     "job_list",
-    roConfig("List recent ERC-8183 jobs.", {
-      limit: z.number().int().optional(),
-      mine: z.boolean().optional(),
-      network,
-    }),
-    async (a) =>
+    roConfig("job_list"),
+    async (a: ReadArgs<"job_list">) =>
       toolResult(
         await cr.jobList({
           limit: a.limit,
@@ -551,39 +596,28 @@ export function buildMcpServer(
   );
   server.registerTool(
     "job_count",
-    roConfig("Network-wide in-flight ERC-8183 job count.", { network }),
-    async (a) => toolResult(await cr.jobCount(a.network ?? defaultNetwork())),
+    roConfig("job_count"),
+    async (a: ReadArgs<"job_count">) =>
+      toolResult(await cr.jobCount(a.network ?? defaultNetwork())),
   );
   server.registerTool(
     "tx_status",
-    roConfig("Transaction status + receipt summary.", {
-      tx_hash: z.string(),
-      network,
-    }),
-    async (a) =>
+    roConfig("tx_status"),
+    async (a: ReadArgs<"tx_status">) =>
       toolResult(await cr.txStatus(a.tx_hash, a.network ?? defaultNetwork())),
   );
   server.registerTool(
     "block_info",
-    roConfig(
-      'Block header summary ("latest"/"earliest"/"pending", decimal, or 0x hash).',
-      { block: z.string().optional(), network },
-    ),
-    async (a) =>
+    roConfig("block_info"),
+    async (a: ReadArgs<"block_info">) =>
       toolResult(
         await cr.blockInfo(a.block ?? "latest", a.network ?? defaultNetwork()),
       ),
   );
   server.registerTool(
     "contract_call_view",
-    roConfig("Call a read-only (view) contract function by signature.", {
-      address: z.string(),
-      function_signature: z.string(),
-      args: z.array(z.unknown()).optional(),
-      output_types: z.array(z.string()).optional(),
-      network,
-    }),
-    async (a) =>
+    roConfig("contract_call_view"),
+    async (a: ReadArgs<"contract_call_view">) =>
       toolResult(
         await cr.contractCallView(
           a.address,
@@ -596,8 +630,9 @@ export function buildMcpServer(
   );
   server.registerTool(
     "network_info",
-    roConfig("Chain id / RPC / token info for a studio network.", { network }),
-    async (a) => toolResult(await cr.networkInfo(a.network ?? defaultNetwork())),
+    roConfig("network_info"),
+    async (a: ReadArgs<"network_info">) =>
+      toolResult(await cr.networkInfo(a.network ?? defaultNetwork())),
   );
 
   return server;
@@ -628,9 +663,10 @@ async function main(): Promise<void> {
   const sellPath = b402SellPath(cfg);
   const host = process.env.AGENT_BIND_HOST || "0.0.0.0";
   const port = Number(process.env.AGENT_PORT || "8000");
+  const runWork = buildRunWork();
   const seller = await B402Seller.create({
     cfg,
-    runWork: ({ prompt }) => runLlm(prompt),
+    runWork: ({ prompt }) => runWork(prompt, { sessionId: "b402" }),
     walletAddress: getWallet().address,
     resourceUrl: `${
       process.env.AGENTCORE_RUNTIME_URL ?? `http://localhost:${port}`
@@ -690,7 +726,10 @@ async function main(): Promise<void> {
           delete transports[t.sessionId];
         }
       };
-      await buildMcpServer({ commerceSkills: rails.erc8183 }).connect(t);
+      await buildMcpServer({
+        commerceSkills: rails.erc8183,
+        runWork,
+      }).connect(t);
       transport = t;
     }
     await transport.handleRequest(req, res, req.body);

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

@@ -57,6 +57,13 @@ import {
 export function buildModel(): LanguageModel {
   const cfg = loadStudioToml();
   const llmCfg = (cfg.llm ?? {}) as TomlTable;
+  if (String(llmCfg.provider ?? "openrouter") === "none") {
+    throw new Error(
+      "Protocol-only scaffold: no LLM provider is configured. " +
+        "Implement the generated work hook before accepting funded jobs, " +
+        "or set [llm].provider and [llm].model in studio.toml.",
+    );
+  }
   const inner = resolveModel(llmCfg);
 
   if (String(llmCfg.provider ?? "openrouter") !== "pieverse-llm") {