@openagentsinc/pylon 0.2.4 → 0.2.5

package/README.md

@@ -17,6 +17,8 @@ npx @openagentsinc/pylon --version 0.1.16
 npx @openagentsinc/pylon --no-launch
 npx @openagentsinc/pylon --no-updates
 npx @openagentsinc/pylon status --json
+npx @openagentsinc/pylon --register-openagents --no-launch --json
+npx @openagentsinc/pylon --register-openagents --setup-mdk-wallet --no-launch --json
 npx @openagentsinc/pylon --download-curated-cache --model gemma-4-e2b --run-diagnostics
 npx @openagentsinc/pylon --verbose
 ```
@@ -64,6 +66,11 @@ The launcher:
   unless `--no-launch` is set
 - forwards CLI subcommands such as `pylon status --json` to the installed
   `pylon` binary after bootstrap instead of opening `pylon-tui`
+- can register the local Pylon with OpenAgents and send a public-safe
+  heartbeat when `--register-openagents` is explicitly set
+- can initialize or reuse a local MoneyDevKit agent wallet, generate local
+  receive readiness, and report only redacted wallet/payout-target refs when
+  `--setup-mdk-wallet` is explicitly set
 - on native Windows x86_64, installs `pylon.exe` and `pylon-tui.exe` from the
   Windows `.zip` release asset and forwards CLI subcommands to `pylon.exe`
 - while the TUI is running on the default release track, checks GitHub Releases
@@ -87,9 +94,79 @@ The launcher:
   advertise homework-worker capability. Launcher `0.1.17` adds CLI subcommand
   forwarding and bounds background GitHub release checks to avoid
   unauthenticated rate-limit churn.
-- does not try to install or register a local runtime automatically; the
-  bootstrap stays honest about the separate local Gemma runtime
-  prerequisite instead of mutating the host behind the user's back
+- does not register with OpenAgents by default; registration is an explicit
+  token-scoped operator action
+
+## OpenAgents registration
+
+Use this only with an active OpenAgents programmatic agent token. Prefer an
+environment variable so the token is not stored in shell history:
+
+```bash
+export OPENAGENTS_AGENT_TOKEN="oa_agent_..."
+
+npx @openagentsinc/pylon@latest \
+  --register-openagents \
+  --openagents-api https://openagents.com \
+  --resource-mode background_20 \
+  --no-launch \
+  --json
+```
+
+The launcher runs the normal first-run smoke, derives or reuses a stable public
+Pylon ref from the local Pylon identity, registers through
+`POST /api/pylons/register`, and sends a heartbeat through
+`POST /api/pylons/{pylonRef}/heartbeat`.
+
+Optional public-safe registration flags:
+
+```bash
+--pylon-ref pylon.example.local
+--pylon-display-name "Example Pylon"
+--capability-ref capability.public.gpu
+```
+
+The registration payload deliberately excludes local paths, wallet material,
+private model inventory, hostnames, SSH details, provider credentials, and raw
+payment data.
+
+## MDK wallet readiness
+
+After registration, a Pylon can report wallet receive readiness and request
+payout-target admission:
+
+```bash
+export OPENAGENTS_AGENT_TOKEN="oa_agent_..."
+
+npx @openagentsinc/pylon@latest \
+  --register-openagents \
+  --setup-mdk-wallet \
+  --openagents-api https://openagents.com \
+  --resource-mode background_20 \
+  --no-launch \
+  --json
+```
+
+Optional test/operator isolation flags:
+
+```bash
+--mdk-wallet-home /path/to/ignored/mdk-home
+--mdk-wallet-port 3457
+--mdk-receive-amount-sats 21
+```
+
+The launcher uses `npx @moneydevkit/agent-wallet@latest` locally. It may run
+`init --show`, `init`, `balance`, and `receive`. It submits only:
+
+- `wallet.public.mdk_agent_wallet.<digest>`;
+- `receive.redacted.mdk_agent_wallet.<digest>`;
+- `payout_target.public.mdk_agent_wallet.<digest>`;
+- bucketed readiness refs such as
+  `balance.mdk_agent_wallet.minimum_not_satisfied`.
+
+It does not submit the mnemonic, wallet config, raw receive invoice, payment
+hash, preimage, exact wallet balance, wallet home path, or private destination
+material to OpenAgents.
 
 Set `OPENAGENTS_DISABLE_TELEMETRY=1` to disable installer telemetry, or
 `OPENAGENTS_TELEMETRY_URL=http://127.0.0.1:8000/api/telemetry/events` to point

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openagentsinc/pylon",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "description": "Bootstrap the standalone OpenAgents Pylon release asset and run first-run smoke checks.",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -2,6 +2,7 @@ import {
   DEFAULT_DIAGNOSTIC_MAX_OUTPUT_TOKENS,
   DEFAULT_DIAGNOSTIC_REPEATS,
   DEFAULT_MODEL_ID,
+  DEFAULT_OPENAGENTS_API_BASE,
   DEFAULT_RELEASE_API_BASE,
   DEFAULT_RELEASE_REPO,
   bootstrapInstalledPylon,
@@ -120,6 +121,28 @@ Options:
   --verbose                            Print extra network and recovery detail.
   --debug-network                      Alias for --verbose.
   --json                               Emit a machine-readable JSON summary.
+  --register-openagents                Register and heartbeat this Pylon with
+                                       OpenAgents after local first-run smoke.
+                                       Requires OPENAGENTS_AGENT_TOKEN or
+                                       --openagents-agent-token.
+  --openagents-api <url>               OpenAgents API base for registration.
+                                       Default: ${DEFAULT_OPENAGENTS_API_BASE}
+  --openagents-agent-token <token>     Agent bearer token for registration.
+                                       Prefer the environment variable.
+  --pylon-ref <ref>                    Explicit public-safe Pylon ref.
+  --pylon-display-name <name>          Public-safe Pylon display name.
+  --resource-mode <mode>               Public resource mode for registration.
+                                       Default: background_20
+  --capability-ref <ref>               Add a public-safe capability ref.
+                                       May be repeated or comma-separated.
+  --setup-mdk-wallet                   Initialize or reuse the local MDK agent
+                                       wallet, create receive readiness, and
+                                       report redacted wallet/payout refs.
+  --mdk-wallet-home <path>             HOME override for isolated MDK wallet
+                                       config during tests or operator smokes.
+  --mdk-wallet-port <port>             MDK agent-wallet daemon port override.
+  --mdk-receive-amount-sats <amount>   Tiny receive amount for readiness.
+                                       Default: 1 satoshi of bitcoin.
 
 Test and maintainer options:
   --repo <owner/name>                  Override the GitHub release repo.
@@ -147,6 +170,17 @@ export function parseArgs(argv) {
     json: false,
     help: false,
     pylonArgs: [],
+    openAgentsRegister: false,
+    openAgentsApiBase: DEFAULT_OPENAGENTS_API_BASE,
+    openAgentsAgentToken: null,
+    openAgentsPylonRef: null,
+    openAgentsPylonDisplayName: null,
+    openAgentsResourceMode: "background_20",
+    openAgentsCapabilityRefs: [],
+    openAgentsSetupMdkWallet: false,
+    openAgentsMdkWalletHome: null,
+    openAgentsMdkWalletPort: null,
+    openAgentsMdkReceiveAmountSats: 1,
   };
 
   for (let index = 0; index < argv.length; index += 1) {
@@ -227,6 +261,73 @@ export function parseArgs(argv) {
       case "--json":
         options.json = true;
         break;
+      case "--register-openagents":
+        options.openAgentsRegister = true;
+        break;
+      case "--openagents-api":
+        options.openAgentsApiBase = argv[++index];
+        if (!options.openAgentsApiBase) {
+          throw new Error("--openagents-api requires a value.");
+        }
+        break;
+      case "--openagents-agent-token":
+        options.openAgentsAgentToken = argv[++index];
+        if (!options.openAgentsAgentToken) {
+          throw new Error("--openagents-agent-token requires a value.");
+        }
+        break;
+      case "--pylon-ref":
+        options.openAgentsPylonRef = argv[++index];
+        if (!options.openAgentsPylonRef) {
+          throw new Error("--pylon-ref requires a value.");
+        }
+        break;
+      case "--pylon-display-name":
+        options.openAgentsPylonDisplayName = argv[++index];
+        if (!options.openAgentsPylonDisplayName) {
+          throw new Error("--pylon-display-name requires a value.");
+        }
+        break;
+      case "--resource-mode":
+        options.openAgentsResourceMode = argv[++index];
+        if (!options.openAgentsResourceMode) {
+          throw new Error("--resource-mode requires a value.");
+        }
+        break;
+      case "--capability-ref": {
+        const value = argv[++index];
+        if (!value) {
+          throw new Error("--capability-ref requires a value.");
+        }
+        options.openAgentsCapabilityRefs.push(
+          ...value
+            .split(",")
+            .map((entry) => entry.trim())
+            .filter(Boolean),
+        );
+        break;
+      }
+      case "--setup-mdk-wallet":
+        options.openAgentsSetupMdkWallet = true;
+        break;
+      case "--mdk-wallet-home":
+        options.openAgentsMdkWalletHome = argv[++index];
+        if (!options.openAgentsMdkWalletHome) {
+          throw new Error("--mdk-wallet-home requires a value.");
+        }
+        break;
+      case "--mdk-wallet-port":
+        options.openAgentsMdkWalletPort = parseIntegerFlag(
+          argv[++index],
+          "--mdk-wallet-port",
+        );
+        break;
+      case "--mdk-receive-amount-sats":
+        options.openAgentsMdkReceiveAmountSats = parseIntegerFlag(
+          argv[++index],
+          "--mdk-receive-amount-sats",
+        );
+        break;
       case "--repo":
         options.repo = argv[++index];
         if (!options.repo) {

package/src/index.js

@@ -15,6 +15,7 @@ export { createTelemetryClient } from "./telemetry.js";
 export const DEFAULT_RELEASE_REPO = "OpenAgentsInc/openagents";
 export const DEFAULT_RELEASE_API_BASE = "https://api.github.com";
 export const DEFAULT_RELEASE_GIT_BASE = "https://github.com";
+export const DEFAULT_OPENAGENTS_API_BASE = "https://openagents.com";
 export const DEFAULT_RUSTUP_INIT_URL = "https://sh.rustup.rs";
 export const DEFAULT_MODEL_ID = "gemma-4-e4b";
 export const DEFAULT_DIAGNOSTIC_REPEATS = 3;
@@ -26,6 +27,12 @@ const PYLON_RELEASE_TAG_PREFIX = "pylon-v";
 const RELEASE_ASSET_INSTALL_METHOD = "release_asset";
 const SOURCE_BUILD_INSTALL_METHOD = "source_build";
 const PREFERRED_RUNTIME_MODEL_NAME = "gemma4:e4b";
+const DEFAULT_PYLON_RESOURCE_MODE = "background_20";
+const DEFAULT_MDK_RECEIVE_AMOUNT_SATS = 1;
+const DEFAULT_PYLON_CAPABILITY_REFS = [
+  "capability.public.pylon_launcher",
+  "capability.public.inference",
+];
 const LEGACY_SOURCE_BUILD_SIBLING_REPOSITORIES = {
   "spark-sdk": "https://github.com/AtlantisPleb/spark-sdk.git",
 };
@@ -1549,6 +1556,407 @@ function isUnsupportedGemmaDiagnoseError(error) {
   );
 }
 
+function publicHash(value) {
+  return createHash("sha256").update(String(value)).digest("hex").slice(0, 16);
+}
+
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim() !== "") {
+      return value.trim();
+    }
+  }
+  return null;
+}
+
+function normalizePublicPylonRef(value) {
+  const normalized = String(value ?? "")
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9_.:-]+/g, "-")
+    .replace(/^[^a-z0-9]+/, "")
+    .slice(0, 120);
+
+  if (!normalized || normalized.length < 3) {
+    return null;
+  }
+
+  return normalized;
+}
+
+export function resolveOpenAgentsPylonRef({
+  explicitPylonRef = null,
+  init = null,
+  status = null,
+  configPath = null,
+  target = null,
+} = {}) {
+  const explicit = normalizePublicPylonRef(explicitPylonRef);
+  if (explicit) {
+    return explicit;
+  }
+
+  const source = firstString(
+    init?.pylon_ref,
+    init?.pylonRef,
+    init?.identity_ref,
+    init?.identityRef,
+    init?.node_id,
+    init?.nodeId,
+    init?.public_key,
+    init?.publicKey,
+    init?.identity?.pylon_ref,
+    init?.identity?.node_id,
+    init?.identity?.public_key,
+    status?.pylon_ref,
+    status?.pylonRef,
+    status?.node_id,
+    status?.nodeId,
+    status?.snapshot?.identity?.pylon_ref,
+    status?.snapshot?.identity?.node_id,
+    status?.snapshot?.identity?.public_key,
+    configPath,
+  );
+
+  if (!source) {
+    return null;
+  }
+
+  const platform = target?.os && target?.arch ? `${target.os}.${target.arch}` : "local";
+  return `pylon.${platform}.${publicHash(source)}`.slice(0, 120);
+}
+
+function statusLabelFromPylonStatus(status) {
+  const authoritative = firstString(
+    status?.snapshot?.runtime?.authoritative_status,
+    status?.snapshot?.runtime?.status,
+    status?.runtime?.authoritative_status,
+    status?.status,
+  );
+
+  if (!authoritative) {
+    return "not_ready";
+  }
+
+  const normalized = authoritative.toLowerCase();
+  if (normalized.includes("ready") || normalized.includes("online")) {
+    return "online";
+  }
+  if (normalized.includes("degraded")) {
+    return "degraded";
+  }
+  if (normalized.includes("blocked") || normalized.includes("error")) {
+    return "blocked";
+  }
+  return normalized.slice(0, 80);
+}
+
+function capabilityRefsFromOptions(options, inventory) {
+  const explicit = Array.isArray(options.openAgentsCapabilityRefs)
+    ? options.openAgentsCapabilityRefs
+    : [];
+  const refs = new Set(
+    [...DEFAULT_PYLON_CAPABILITY_REFS, ...explicit]
+      .map((ref) => String(ref).trim())
+      .filter(Boolean),
+  );
+
+  if (Array.isArray(inventory?.rows) && inventory.rows.length > 0) {
+    refs.add("capability.public.local_inventory_present");
+  }
+
+  return Array.from(refs);
+}
+
+async function postOpenAgentsJson({
+  fetchImpl,
+  url,
+  token,
+  idempotencyKey,
+  body,
+}) {
+  const response = await fetchImpl(url, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+      "Idempotency-Key": idempotencyKey,
+    },
+    body: JSON.stringify(body),
+  });
+  const text = await response.text();
+  const payload = text.trim() ? JSON.parse(text) : null;
+
+  if (!response.ok) {
+    const reason =
+      payload?.reason ??
+      payload?.error ??
+      `${response.status} ${response.statusText}`.trim();
+    throw new Error(`OpenAgents Pylon registration failed: ${reason}`);
+  }
+
+  return payload;
+}
+
+export async function registerPylonWithOpenAgents(
+  options,
+  {
+    init,
+    status,
+    inventory,
+    fetchImpl = globalThis.fetch,
+    onStatus = null,
+  } = {},
+) {
+  if (!options.openAgentsRegister) {
+    return null;
+  }
+
+  const token =
+    options.openAgentsAgentToken ??
+    process.env.OPENAGENTS_AGENT_TOKEN ??
+    process.env.OPENAGENTS_PYLON_AGENT_TOKEN;
+
+  if (!token) {
+    throw new Error(
+      "OpenAgents registration requires OPENAGENTS_AGENT_TOKEN or --openagents-agent-token.",
+    );
+  }
+
+  if (typeof fetchImpl !== "function") {
+    throw new Error("A fetch implementation is required for OpenAgents registration.");
+  }
+
+  const apiBase = (options.openAgentsApiBase ?? DEFAULT_OPENAGENTS_API_BASE)
+    .replace(/\/+$/, "");
+  const pylonRef = resolveOpenAgentsPylonRef({
+    explicitPylonRef: options.openAgentsPylonRef,
+    init,
+    status,
+    configPath: init?.config_path ?? options.configPath ?? null,
+    target: options.target,
+  });
+
+  if (!pylonRef) {
+    throw new Error(
+      "OpenAgents registration could not derive a stable public Pylon ref; pass --pylon-ref.",
+    );
+  }
+
+  const resourceMode =
+    options.openAgentsResourceMode ?? DEFAULT_PYLON_RESOURCE_MODE;
+  const displayName =
+    options.openAgentsPylonDisplayName ?? `Pylon ${pylonRef.slice(-8)}`;
+  const heartbeatStatus = statusLabelFromPylonStatus(status);
+
+  emitStatus(onStatus, "Registering Pylon with OpenAgents", pylonRef);
+  const registration = await postOpenAgentsJson({
+    fetchImpl,
+    url: `${apiBase}/api/pylons/register`,
+    token,
+    idempotencyKey: `pylon-register-${pylonRef}`,
+    body: {
+      capabilityRefs: capabilityRefsFromOptions(options, inventory),
+      displayName,
+      pylonRef,
+      resourceMode,
+      statusRefs: [
+        `status.public.${heartbeatStatus}`,
+        `release.public.${String(options.tagName ?? `pylon-v${options.version}`).replace(/[^A-Za-z0-9_.:/-]+/g, "_")}`,
+      ],
+    },
+  });
+
+  emitStatus(onStatus, "Sending OpenAgents Pylon heartbeat", heartbeatStatus);
+  const heartbeat = await postOpenAgentsJson({
+    fetchImpl,
+    url: `${apiBase}/api/pylons/${encodeURIComponent(pylonRef)}/heartbeat`,
+    token,
+    idempotencyKey: `pylon-heartbeat-${pylonRef}-${Math.floor(Date.now() / 60_000)}`,
+    body: {
+      capacityRefs: ["capacity.public.launcher_smoke"],
+      healthRefs: [`health.public.${heartbeatStatus}`],
+      resourceMode,
+      status: heartbeatStatus,
+    },
+  });
+
+  return {
+    apiBase,
+    pylonRef,
+    resourceMode,
+    status: heartbeatStatus,
+    registration: {
+      idempotent: Boolean(registration?.idempotent),
+      publicUrl: `${apiBase}/api/pylons/${encodeURIComponent(pylonRef)}`,
+    },
+    heartbeat: {
+      idempotent: Boolean(heartbeat?.idempotent),
+    },
+  };
+}
+
+function buildMdkAgentWalletEnv(options = {}) {
+  const env = { ...process.env };
+  if (options.openAgentsMdkWalletHome) {
+    env.HOME = path.resolve(options.openAgentsMdkWalletHome);
+  }
+  if (options.openAgentsMdkWalletPort) {
+    env.MDK_WALLET_PORT = String(options.openAgentsMdkWalletPort);
+  }
+  return env;
+}
+
+async function runMdkAgentWalletJson(args, options, runProcessImpl) {
+  const { stdout } = await runProcessImpl(
+    "npx",
+    ["-y", "@moneydevkit/agent-wallet@latest", ...args],
+    { env: buildMdkAgentWalletEnv(options) },
+  );
+  try {
+    return JSON.parse(stdout);
+  } catch (error) {
+    throw new Error(
+      `MDK agent wallet returned invalid JSON for \`agent-wallet ${args.join(" ")}\`: ${
+        error instanceof Error ? error.message : String(error)
+      }`,
+    );
+  }
+}
+
+export async function setupMdkWalletReadinessForOpenAgentsPylon(
+  options,
+  {
+    fetchImpl = globalThis.fetch,
+    init = null,
+    status = null,
+    registration = null,
+    runProcessImpl = runProcess,
+    onStatus = null,
+  } = {},
+) {
+  if (!options.openAgentsSetupMdkWallet) {
+    return null;
+  }
+
+  const token =
+    options.openAgentsAgentToken ??
+    process.env.OPENAGENTS_AGENT_TOKEN ??
+    process.env.OPENAGENTS_PYLON_AGENT_TOKEN;
+
+  if (!token) {
+    throw new Error(
+      "MDK wallet readiness reporting requires OPENAGENTS_AGENT_TOKEN or --openagents-agent-token.",
+    );
+  }
+
+  const pylonRef =
+    registration?.pylonRef ??
+    resolveOpenAgentsPylonRef({
+      explicitPylonRef: options.openAgentsPylonRef,
+      init,
+      status,
+      configPath: init?.config_path ?? options.configPath ?? null,
+      target: options.target,
+    });
+
+  if (!pylonRef) {
+    throw new Error(
+      "MDK wallet readiness could not derive a stable public Pylon ref; pass --pylon-ref.",
+    );
+  }
+
+  const apiBase = (options.openAgentsApiBase ?? DEFAULT_OPENAGENTS_API_BASE)
+    .replace(/\/+$/, "");
+  const receiveAmount = Number.isFinite(options.openAgentsMdkReceiveAmountSats)
+    ? options.openAgentsMdkReceiveAmountSats
+    : DEFAULT_MDK_RECEIVE_AMOUNT_SATS;
+
+  emitStatus(onStatus, "Preparing MDK agent wallet readiness", pylonRef);
+  let walletInit;
+  try {
+    walletInit = await runMdkAgentWalletJson(["init", "--show"], options, runProcessImpl);
+  } catch {
+    walletInit = await runMdkAgentWalletJson(["init"], options, runProcessImpl);
+  }
+
+  const balance = await runMdkAgentWalletJson(["balance"], options, runProcessImpl);
+  const receive = await runMdkAgentWalletJson(
+    [
+      "receive",
+      String(receiveAmount),
+      "--description",
+      `OpenAgents Pylon readiness ${pylonRef}`,
+    ],
+    options,
+    runProcessImpl,
+  );
+
+  const walletRef = `wallet.public.mdk_agent_wallet.${publicHash(
+    firstString(walletInit?.walletId, walletInit?.wallet_id, pylonRef) ?? pylonRef,
+  )}`;
+  const receiveRef = `receive.redacted.mdk_agent_wallet.${publicHash(
+    firstString(receive?.invoice, receive?.payment_hash, receive?.paymentHash, pylonRef) ?? pylonRef,
+  )}`;
+  const payoutTargetRef = `payout_target.public.mdk_agent_wallet.${publicHash(
+    `${pylonRef}:${receiveRef}`,
+  )}`;
+  const balanceReady =
+    typeof balance?.balance_sats === "number" && balance.balance_sats > 0
+      ? "balance.mdk_agent_wallet.minimum_satisfied"
+      : "balance.mdk_agent_wallet.minimum_not_satisfied";
+
+  emitStatus(onStatus, "Reporting MDK wallet readiness", pylonRef);
+  const walletReadiness = await postOpenAgentsJson({
+    fetchImpl,
+    url: `${apiBase}/api/pylons/${encodeURIComponent(pylonRef)}/wallet-readiness`,
+    token,
+    idempotencyKey: `pylon-wallet-readiness-${pylonRef}-${receiveRef}`,
+    body: {
+      balanceRefs: [balanceReady],
+      liquidityRefs: ["liquidity.public.receive_ready"],
+      readinessRefs: [
+        "readiness.public.mdk_agent_wallet_initialized",
+        "readiness.public.mdk_agent_wallet_receive_ready",
+        receiveRef,
+      ],
+      status: "ready",
+      walletReady: true,
+      walletRef,
+    },
+  });
+
+  emitStatus(onStatus, "Requesting OpenAgents payout-target admission", pylonRef);
+  const payoutTargetAdmission = await postOpenAgentsJson({
+    fetchImpl,
+    url: `${apiBase}/api/pylons/${encodeURIComponent(pylonRef)}/payout-target-admission`,
+    token,
+    idempotencyKey: `pylon-payout-target-${pylonRef}-${payoutTargetRef}`,
+    body: {
+      admissionRefs: ["admission.public.requested", receiveRef],
+      payoutTargetRef,
+      policyRefs: ["policy.public.operator_review_required"],
+      status: "requested",
+    },
+  });
+
+  return {
+    pylonRef,
+    walletReady: true,
+    walletRef,
+    receiveRef,
+    payoutTargetRef,
+    balanceReadinessRef: balanceReady,
+    walletReadiness: {
+      idempotent: Boolean(walletReadiness?.idempotent),
+    },
+    payoutTargetAdmission: {
+      idempotent: Boolean(payoutTargetAdmission?.idempotent),
+      status: "requested",
+    },
+  };
+}
+
 export async function ensureReleaseInstall(
   options = {},
   {
@@ -1879,6 +2287,7 @@ export async function ensureReleaseInstall(
 export async function bootstrapInstalledPylon(
   options,
   {
+    fetchImpl = globalThis.fetch,
     runProcessImpl = runProcess,
     onStatus = null,
     telemetryClient = null,
@@ -1928,6 +2337,25 @@ export async function bootstrapInstalledPylon(
       runProcessImpl,
     );
 
+    const openAgentsRegistration = await registerPylonWithOpenAgents(options, {
+      fetchImpl,
+      init,
+      inventory,
+      onStatus,
+      status,
+    });
+    const openAgentsMdkWallet = await setupMdkWalletReadinessForOpenAgentsPylon(
+      options,
+      {
+        fetchImpl,
+        init,
+        onStatus,
+        registration: openAgentsRegistration,
+        runProcessImpl,
+        status,
+      },
+    );
+
     let download = null;
     if (!skipModelDownload) {
       emitStatus(onStatus, "Downloading curated model bundle", model);
@@ -2025,6 +2453,8 @@ export async function bootstrapInstalledPylon(
       init,
       status,
       inventory,
+      openAgentsRegistration,
+      openAgentsMdkWallet,
       model,
       download,
       diagnostic,