@bnbagent/studio-cli 0.0.8 → 0.0.9

package/dist/bag.js

@@ -44,7 +44,7 @@ import {
   x402SellerIsFree,
   x402SellerPricingState,
   x402SellerUsesB402
-} from "./chunk-ODCZKKZJ.js";
+} from "./chunk-YFEM4564.js";
 import {
   TWAK_CLI_MIN_VERSION,
   TWAK_CLI_VERSION,
@@ -222,7 +222,7 @@ import {
 var CAMPAIGN_DOC_URL = "https://www.bnbchain.org/en/blog/bnb-agent-studio-is-live-on-bnb-chain-ai-agents-from-one-prompt";
 var CAMPAIGN_CHECK_TIMEOUT_MS = 6e3;
 async function fetchCampaignActive() {
-  const { bnbPlatformApiUrl: bnbPlatformApiUrl2 } = await import("./deployCli-VM5TYKQX.js");
+  const { bnbPlatformApiUrl: bnbPlatformApiUrl2 } = await import("./deployCli-NJFCWBSF.js");
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), CAMPAIGN_CHECK_TIMEOUT_MS);
   try {
@@ -3415,11 +3415,12 @@ function unavailableProvidersForProject(root) {
   }
   if (runtime === "azure-foundry") {
     const reason = "this project uses a different container adapter; scaffold an agentcore project before selecting this provider";
+    const azureProtocolReason = "Azure Foundry deploy currently supports A2A projects only; use an A2A azure-foundry scaffold or AgentCore for MCP";
     return {
-      bnb: reason,
       aws: reason,
       ...azureProtocolUnsupported ? {
-        azure: "Azure Foundry deploy currently supports A2A projects only; use an A2A azure-foundry scaffold or AgentCore for MCP"
+        bnb: azureProtocolReason,
+        azure: azureProtocolReason
       } : {}
     };
   }
@@ -4545,6 +4546,18 @@ var azureFoundryChecks = [
   checkAltanaSdkResolvable,
   checkAltanaSessionNotInsideAgent
 ];
+var managedAzureFoundryChecks = [
+  checkStackRuntimeAzure,
+  checkEntrypointAndDockerfile,
+  checkLlmExternalProviderReady,
+  checkTwakCustomContractsUnsupported,
+  checkTwakPasswordEnvSet,
+  checkTwakCredentialsAvailable,
+  checkAltanaCustomContractsUnsupported,
+  checkAltanaSessionReady,
+  checkAltanaSdkResolvable,
+  checkAltanaSessionNotInsideAgent
+];
 
 // src/cli/llm.ts
 import * as fs19 from "fs";
@@ -13425,8 +13438,9 @@ var checkPlatformLoggedIn = async (_root, _target) => {
     }
   ];
 };
-var checkPlatformDockerAvailable = async (root, _target) => {
-  if (platformArtifact(loadAgent(root)) !== "container") return [];
+var checkPlatformDockerAvailable = async (root, target) => {
+  if (target !== "platform-azure" && platformArtifact(loadAgent(root)) !== "container")
+    return [];
   const docker = await whichBin("docker");
   if (docker === null) {
     return [
@@ -13563,6 +13577,17 @@ async function runPrepare(opts = {}) {
     }
     return new CheckResult(checks, target);
   }
+  if (target === "platform-azure") {
+    checks.push(...await runProducers(criticalChecks, root, target));
+    checks.push(
+      ...await runProducers(managedAzureFoundryChecks, root, target)
+    );
+    checks.push(...await runProducers(warningChecks, root, target));
+    if (includeInfo) {
+      checks.push(...await runProducers(infoChecks, root, target));
+    }
+    return new CheckResult(checks, target);
+  }
   if (target === "azure-foundry") {
     checks.push(
       ...await runProducers(
@@ -14267,12 +14292,37 @@ function trialLine(trial) {
 }
 async function platformAgent(opts) {
   const root = opts.root;
+  const backend = opts.backend ?? "aws";
   const isTty = opts.isTty ?? stdinIsTty;
   const ask = opts.promptUser ?? promptUser;
   warn(
-    "note: deploying to the BNB Chain managed platform \u2014 a 48h TESTNET trial sandbox (network is forced to bsc-testnet; the runtime is auto-reclaimed at 48h). Not a production seller."
+    `note: deploying to the BNB Chain managed platform (backend=${backend}) \u2014 a 48h TESTNET trial sandbox (network is forced to bsc-testnet; the runtime is auto-reclaimed at 48h). Not a production seller.`
   );
   const platformCmd = opts.runPlatformCommand ?? runPlatformAccountCommand;
+  if (backend === "azure") {
+    const cfg2 = loadAgentCfg(root);
+    const faces2 = stackFaces(tableOf12(cfg2, "stack"), tableOf12(cfg2, "payments"));
+    const protocol2 = nativeProtocolOf(faces2);
+    if (hasX402Face(faces2)) {
+      warn(
+        "error: x402 publication is not supported on the managed Azure backend. No build or upload was started."
+      );
+      return 1;
+    }
+    const runtimeProfile = protocol2 === "A2A" ? "foundry-responses-v1" : "foundry-invocations-v1";
+    const capability = await platformCmd(["capabilities"], { json: true });
+    const platform = isJsonObject(capability.data.platform) ? capability.data.platform : {};
+    const backends = isJsonObject(platform.backends) ? platform.backends : {};
+    const azure = isJsonObject(backends.azure) ? backends.azure : {};
+    const profiles = Array.isArray(azure.runtimeProfiles) ? azure.runtimeProfiles.map(String) : [];
+    const protocols = Array.isArray(azure.protocols) ? azure.protocols.map(String) : [];
+    if (capability.code !== 0 || azure.enabled !== true || !profiles.includes(runtimeProfile) || !protocols.includes(protocol2)) {
+      warn(
+        `error: the managed platform does not currently accept Azure ${runtimeProfile}/${protocol2}. No build or upload was started.`
+      );
+      return capability.code || 1;
+    }
+  }
   const campaignProbe = opts.campaignActive ?? (async () => null);
   const trialRes = await platformCmd(["trial"], { json: true });
   if (trialRes.code !== 0) {
@@ -14306,7 +14356,7 @@ async function platformAgent(opts) {
       return rc;
     }
   }
-  const packaging = platformPackaging(root);
+  const packaging = backend === "azure" ? "container" : platformPackaging(root);
   {
     const confirm = opts.confirmPackaging ?? ((r, p) => confirmPackagingDefault(r, p, {
       acceptRisk: opts.acceptRisk ?? false,
@@ -14376,7 +14426,8 @@ then re-run the deploy.`
     secrets,
     slug,
     cwd: agentDir,
-    extraArgs: opts.extraArgs ?? []
+    extraArgs: opts.extraArgs ?? [],
+    backend
   });
   if (res.code !== 0) {
     warn(
@@ -14405,7 +14456,7 @@ then re-run the deploy.`
       trial = trialFromJson(post.data);
     }
   }
-  recordDeployState(root, slug, dep);
+  recordDeployState(root, slug, dep, backend);
   recordShippedWallet(root, secrets);
   refreshTrialCache(root, {
     expiresAt: trial.expiresAt,
@@ -14416,7 +14467,7 @@ then re-run the deploy.`
 ` : "";
   emit(
     `
-\u2713 deployed to the platform (slug=${slug}).
+\u2713 deployed to the platform (backend=${backend}, slug=${slug}).
   deployment: ${dep.deploymentId}
   invoke URL: ${dep.invokeUrl || "<pending \u2014 see `bag deploy status`>"}
   ${trialLine(trial)}
@@ -14433,7 +14484,7 @@ async function termsConsentGate(root, deps) {
     return null;
   }
   warn(
-    "=== Platform trial terms (first deploy) ===\nThis deploys into the BNB Chain operator's AWS account as a 48h testnet trial. A runtime signing key (your configured or a throwaway wallet) is transmitted to the operator's Secrets Manager for the runtime to sign with \u2014 testnet-scoped, auto-reclaimed at 48h. By proceeding you accept these trial terms."
+    "=== Platform trial terms (first deploy) ===\nThis deploys into a BNB Chain operator-managed cloud account as a 48h testnet trial. A runtime signing key (your configured or a throwaway wallet) is transmitted to the operator's managed secret channel for the runtime to sign with \u2014 testnet-scoped, auto-reclaimed at 48h. By proceeding you accept these trial terms."
   );
   if (deps.acceptRisk) {
     return stampTerms(root) ? null : 1;
@@ -14490,7 +14541,7 @@ function walletWarning(root, secrets) {
     warn(
       `
 [expected \xB7 bounded Altana session]
-  This project's bounded Altana session${who2} will be transmitted to the BNB Chain operator's Secrets Manager so the trial runtime can sign on testnet. The session is budget-limited, expiring, and revocable \u2014 the admin keystore and WALLET_PASSWORD never ship.
+  This project's bounded Altana session${who2} will be transmitted through the BNB Chain operator's managed secret channel so the trial runtime can sign on testnet. The session is budget-limited, expiring, and revocable \u2014 the admin keystore and WALLET_PASSWORD never ship.
   If the current budget or expiry is wider than you want an operator-held key to carry, stop and grant a tighter one first:
       bag wallet session grant --force --budget-u <small> --expiry-days <short>
   You can revoke it on-chain at any time with \`bag wallet session revoke\`.
@@ -14502,16 +14553,17 @@ function walletWarning(root, secrets) {
   warn(
     `
 !!! wallet exposure (platform trial) !!!
-  This project's wallet ${who} will be transmitted to the BNB Chain operator's Secrets Manager so the trial runtime can sign on testnet \u2014 expected for the platform trial, and testnet-scoped.
+  This project's wallet ${who} will be transmitted through the BNB Chain operator's managed secret channel so the trial runtime can sign on testnet \u2014 expected for the platform trial, and testnet-scoped.
   If this address is one you also use elsewhere (especially on mainnet), stop and deploy with a fresh throwaway instead:
       bag wallet new
   Otherwise proceed. Reusing this address on mainnet later is discouraged.
 `
   );
 }
-function recordDeployState(root, slug, dep) {
+function recordDeployState(root, slug, dep, backend = "aws") {
   recordPlatformKv(root, "slug", slug);
   recordPlatformKv(root, "deployment_id", dep.deploymentId);
+  recordPlatformKv(root, "backend", backend);
   if (dep.agentId) {
     recordPlatformKv(root, "agent_id", dep.agentId);
   }
@@ -14617,6 +14669,7 @@ function printAgentClientPrompt(root, invokeUrl, status) {
   const base = access.base;
   const tokenUrl = access.tokenUrl;
   const deploymentId = String(platformCfg(root).deployment_id || "n/a");
+  const managedBackend = platformCfg(root).backend === "azure" ? "azure" : "aws";
   const selftestLine = "- Quick self-test (operator): run `bag deploy info --with-curl`";
   const rt = agentId ? `${base}/v1/rt/${agentId}` : `${base}/v1/rt/<agentId>`;
   const cardUrl = `${rt}/.well-known/agent-card.json`;
@@ -14696,7 +14749,7 @@ function printAgentClientPrompt(root, invokeUrl, status) {
       "- The anonymous x402 route does not use the OAuth2 token flow shown for ERC-8183."
     ],
     ...!x402Only && hasA2aFace(faces) ? [
-      '- A2A callers: send the payload as a DATA part, NOT text \u2014 parts:[{"kind":"data","data":{ ...payload above... }}]. A JSON string in a "text" part is rejected (the runtime only reads data parts, so no skill is parsed).'
+      managedBackend === "azure" ? '- A2A callers: Foundry incoming A2A is text-only. Send the payload as a JSON-string TEXT part \u2014 parts:[{"kind":"text","text":"{\\"skill\\":\\"negotiate\\",...}"}].' : '- A2A callers: send the payload as a DATA part, NOT text \u2014 parts:[{"kind":"data","data":{ ...payload above... }}]. A JSON string in a "text" part is rejected (the runtime only reads data parts, so no skill is parsed).'
     ] : [],
     "",
     "YOUR TASK",
@@ -14892,6 +14945,9 @@ var ADVERTISED_DEPLOY_RUNTIME_TARGETS = ["agentcore"];
 // src/cli/deploy.ts
 var TARGET_CHOICES = [...DEPLOY_RUNTIME_TARGETS];
 var ADVERTISED_TARGET_CHOICES = [...ADVERTISED_DEPLOY_RUNTIME_TARGETS];
+function runtimeSecretsForManagedBackend(backend) {
+  return backend === "azure" ? collectAzureSecretPayload : collectRuntimeSecrets;
+}
 function isFile16(p) {
   try {
     return fs38.statSync(p).isFile();
@@ -14958,7 +15014,12 @@ function registerDeploy(program) {
     PROVIDER_MENU_ORDER,
     ADVERTISED_PROVIDERS
   );
-  p.addOption(providerOption()).option("--project-root <path>", "Override project root.").option("--skip-prepare", "Skip non-storage local readiness checks.").option(
+  p.addOption(providerOption()).addOption(
+    new Option4(
+      "--backend <backend>",
+      "Managed backend confirmation for --provider bnb (aws or azure). It must match [stack].runtime."
+    ).choices(["aws", "azure"])
+  ).option("--project-root <path>", "Override project root.").option("--skip-prepare", "Skip non-storage local readiness checks.").option(
     "--force-deploy-broken-storage",
     "DANGEROUS: bypass fatal deliverable-storage checks."
   ).option("--force", "Bypass explicitly forceable readiness checks.").addOption(
@@ -14976,7 +15037,12 @@ function registerDeploy(program) {
   ).action(act((opts) => cmdPrepare(opts)));
   p.command("agent").description(
     "Deprecated compatibility alias for `bag deploy`. Thin wrapper: gates on prepare, syncs runtime secrets, builds the agent (`pnpm build`), delegates to the platform CLI."
-  ).addOption(providerOption()).addOption(runtimeOption()).addOption(targetAlias()).addOption(
+  ).addOption(providerOption()).addOption(
+    new Option4(
+      "--backend <backend>",
+      "Managed backend confirmation for --provider bnb (aws or azure). It must match [stack].runtime."
+    ).choices(["aws", "azure"])
+  ).addOption(runtimeOption()).addOption(targetAlias()).addOption(
     new Option4(
       "--to <destination>",
       "Deploy destination override: self (your own cloud) or platform (the managed BNB Chain trial). Default: studio.toml [deploy].destination, else self."
@@ -15038,10 +15104,10 @@ function registerDeploy(program) {
     )
   );
   p.command("info").description(
-    "Show the buyer-access surface for a platform deploy (URL, token endpoint, scope, agentId)."
+    "Show the buyer-access surface for a platform or Azure self-deploy."
   ).option("--project-root <path>", "Override project root.").option("--json", "Emit JSON instead of a table.").option(
     "--with-curl",
-    "Also print a copy-paste curl chain (client_credentials token + invoke)."
+    "Also print a copy-paste authentication + invoke curl chain."
   ).action(
     act(
       (opts) => cmdInfo(opts)
@@ -15665,6 +15731,37 @@ async function cmdAgent(opts, agentcoreArgs) {
   const root = resolveProjectRoot2(opts.projectRoot);
   const destination = opts.provider ? opts.provider === "bnb" ? "platform" : "self" : opts.to ?? opts.destination ?? agentDeployDestination(root);
   const packagingDestination = opts.to ?? opts.destination ?? agentDeployDestination(root);
+  let managedBackend;
+  if (destination === "platform") {
+    const runtime = readStackRuntime(root) ?? "agentcore";
+    managedBackend = runtime === "azure-foundry" ? "azure" : "aws";
+    if (opts.backend && opts.backend !== managedBackend) {
+      printErr(
+        `error: --backend=${opts.backend} conflicts with [stack].runtime='${runtime}', which requires backend=${managedBackend}. --backend confirms the recipe target; it does not convert recipes across clouds.`
+      );
+      return 2;
+    }
+    if (managedBackend === "azure" && !opts.backend) {
+      if (!stdinIsTty()) {
+        printErr(
+          "error: an azure-foundry project requires explicit --backend azure in a non-interactive terminal."
+        );
+        return 2;
+      }
+      const answer = await promptUser(
+        "This azure-foundry project will use the managed Azure backend. Continue? [y/N] "
+      );
+      if (!["y", "yes"].includes(answer.trim().toLowerCase())) {
+        printErr("cancelled: managed Azure backend was not confirmed.");
+        return 2;
+      }
+    }
+  } else if (opts.backend) {
+    printErr(
+      `error: --backend is accepted only with --provider bnb; --provider ${opts.provider ?? "self"} selects a user-owned cloud directly.`
+    );
+    return 2;
+  }
   if (destination === "platform") {
     const networkGate = rejectPlatformMainnet(root);
     if (networkGate !== null) return networkGate;
@@ -15691,14 +15788,15 @@ async function cmdAgent(opts, agentcoreArgs) {
     }
     return platformAgent({
       root,
+      backend: managedBackend,
       acceptRisk: opts.acceptRisk,
       skipPrepare: opts.skipPrepare,
       force: opts.force,
       // The deploy layer injects the shared secret collector + prepare gate
       // so the self-deploy and platform secret/readiness surfaces never
       // drift (the Python `_collect_runtime_secrets` / `run_prepare` share).
-      collectRuntimeSecrets,
-      runPrepareGate: platformPrepareGate(opts),
+      collectRuntimeSecrets: runtimeSecretsForManagedBackend(managedBackend),
+      runPrepareGate: platformPrepareGate(opts, managedBackend),
       extraArgs: stripLeadingDdash2(agentcoreArgs)
     });
   }
@@ -15901,10 +15999,10 @@ function recordOf2(data) {
 function stripLeadingDdash2(extra) {
   return extra.length > 0 && extra[0] === "--" ? extra.slice(1) : extra;
 }
-function platformPrepareGate(opts) {
+function platformPrepareGate(opts, backend = "aws") {
   return async (root, force) => {
     let result = await runPrepare({
-      target: "platform",
+      target: backend === "azure" ? "platform-azure" : "platform",
       projectRoot: root,
       includeInfo: false,
       force
@@ -15968,6 +16066,7 @@ function agentProtocolOf(agentRoot2) {
   return nativeProtocolOf(agentFacesOf(agentRoot2));
 }
 var GUIDE_URL2 = "https://github.com/bnb-chain/bnbagent-studio/blob/main/docs/guides/agentcore-a2a-access.md";
+var FOUNDRY_GUIDE_URL = "https://github.com/bnb-chain/bnbagent-studio/blob/main/docs/guides/foundry-a2a-access.md";
 function oauthFactsForAgentcore(agentRoot2) {
   const summary = accessSummaryForAgentcore(agentRoot2);
   if (summary === null) {
@@ -16012,8 +16111,12 @@ async function printAccessNextSteps2(root, runtime, opts = {}) {
     }
     return;
   }
+  const invokeUrl = opts.invokeUrl ?? recordedEndpoint(root);
+  if (invokeUrl) {
+    printOut(`  endpoint: ${invokeUrl}`);
+  }
   printOut(
-    "  Azure Foundry buyer access is in Preview \u2014 see docs/guides/foundry-a2a-access.md in the bnbagent-studio repo. The per-agent A2A card URL and OAuth scope are confirmed only after a live deploy."
+    `  Azure Foundry access uses a Microsoft Entra bearer token. Run \`bag deploy info --with-curl\` for the exact endpoint, token resource, and Invocations request body; see ${FOUNDRY_GUIDE_URL}.`
   );
 }
 var CLIENT_PROMPT_RULE2 = "\u2500".repeat(62);
@@ -16417,6 +16520,96 @@ Quick-verify x402 endpoint:
     "\n  Note: this only exercises `negotiate` (a read-only quote). To get a deliverable you must fund a job on-chain (ERC-8183 createJob -> registerJob -> setBudget -> fund), then call `notify_funded` with that job_id and poll the chain for SUBMITTED \u2014 see the emitted client prompt / `bnbagent-studio-buying-via-8183`."
   );
 }
+var AZURE_FOUNDRY_TOKEN_RESOURCE = "https://ai.azure.com";
+var AZURE_FOUNDRY_TOKEN_SCOPE = `${AZURE_FOUNDRY_TOKEN_RESOURCE}/.default`;
+function azureQuickVerifyBody() {
+  return {
+    input: JSON.stringify({
+      skill: "negotiate",
+      task_description: "Create a concise launch checklist",
+      terms: {
+        deliverables: "A 5-item checklist",
+        quality_standards: "Clear and actionable"
+      }
+    })
+  };
+}
+function printAzureInfo(deployment, opts) {
+  const endpoint = deployment.endpoint;
+  if (!endpoint) {
+    if (opts.json) {
+      printOut(
+        JSON.stringify(
+          {
+            provider: "azure",
+            target: deployment.target,
+            name: deployment.name,
+            endpoint: null,
+            error: "No Azure invocation endpoint is recorded."
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      printErr(
+        "Azure deployment is recorded but has no invocation endpoint. Run `bag deploy status --provider azure` and redeploy if the live endpoint cannot be recovered."
+      );
+    }
+    return 1;
+  }
+  const body = azureQuickVerifyBody();
+  if (opts.json) {
+    printOut(
+      JSON.stringify(
+        {
+          provider: "azure",
+          target: deployment.target,
+          name: deployment.name,
+          deployment_id: deployment.deploymentId,
+          endpoint,
+          authentication: {
+            type: "entra_bearer",
+            resource: AZURE_FOUNDRY_TOKEN_RESOURCE,
+            scope: AZURE_FOUNDRY_TOKEN_SCOPE
+          },
+          request: {
+            method: "POST",
+            content_type: "application/json",
+            body
+          }
+        },
+        null,
+        2
+      )
+    );
+    return 0;
+  }
+  printOut("bag deploy info \u2014 Azure Foundry self-deploy");
+  printOut(`  endpoint: ${endpoint}`);
+  printOut(
+    `  authentication: Microsoft Entra bearer token (resource ${AZURE_FOUNDRY_TOKEN_RESOURCE}; SDK scope ${AZURE_FOUNDRY_TOKEN_SCOPE})`
+  );
+  printOut("  request: POST application/json");
+  printOut(`  body: ${JSON.stringify(body)}`);
+  if (opts.withCurl) {
+    printOut("\nQuick-verify curl:");
+    printOut(
+      `  AZURE_TOKEN=$(az account get-access-token --resource ${AZURE_FOUNDRY_TOKEN_RESOURCE} --query accessToken -o tsv)`
+    );
+    printOut(`  AZURE_ENDPOINT=${JSON.stringify(endpoint)}`);
+    printOut(
+      `  curl -sS -X POST "$AZURE_ENDPOINT" \\
+    -H "Authorization: Bearer $AZURE_TOKEN" \\
+    -H "Content-Type: application/json" \\
+    -d '${JSON.stringify(body)}'`
+    );
+    printOut(
+      "\n  The Azure CLI command is only a convenient way to mint a token for this curl. Deployment itself does not require az/azd; DefaultAzureCredential or ClientSecretCredential can mint the same scope in an application."
+    );
+  }
+  return 0;
+}
 async function cmdInfo(opts) {
   const rc = applyProjectRoot(opts.projectRoot, false);
   if (rc !== null) {
@@ -16424,7 +16617,8 @@ async function cmdInfo(opts) {
   }
   const root = resolveProjectRoot2(opts.projectRoot);
   const workspaceRoot = deployWorkspaceRoot2(root);
-  const hasBnbDeployment = discoverRecordedDeployments(workspaceRoot).some(
+  const recorded = discoverRecordedDeployments(workspaceRoot);
+  const hasBnbDeployment = recorded.some(
     (deployment) => deployment.provider === "bnb"
   );
   if (hasBnbDeployment) {
@@ -16434,6 +16628,12 @@ async function cmdInfo(opts) {
     }
     return infoRc;
   }
+  const azureDeployment = recorded.find(
+    (deployment) => deployment.provider === "azure"
+  );
+  if (azureDeployment) {
+    return printAzureInfo(azureDeployment, opts);
+  }
   printErr(
     "`bag deploy info` reports the platform buyer-access surface; this project has no recorded BNB deployment. Use `bag deploy status` to inspect recorded providers."
   );
@@ -16571,10 +16771,10 @@ async function cmdLogs(opts) {
       if (deployment.provider === "aws" && opts.since) {
         argv.push("--since", opts.since);
       }
-      if (deployment.provider === "azure" && opts.limit) {
+      if (opts.limit) {
         argv.push("--limit", opts.limit);
       }
-      if (deployment.provider === "azure" && opts.session) {
+      if (opts.session) {
         argv.push("--session", opts.session);
       }
       return runDeployCliStream(argv, {

package/dist/{chunk-ODCZKKZJ.js → chunk-YFEM4564.js}

@@ -820,7 +820,7 @@ function isTable(value) {
 }
 
 // src/cli/_deploy/deployCli.ts
-var DEPLOY_CLI_VERSION = "0.4.14";
+var DEPLOY_CLI_VERSION = "0.5.4";
 var DEPLOY_CLI_PACKAGE = `@bnbagent/deploy-cli@${DEPLOY_CLI_VERSION}`;
 var BNB_PLATFORM_API_URL = "https://bnbagent-api.bnbchain.world";
 var BNB_PLATFORM_API_URL_ENV = "BNBAGENT_API_URL";
@@ -992,7 +992,12 @@ function buildDeploySpec(root, opts) {
       }
     }
     deploy.protocol = protocol;
-    doc.bnb = { apiUrl: bnbPlatformApiUrl() };
+    const stackRuntime = String(stack.runtime ?? "agentcore");
+    doc.bnb = stackRuntime === "azure-foundry" ? {
+      apiUrl: bnbPlatformApiUrl(),
+      backend: "azure",
+      runtimeProfile: protocol === "A2A" ? "foundry-responses-v1" : "foundry-invocations-v1"
+    } : { apiUrl: bnbPlatformApiUrl() };
   }
   if (opts.inlineSecrets) {
     Object.assign(env, opts.inlineSecrets);

package/dist/{deployCli-VM5TYKQX.js → deployCli-NJFCWBSF.js}

@@ -18,7 +18,7 @@ import {
   runPlatformAccountCommand,
   trialFromDeployCliJson,
   withDeployFiles
-} from "./chunk-ODCZKKZJ.js";
+} from "./chunk-YFEM4564.js";
 import "./chunk-RO726HJG.js";
 export {
   BNB_PLATFORM_API_URL,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bnbagent/studio-cli",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "description": "Skills-first toolkit and bag CLI for BNB Chain seller agents: ERC-8004 identity, ERC-8183 escrowed commerce, and x402 payments.",
   "keywords": [
     "bnb-chain",
@@ -51,7 +51,7 @@
   },
   "dependencies": {
     "@bnbagent/sdk": "0.5.0",
-    "@bnbagent/studio-runtime": "0.0.8",
+    "@bnbagent/studio-runtime": "0.0.9",
     "ai": "^7.0.29",
     "archiver": "^8.0.0",
     "commander": "^15.0.0",

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

@@ -4,8 +4,9 @@
  * Generated by `bag init --runtime azure-foundry`. This is the
  * Foundry-hosted counterpart of the cloud-neutral A2A entrypoint
  * (`main.ts`). The deploy spec declares Foundry's minimal pass-through
- * `invocations` protocol, so this host implements its documented container
- * contract: plain HTTP on :8088, GET /readiness, and POST /invocations.
+ * `invocations` protocol for user-owned Azure and the `responses` protocol
+ * for managed incoming A2A. This host implements both documented container
+ * endpoints on :8088 plus GET /readiness.
  *
  * ## How A2A reaches the seller skills on Foundry
  *
@@ -31,6 +32,7 @@
  * arrive as environment variables before the process starts.
  */
 
+import { randomUUID } from "node:crypto";
 import { pathToFileURL } from "node:url";
 import { createOpenAI } from "@ai-sdk/openai";
 import { loadStudioToml } from "@bnbagent/studio-runtime/config";
@@ -234,6 +236,112 @@ export function extractEnvelope(
     : 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");
+}
+
 async function main(): Promise<void> {
   scrubBlankAppInsights();
 
@@ -268,6 +376,20 @@ async function main(): Promise<void> {
     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);
+    }
+  });
   // 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) => {
@@ -280,7 +402,7 @@ async function main(): Promise<void> {
   // Foundry's documented default is 8088; PORT remains the platform override.
   const port = Number(process.env.PORT || process.env.AGENT_PORT || "8088");
   const server = app.listen(port, "0.0.0.0", () => {
-    log.info(`Invocations host serving on 0.0.0.0:${port}`);
+    log.info(`Invocations + Responses host serving on 0.0.0.0:${port}`);
   });
   process.once("SIGTERM", () => {
     server.close(() => process.exit(0));

package/recipes/runtimes/azure-foundry/recipe.toml

@@ -1,6 +1,6 @@
 [recipe]
 name = "runtimes/azure-foundry"
-description = "Runtime adapter recipe for Azure AI Foundry Hosted Agents — the second deploy target. Selected via `bag init --runtime azure-foundry`. Declares the runtime's required node deps and contributes the cloud-neutral @a2a-js/sdk server for local/dev plus the Foundry deploy host: a pass-through Invocations skill router over the SHARED SellerAgentExecutor.dispatch, serving the documented :8088 + /readiness + /invocations contract. Azure deployment currently supports A2A scaffolds only; the MCP entrypoint remains local/AgentCore-oriented and is rejected before Foundry deploy. The chain tools (tools.ts) + model factory (model.ts) are shared by both protocols (decision D9). Deploys are container-only and fully delegated to the pinned @bnbagent/deploy-cli (SDK/REST + browser login; CustomKeys secret injection; no azd/az CLIs, no azure.yaml/infra in the scaffold)."
+description = "Runtime adapter recipe for Azure AI Foundry Hosted Agents — the second deploy target. Selected via `bag init --runtime azure-foundry`. Declares the runtime's required node deps and contributes the cloud-neutral @a2a-js/sdk server for local/dev plus a dual-protocol Foundry deploy host: pass-through Invocations for user-owned Azure and OpenAI Responses for managed incoming A2A, both routed over the SHARED SellerAgentExecutor.dispatch. Azure deployment currently supports A2A scaffolds only; the MCP entrypoint remains local/AgentCore-oriented and is rejected before Foundry deploy. The chain tools (tools.ts) + model factory (model.ts) are shared by both protocols (decision D9). Deploys are container-only and fully delegated to the pinned @bnbagent/deploy-cli (SDK/REST + browser login; CustomKeys secret injection; no azd/az CLIs, no azure.yaml/infra in the scaffold)."
 status = "v1"
 
 # The recipe contributes the entrypoints plus the deps below; the deploy
@@ -9,8 +9,8 @@ status = "v1"
 # azd bootstrap and no azure.yaml / infra/ in the scaffold).
 #
 # foundryMain.ts implements the documented framework-neutral container
-# contract directly: plain HTTP on :8088, GET /readiness, and the declared
-# POST /invocations pass-through route. This path was live E2E verified on
+# contract directly: plain HTTP on :8088, GET /readiness, POST /invocations,
+# and POST /responses (required for managed incoming A2A). The invocations path was live E2E verified on
 # 2026-07-20 through deploy, cold-start smoke, invoke, logs, and destroy.
 
 # Base deps are shared by every mode. bnbagent-deploy injects provider/storage

package/skills/bnbagent-studio.md

@@ -53,7 +53,7 @@ Treat ERC-8183 amounts as decimal strings at CLI/config boundaries and `bigint`
 
 ## CLI groups at a glance
 
-`init`, `scan`, `recipe`, `skills`, `wallet`, `erc8004`, `erc8183`, `x402`, `agents`, `config`, `env`, `dev`, `doctor`, `audit`, `deploy`, `platform`, `llm`, `bundle`, `budget` - see `bag --help` for details. `bag deploy [--provider bnb\|aws]` is the primary deploy command; `prepare`, `verify`, `status`, `info`, `destroy`, `logs`, and `fix-gitignore` remain lifecycle subcommands (`deploy agent` is a deprecated compatibility alias). Provider deploy/status/logs/destroy and deploy-time credential validation are delegated to pinned `@bnbagent/deploy-cli@0.4.14`.
+`init`, `scan`, `recipe`, `skills`, `wallet`, `erc8004`, `erc8183`, `x402`, `agents`, `config`, `env`, `dev`, `doctor`, `audit`, `deploy`, `platform`, `llm`, `bundle`, `budget` - see `bag --help` for details. `bag deploy [--provider bnb\|aws] [--backend aws\|azure]` is the primary deploy command; `--backend` is valid only for provider `bnb` and confirms the recipe-derived managed backend. `prepare`, `verify`, `status`, `info`, `destroy`, `logs`, and `fix-gitignore` remain lifecycle subcommands (`deploy agent` is a deprecated compatibility alias). Provider deploy/status/logs/destroy and deploy-time credential validation are delegated to pinned `@bnbagent/deploy-cli@0.5.4`.
 
 ## Tool surface
 

package/skills/references/bnbagent-studio-use-aws-agentcore.md

@@ -1,6 +1,6 @@
 ---
 name: bnbagent-studio-use-aws-agentcore
-description: When the user wants to deploy or operate a bnbagent-studio project on AWS Bedrock AgentCore - deploy with `bag deploy --provider aws` (all cloud lifecycle mutations are delegated to pinned `@bnbagent/deploy-cli@0.4.14`), inspect with `bag deploy status` / `logs --provider aws` / `verify --provider aws`, and tear down with `bag deploy destroy --provider aws --execute [--purge]`. Also covers AWS credential prerequisites, the optional read-only quota probe, and the runtime-secret channel.
+description: When the user wants to deploy or operate a bnbagent-studio project on AWS Bedrock AgentCore - deploy with `bag deploy --provider aws` (all cloud lifecycle mutations are delegated to pinned `@bnbagent/deploy-cli@0.5.4`), inspect with `bag deploy status` / `logs --provider aws` / `verify --provider aws`, and tear down with `bag deploy destroy --provider aws --execute [--purge]`. Also covers AWS credential prerequisites, the optional read-only quota probe, and the runtime-secret channel.
 ---
 
 > **Reference file** of the `bnbagent-studio` router skill - installed at `bnbagent-studio/references/` and loaded on demand (not a standalone skill). Route here via the router's decision tree.

package/skills/references/bnbagent-studio-use-azure-foundry.md

@@ -1,6 +1,6 @@
 ---
 name: bnbagent-studio-use-azure-foundry
-description: When the user wants to deploy or operate an A2A bnbagent-studio project on Azure AI Foundry Hosted Agents - scaffold with `bag init --runtime azure-foundry --protocols A2A`, deploy with `bag deploy --provider azure` (container-only Invocations contract; all cloud lifecycle execution is delegated to pinned `@bnbagent/deploy-cli@0.4.14`, SDK/REST with browser login - no `az`/`azd` CLIs), and run lifecycle commands with `--provider azure` when multiple deployments exist. Native MCP deploy is not supported on Azure yet; use AgentCore for MCP.
+description: When the user wants to deploy or operate a bnbagent-studio project on Azure AI Foundry Hosted Agents - scaffold with `bag init --runtime azure-foundry`, deploy either to the managed platform with `bag deploy --provider bnb --backend azure` or directly with `bag deploy --provider azure`; all cloud lifecycle execution is delegated to pinned `@bnbagent/deploy-cli@0.5.4`. Native MCP is not supported on Azure; use AgentCore for MCP.
 ---
 
 > **Reference file** of the `bnbagent-studio` router skill - installed at `bnbagent-studio/references/` and loaded on demand (not a standalone skill). Route here via the router's decision tree.
@@ -9,7 +9,7 @@ description: When the user wants to deploy or operate an A2A bnbagent-studio pro
 
 > **Preview - not advertised in this release.** Azure Foundry support is fully wired but hidden from the `--runtime` menu and the deploy provider menu; these steps still work if you select `azure-foundry` / `--provider azure` explicitly. The most recent end-to-end live verification predates the TypeScript rewrite - treat your first deploy as a verification run.
 
-Procedure for deploying and operating the seller Agent on **Azure AI Foundry Hosted Agents** (`[stack].runtime = "azure-foundry"`). ALL cloud execution - browser login, Foundry onboarding, the container registry image build/push, secret provisioning, and the RBAC self-grant - is **delegated to the pinned `@bnbagent/deploy-cli`** (run via `bunx --bun`; override with `BNBAGENT_DEPLOY_COMMAND`), whose Azure provider is **SDK/REST-only**. Studio never shells out to (or requires) the `az` / `azd` CLIs.
+Procedure for deploying and operating the seller Agent on **Azure AI Foundry Hosted Agents** (`[stack].runtime = "azure-foundry"`). ALL cloud execution is **delegated to the pinned `@bnbagent/deploy-cli`** (run via `bunx --bun`; override with `BNBAGENT_DEPLOY_COMMAND`), whose Azure provider is **SDK/REST-only**. Studio never shells out to (or requires) the `az` / `azd` CLIs. Direct user-owned deployment uses browser/local credentials and may self-heal RBAC; the managed platform uses environment credentials in `ambient-only` mode and only probes RBAC.
 
 ```
 <workspace>/
@@ -21,7 +21,7 @@ Procedure for deploying and operating the seller Agent on **Azure AI Foundry Hos
 
 > **Deploy model: CONTAINER-ONLY.** The deploy-cli Azure provider rejects Node zip artifacts, so every azure-foundry deploy builds the scaffolded `app/agent/Dockerfile` **locally with Docker** (linux/amd64) and pushes it to the auto-provisioned Azure Container Registry; Foundry Agent Service pulls and runs the image. A running Docker daemon is required.
 
-> **Protocol: A2A projects only for now.** The deployed Node host speaks Foundry's pass-through Invocations container contract on `:8088` (`GET /readiness`, `POST /invocations`). That endpoint is not native MCP streamable HTTP; `bag init` and provider selection reject azure-foundry + MCP instead of deploying a container that can never become ready.
+> **Protocol: A2A projects only for now.** The deployed Node host speaks both Foundry container contracts on `:8088`: `GET /readiness`, pass-through `POST /invocations` for user-owned Azure, and OpenAI-compatible `POST /responses` for managed incoming A2A. Neither endpoint is native MCP streamable HTTP; `bag init` and provider selection reject azure-foundry + MCP instead of deploying a container that can never become ready.
 
 > **Auth is a browser login.** The first delegated run opens a browser to sign in to the right tenant/subscription - there is no `az login` / `azd auth login` step and no CLI to install.
 
@@ -38,7 +38,7 @@ Procedure for deploying and operating the seller Agent on **Azure AI Foundry Hos
 - **Region must support Hosted Agents.** Default `eastus2`. `eastus` does NOT. Prepare refuses an unsupported `[azure].location` (else deploy fails with `Unsupported region for Foundry Hosted Agents`).
 - **Account name MUST equal the custom subdomain.** The runtime derives `https://{account_name}.services.ai.azure.com`; a mismatch resolves to NXDOMAIN and the agent returns HTTP 500. `bag init` sets them equal - keep them equal in `[azure]`.
 - **Empty `APPLICATIONINSIGHTS_CONNECTION_STRING` crashes the exporter.** The emitted entrypoint drops it when blank - don't remove that guard.
-- **The hosted container contract is fixed.** Keep `AGENT_PORT=8088`, `GET /readiness` returning HTTP 200, and `POST /invocations`. Local A2A still runs on `:9000`; do not copy that local port into the Foundry Dockerfile.
+- **The hosted container contract is fixed.** Keep `AGENT_PORT=8088`, `GET /readiness` returning HTTP 200, and both `POST /invocations` and `POST /responses`. Local A2A still runs on `:9000`; do not copy that local port into the Foundry Dockerfile.
 - **Prepare checks are local-only.** They validate the scaffold (region, subdomain, entrypoint + Dockerfile, an OpenAI-compatible `[llm]` provider, twak readiness) without any cloud call; Azure auth happens at deploy time.
 
 ## Runtime secrets - the delegated hand-off
@@ -47,7 +47,7 @@ Procedure for deploying and operating the seller Agent on **Azure AI Foundry Hos
 
 > The encrypted keystore (`.studio/wallets/`) stays at the workspace root and rides only that secret channel - never baked into the image.
 
-Provider-native overrides go in the optional `studio.toml [deploy.foundry]` table (verbatim deploy-spec keys; deploy-cli 0.4.14 consumes `account`, `cpu`, `location`, `memory`, `project`, `projectEndpoint`, `protocol`, `registry` and warns about anything else). The `[azure]` block's `account_name` / `project_name` / `project_endpoint` / `location` win over conflicting `[deploy.foundry]` keys.
+Provider-native overrides go in the optional `studio.toml [deploy.foundry]` table (verbatim deploy-spec keys; deploy-cli 0.5.4 consumes `account`, `cpu`, `location`, `memory`, `project`, `projectEndpoint`, `protocol`, `registry` and warns about anything else). The `[azure]` block's `account_name` / `project_name` / `project_endpoint` / `location` win over conflicting `[deploy.foundry]` keys.
 
 ## Typical workflow
 
@@ -76,9 +76,17 @@ bag deploy --provider azure                  # delegated: login → onboard →
 
 ```bash
 bag deploy status                            # all recorded providers + live state
+bag deploy info --with-curl                  # endpoint + Entra token shortcut + request body
 bag deploy logs --provider azure --limit 50 # delegated Hosted Agent logs
 ```
 
+`bag deploy info` reads the recorded Azure endpoint without recreating the
+temporary deploy spec. `--with-curl` adds an optional `az account
+get-access-token --resource https://ai.azure.com` shortcut and a complete
+Invocations request. This does not make the Azure CLI a deploy prerequisite;
+application clients may mint the same `https://ai.azure.com/.default` scope
+with `DefaultAzureCredential` or `ClientSecretCredential`.
+
 The built-in smoke proves the container contract, not the seller signature. For a release E2E, invoke with a complete `negotiate` envelope and require `response.accepted=true`, a non-empty `negotiation_hash`, and `provider_sig`. The Invocations body is `{"input":"<serialized skill JSON>"}`.
 
 ### D. Tear down

package/skills/references/bnbagent-studio-use-bnb-trial.md

@@ -9,7 +9,7 @@ description: Use when deploying or operating a bnbagent-studio seller on the BNB
 
 Treat this provider as a temporary testnet sandbox. Require a throwaway wallet, keep `bsc-testnet`, and explain that the runtime signing material is transmitted to the operator's managed secret store for the trial. Never use a mainnet key. Exception: `wallet.kind='altana'` ships only the bounded, budget-limited, revocable session - the throwaway-wallet advice does not apply; tighten the session instead (`bag wallet session grant --force --budget-u <small> --expiry-days <short>`) and never run `bag wallet new` on an altana project (it breaks the session's `[wallet].address` anchor).
 
-All auth and cloud lifecycle work must cross the pinned `@bnbagent/deploy-cli@0.4.14` boundary. Do not call the AWS CLI or platform REST routes directly.
+All auth and cloud lifecycle work must cross the pinned `@bnbagent/deploy-cli@0.5.4` boundary. Do not call a cloud CLI or platform REST routes directly. The managed backend is recipe-derived: `agentcore` uses AWS; `azure-foundry` uses Azure. For headless managed Azure, confirm with `bag deploy --provider bnb --backend azure --yes`; never treat `--backend` as a cross-cloud recipe converter.
 
 ## Select and authenticate