@elizaos/plugin-steward-app 2.0.3-beta.5 → 2.0.3-beta.7

package/dist/routes/steward-bridge.js

@@ -0,0 +1,776 @@
+import { loadElizaConfig } from "@elizaos/agent/config/config";
+import {
+  loadStewardCredentials,
+  resolveEffectiveStewardConfig,
+  saveStewardCredentials
+} from "@elizaos/app-core/services/steward-credentials";
+import { fingerprintRandomToken } from "@elizaos/app-core/services/steward-sidecar/helpers";
+import {
+  StewardApiError,
+  StewardClient
+} from "@stwd/sdk";
+import { fetchSolanaNativeBalanceViaRpc } from "../api/wallet.js";
+import { fetchEvmNativeBalanceViaRpc } from "../api/wallet-evm-balance.js";
+import { resolveWalletRpcReadiness } from "../api/wallet-rpc.js";
+function normalizeEnvValue(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed || null;
+}
+function resolveStewardConnection(env = process.env) {
+  const persisted = resolveEffectiveStewardConfig(env);
+  const baseUrl = normalizeEnvValue(env.STEWARD_API_URL) ?? normalizeEnvValue(persisted?.apiUrl) ?? null;
+  const apiKey = normalizeEnvValue(env.STEWARD_API_KEY) ?? normalizeEnvValue(persisted?.apiKey) ?? null;
+  const tenantId = normalizeEnvValue(env.STEWARD_TENANT_ID) ?? normalizeEnvValue(persisted?.tenantId) ?? null;
+  const agentId = normalizeEnvValue(env.STEWARD_AGENT_ID) ?? normalizeEnvValue(env.ELIZA_STEWARD_AGENT_ID) ?? normalizeEnvValue(persisted?.agentId) ?? null;
+  const agentToken = normalizeEnvValue(env.STEWARD_AGENT_TOKEN) ?? normalizeEnvValue(persisted?.agentToken) ?? null;
+  return {
+    baseUrl,
+    apiKey,
+    tenantId,
+    bearerToken: apiKey ? null : agentToken,
+    agentId
+  };
+}
+function resolveStewardRpcReadinessSafe() {
+  try {
+    return resolveWalletRpcReadiness(loadElizaConfig());
+  } catch {
+    return null;
+  }
+}
+function firstRpcUrl(urls) {
+  return urls.find((candidate) => typeof candidate === "string" && candidate.trim())?.trim() ?? null;
+}
+function resolveEvmNativeBalanceFallback(chainId, readiness) {
+  switch (chainId) {
+    case 1: {
+      const rpcUrl = firstRpcUrl(readiness.ethereumRpcUrls);
+      return rpcUrl ? { rpcUrl, symbol: "ETH", chainId } : null;
+    }
+    case 8453: {
+      const rpcUrl = firstRpcUrl(readiness.baseRpcUrls);
+      return rpcUrl ? { rpcUrl, symbol: "ETH", chainId } : null;
+    }
+    case 56:
+    case 97: {
+      const rpcUrl = firstRpcUrl(readiness.bscRpcUrls);
+      return rpcUrl ? { rpcUrl, symbol: "BNB", chainId } : null;
+    }
+    case 43114: {
+      const rpcUrl = firstRpcUrl(readiness.avalancheRpcUrls);
+      return rpcUrl ? { rpcUrl, symbol: "AVAX", chainId } : null;
+    }
+    default:
+      return null;
+  }
+}
+function resolveStewardAgentId(env = process.env, evmAddress) {
+  return resolveStewardConnection(env).agentId ?? evmAddress?.trim() ?? null;
+}
+function createStewardClient(options = {}) {
+  if (options.client !== void 0) {
+    return options.client;
+  }
+  const env = options.env ?? process.env;
+  const connection = resolveStewardConnection(env);
+  const baseUrl = connection.baseUrl;
+  if (!baseUrl) {
+    return null;
+  }
+  return new StewardClient({
+    baseUrl,
+    bearerToken: connection.bearerToken ?? void 0,
+    apiKey: connection.apiKey ?? void 0,
+    tenantId: connection.tenantId ?? void 0
+  });
+}
+async function getStewardBridgeStatus(options = {}) {
+  const env = options.env ?? process.env;
+  const baseUrl = normalizeEnvValue(env.STEWARD_API_URL);
+  const evmAddress = options.evmAddress ?? null;
+  const agentId = options.agentId ?? resolveStewardAgentId(env, evmAddress);
+  const client = createStewardClient(options);
+  if (!baseUrl || !client) {
+    const persisted = resolveEffectiveStewardConfig(env);
+    if (!persisted?.apiUrl) {
+      return {
+        configured: false,
+        available: false,
+        connected: false,
+        baseUrl,
+        agentId,
+        evmAddress,
+        error: null
+      };
+    }
+    const fallbackClient = new StewardClient({
+      baseUrl: persisted.apiUrl,
+      bearerToken: persisted.agentToken || void 0,
+      apiKey: persisted.apiKey || void 0,
+      tenantId: persisted.tenantId || void 0
+    });
+    const fallbackAgentId = persisted.agentId || agentId;
+    if (!fallbackClient || !fallbackAgentId) {
+      return {
+        configured: false,
+        available: false,
+        connected: false,
+        baseUrl: persisted.apiUrl,
+        agentId: fallbackAgentId,
+        evmAddress,
+        error: null
+      };
+    }
+    try {
+      let agentData = null;
+      if (fallbackAgentId) {
+        try {
+          agentData = await fallbackClient.getAgent(
+            fallbackAgentId
+          );
+        } catch (error) {
+          if (!(error instanceof StewardApiError) || error.status !== 404 && error.status !== 400) {
+            throw error;
+          }
+        }
+      }
+      const walletAddresses = agentData ? {
+        evm: agentData.walletAddresses?.evm?.trim() || agentData.walletAddress?.trim() || null,
+        solana: agentData.walletAddresses?.solana?.trim() || null
+      } : void 0;
+      return {
+        configured: true,
+        available: true,
+        connected: true,
+        baseUrl: persisted.apiUrl,
+        agentId: fallbackAgentId,
+        evmAddress: walletAddresses?.evm ?? evmAddress,
+        error: null,
+        walletAddresses,
+        agentName: agentData?.name || void 0,
+        vaultHealth: fallbackAgentId && !agentData ? "degraded" : "ok"
+      };
+    } catch (error) {
+      return {
+        configured: true,
+        available: false,
+        connected: false,
+        baseUrl: persisted.apiUrl,
+        agentId: fallbackAgentId,
+        evmAddress,
+        error: formatStewardError(error),
+        vaultHealth: "error"
+      };
+    }
+  }
+  try {
+    let agentData = null;
+    if (agentId) {
+      try {
+        agentData = await client.getAgent(agentId);
+      } catch (error) {
+        if (!(error instanceof StewardApiError) || error.status !== 404 && error.status !== 400) {
+          throw error;
+        }
+      }
+    } else {
+      await client.listAgents();
+    }
+    const walletAddresses = agentData ? {
+      evm: agentData.walletAddresses?.evm?.trim() || agentData.walletAddress?.trim() || null,
+      solana: agentData.walletAddresses?.solana?.trim() || null
+    } : void 0;
+    const agentName = agentData?.name || void 0;
+    let vaultHealth = "ok";
+    if (agentId && !agentData) {
+      vaultHealth = "degraded";
+    }
+    return {
+      configured: true,
+      available: true,
+      connected: true,
+      baseUrl,
+      agentId,
+      evmAddress: walletAddresses?.evm ?? evmAddress,
+      error: null,
+      walletAddresses,
+      agentName,
+      vaultHealth
+    };
+  } catch (error) {
+    return {
+      configured: true,
+      available: false,
+      connected: false,
+      baseUrl,
+      agentId,
+      evmAddress,
+      error: formatStewardError(error),
+      vaultHealth: "error"
+    };
+  }
+}
+function isStewardConfigured(env = process.env) {
+  const connection = resolveStewardConnection(env);
+  return Boolean(connection.baseUrl && connection.agentId);
+}
+function formatStewardError(error) {
+  if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
+    return error.message;
+  }
+  return String(error);
+}
+async function signTransactionWithOptionalSteward(params) {
+  const env = params.env ?? process.env;
+  const evmAddress = params.evmAddress ?? null;
+  const agentId = params.agentId ?? resolveStewardAgentId(env, evmAddress) ?? null;
+  const client = createStewardClient({
+    env,
+    evmAddress,
+    agentId,
+    client: params.client
+  });
+  if (!client || !agentId) {
+    throw new Error(
+      "Steward credentials and agent ID must be provided to sign transactions."
+    );
+  }
+  const tx = params.tx;
+  if (!tx || typeof tx !== "object") {
+    throw new Error("Transaction input is required and must be an object.");
+  }
+  if (!("to" in tx) || typeof tx.to !== "string" || !tx.to.trim()) {
+    throw new Error("Transaction must include a valid 'to' address.");
+  }
+  const result = await client.signTransaction(agentId, tx);
+  if ("txHash" in result) {
+    return {
+      mode: "steward",
+      pendingApproval: false,
+      txHash: result.txHash
+    };
+  }
+  if ("results" in result) {
+    return {
+      mode: "steward",
+      pendingApproval: true,
+      policyResults: result.results
+    };
+  }
+  throw new Error("Steward returned an unsigned transaction unexpectedly");
+}
+async function getStewardWalletAddresses(options = {}) {
+  const env = options.env ?? process.env;
+  const evmAddr = options.evmAddress ?? null;
+  const agentId = options.agentId ?? resolveStewardAgentId(env, evmAddr) ?? null;
+  const client = createStewardClient(options);
+  if (!client || !agentId) {
+    return { evmAddress: null, solanaAddress: null };
+  }
+  const agent = await client.getAgent(agentId);
+  const evmAddress = agent.walletAddresses?.evm?.trim() || agent.walletAddress?.trim() || null;
+  const solanaAddress = agent.walletAddresses?.solana?.trim() || null;
+  return { evmAddress, solanaAddress };
+}
+async function getStewardBalance(agentId, chainId, options = {}) {
+  const client = createStewardClient(options);
+  if (!client) throw new Error("Steward not configured");
+  try {
+    const result = await client.getBalance(agentId, chainId);
+    return {
+      balance: result.balances.native,
+      formatted: result.balances.nativeFormatted,
+      symbol: result.balances.symbol,
+      chainId: result.balances.chainId
+    };
+  } catch (error) {
+    const readiness = resolveStewardRpcReadinessSafe();
+    const walletAddresses = await getStewardWalletAddresses({
+      ...options,
+      agentId
+    });
+    if (chainId === 101 && walletAddresses.solanaAddress && readiness && readiness.solanaRpcUrls.length > 0) {
+      const result = await fetchSolanaNativeBalanceViaRpc(
+        walletAddresses.solanaAddress,
+        readiness.solanaRpcUrls
+      );
+      return {
+        balance: result.solBalance,
+        formatted: result.solBalance,
+        symbol: "SOL",
+        chainId
+      };
+    }
+    const evmFallback = readiness && chainId != null ? resolveEvmNativeBalanceFallback(chainId, readiness) : null;
+    if (evmFallback && walletAddresses.evmAddress) {
+      const balance = await fetchEvmNativeBalanceViaRpc(
+        evmFallback.rpcUrl,
+        walletAddresses.evmAddress
+      );
+      return {
+        balance,
+        formatted: balance,
+        symbol: evmFallback.symbol,
+        chainId: evmFallback.chainId
+      };
+    }
+    throw error;
+  }
+}
+async function getStewardTokenBalances(agentId, chainId, options = {}) {
+  const env = options.env ?? process.env;
+  const baseUrl = getStewardBaseUrl(env);
+  if (!baseUrl) throw new Error("Steward not configured");
+  const headers = buildStewardHeaders(env);
+  const qs = chainId != null ? `?chainId=${encodeURIComponent(chainId)}` : "";
+  try {
+    const res = await fetch(
+      `${baseUrl}/agents/${encodeURIComponent(agentId)}/tokens${qs}`,
+      { headers }
+    );
+    if (!res.ok) {
+      const errText = await res.text().catch(() => "Unknown error");
+      throw new Error(
+        `Steward token balances failed (${res.status}): ${errText}`
+      );
+    }
+    const body = await res.json();
+    return body.data ?? {
+      native: {
+        balance: "0",
+        formatted: "0",
+        symbol: "???",
+        chainId: chainId ?? 0
+      },
+      tokens: []
+    };
+  } catch (error) {
+    const readiness = resolveStewardRpcReadinessSafe();
+    const walletAddresses = await getStewardWalletAddresses({
+      ...options,
+      agentId
+    });
+    if (chainId === 101 && walletAddresses.solanaAddress && readiness && readiness.solanaRpcUrls.length > 0) {
+      const native = await fetchSolanaNativeBalanceViaRpc(
+        walletAddresses.solanaAddress,
+        readiness.solanaRpcUrls
+      );
+      return {
+        native: {
+          balance: native.solBalance,
+          formatted: native.solBalance,
+          symbol: "SOL",
+          chainId
+        },
+        tokens: []
+      };
+    }
+    const evmFallback = readiness && chainId != null ? resolveEvmNativeBalanceFallback(chainId, readiness) : null;
+    if (evmFallback && walletAddresses.evmAddress) {
+      const nativeBalance = await fetchEvmNativeBalanceViaRpc(
+        evmFallback.rpcUrl,
+        walletAddresses.evmAddress
+      );
+      return {
+        native: {
+          balance: nativeBalance,
+          formatted: nativeBalance,
+          symbol: evmFallback.symbol,
+          chainId: evmFallback.chainId
+        },
+        tokens: []
+      };
+    }
+    throw error;
+  }
+}
+function buildStewardHeaders(env = process.env) {
+  const headers = new Headers();
+  headers.set("Content-Type", "application/json");
+  headers.set("Accept", "application/json");
+  const connection = resolveStewardConnection(env);
+  const bearerToken = connection.bearerToken;
+  const apiKey = connection.apiKey;
+  const tenantId = connection.tenantId;
+  if (bearerToken) {
+    headers.set("Authorization", `Bearer ${bearerToken}`);
+  } else if (apiKey) {
+    headers.set("X-Steward-Key", apiKey);
+  }
+  if (tenantId) {
+    headers.set("X-Steward-Tenant", tenantId);
+  }
+  return headers;
+}
+function getStewardBaseUrl(env = process.env) {
+  return resolveStewardConnection(env).baseUrl;
+}
+async function getStewardPendingApprovals(agentId, env = process.env) {
+  const baseUrl = getStewardBaseUrl(env);
+  if (!baseUrl) throw new Error("Steward not configured");
+  const headers = buildStewardHeaders(env);
+  const res = await fetch(
+    `${baseUrl}/vault/${encodeURIComponent(agentId)}/pending`,
+    { headers }
+  );
+  if (res.status === 404) return [];
+  if (!res.ok) {
+    const errText = await res.text().catch(() => "Unknown error");
+    throw new Error(
+      `Steward pending approvals failed (${res.status}): ${errText}`
+    );
+  }
+  const body = await res.json();
+  return body.data ?? body ?? [];
+}
+async function approveStewardTransaction(agentId, txId, env = process.env) {
+  const baseUrl = getStewardBaseUrl(env);
+  if (!baseUrl) throw new Error("Steward not configured");
+  const headers = buildStewardHeaders(env);
+  const res = await fetch(
+    `${baseUrl}/vault/${encodeURIComponent(agentId)}/approve/${encodeURIComponent(txId)}`,
+    { method: "POST", headers }
+  );
+  if (!res.ok) {
+    const errText = await res.text().catch(() => "Unknown error");
+    throw new Error(`Steward approve failed (${res.status}): ${errText}`);
+  }
+  const body = await res.json();
+  return body.data ?? body;
+}
+async function denyStewardTransaction(agentId, txId, reason, env = process.env) {
+  const baseUrl = getStewardBaseUrl(env);
+  if (!baseUrl) throw new Error("Steward not configured");
+  const headers = buildStewardHeaders(env);
+  const reqBody = {};
+  if (reason) reqBody.reason = reason;
+  const res = await fetch(
+    `${baseUrl}/vault/${encodeURIComponent(agentId)}/reject/${encodeURIComponent(txId)}`,
+    { method: "POST", headers, body: JSON.stringify(reqBody) }
+  );
+  if (!res.ok) {
+    const errText = await res.text().catch(() => "Unknown error");
+    throw new Error(`Steward deny failed (${res.status}): ${errText}`);
+  }
+  const body = await res.json().catch(() => ({}));
+  return body.data ?? body ?? { txId };
+}
+async function getStewardHistory(agentId, opts, env = process.env) {
+  const baseUrl = getStewardBaseUrl(env);
+  if (!baseUrl) throw new Error("Steward not configured");
+  const headers = buildStewardHeaders(env);
+  const params = new URLSearchParams();
+  if (opts?.limit != null) params.set("limit", String(opts.limit));
+  if (opts?.offset != null) params.set("offset", String(opts.offset));
+  const qs = params.toString() ? `?${params.toString()}` : "";
+  const res = await fetch(
+    `${baseUrl}/vault/${encodeURIComponent(agentId)}/history${qs}`,
+    { headers }
+  );
+  if (!res.ok) {
+    const errText = await res.text().catch(() => "Unknown error");
+    throw new Error(`Steward history failed (${res.status}): ${errText}`);
+  }
+  const body = await res.json();
+  return body.data ?? body ?? [];
+}
+async function provisionStewardWallet(params) {
+  const env = params.env ?? process.env;
+  const client = createStewardClient({ env });
+  if (!client) {
+    throw new Error("Steward not configured \u2014 cannot provision wallet");
+  }
+  const identity = await client.createWallet(
+    params.agentId,
+    params.agentName,
+    params.platformId
+  );
+  if (params.defaultPolicies && params.defaultPolicies.length > 0) {
+    await client.setPolicies(params.agentId, params.defaultPolicies);
+  }
+  return { walletAddress: identity.walletAddress };
+}
+async function signViaSteward(request, env = process.env) {
+  const baseUrl = getStewardBaseUrl(env);
+  if (!baseUrl) throw new Error("Steward not configured");
+  const evmAddress = normalizeEnvValue(env.EVM_ADDRESS) ?? normalizeEnvValue(env.ELIZA_EVM_ADDRESS) ?? null;
+  const agentId = resolveStewardAgentId(env, evmAddress);
+  if (!agentId) throw new Error("Steward agent ID not resolved");
+  const headers = buildStewardHeaders(env);
+  const res = await fetch(
+    `${baseUrl}/vault/${encodeURIComponent(agentId)}/sign`,
+    {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        to: request.to,
+        value: request.value,
+        chainId: request.chainId,
+        data: request.data,
+        broadcast: request.broadcast ?? true,
+        description: request.description
+      })
+    }
+  );
+  const body = await res.json().catch(() => ({}));
+  if (res.ok && body.ok === true) {
+    const data = body.data ?? {};
+    return {
+      approved: true,
+      txHash: typeof data.txHash === "string" ? data.txHash : void 0
+    };
+  }
+  if (res.status === 202) {
+    const data = body.data ?? {};
+    return {
+      approved: false,
+      pending: true,
+      txId: typeof data.txId === "string" ? data.txId : void 0,
+      violations: normalizeViolations(data.violations)
+    };
+  }
+  if (res.status === 403) {
+    const data = body.data ?? {};
+    return {
+      approved: false,
+      denied: true,
+      violations: normalizeViolations(data.violations)
+    };
+  }
+  const errMsg = typeof body.error === "string" ? body.error : `Steward sign failed (${res.status})`;
+  throw new Error(errMsg);
+}
+function normalizeViolations(raw) {
+  if (!Array.isArray(raw)) return void 0;
+  return raw.filter(
+    (v) => !!v && typeof v === "object" && typeof v.policy === "string" && typeof v.reason === "string"
+  ).map((v) => ({ policy: v.policy, reason: v.reason }));
+}
+const MAX_WEBHOOK_EVENTS = 200;
+const recentWebhookEvents = [];
+function pushWebhookEvent(event) {
+  recentWebhookEvents.push(event);
+  if (recentWebhookEvents.length > MAX_WEBHOOK_EVENTS) {
+    recentWebhookEvents.splice(
+      0,
+      recentWebhookEvents.length - MAX_WEBHOOK_EVENTS
+    );
+  }
+}
+function getRecentWebhookEvents(eventType, sinceIndex = 0) {
+  const all = eventType ? recentWebhookEvents.filter((e) => e.event === eventType) : recentWebhookEvents;
+  const events = all.slice(sinceIndex);
+  return { events, nextIndex: recentWebhookEvents.length };
+}
+async function registerStewardWebhook(webhookUrl, env = process.env) {
+  const baseUrl = getStewardBaseUrl(env);
+  if (!baseUrl) throw new Error("Steward not configured");
+  const tenantId = normalizeEnvValue(env.STEWARD_TENANT_ID);
+  if (!tenantId)
+    throw new Error("STEWARD_TENANT_ID not set \u2014 cannot register webhook");
+  const headers = buildStewardHeaders(env);
+  const res = await fetch(
+    `${baseUrl}/tenants/${encodeURIComponent(tenantId)}`,
+    {
+      method: "PUT",
+      headers,
+      body: JSON.stringify({ webhookUrl })
+    }
+  );
+  if (!res.ok) {
+    const errText = await res.text().catch(() => "Unknown error");
+    throw new Error(
+      `Steward webhook registration failed (${res.status}): ${errText}`
+    );
+  }
+}
+async function tryRegisterStewardWebhook(port = Number(
+  process.env.ELIZA_API_PORT?.trim() || process.env.ELIZA_PORT?.trim() || "31337"
+) || 31337, env = process.env) {
+  if (!isStewardConfigured(env)) return;
+  const webhookUrl = `http://127.0.0.1:${port}/api/wallet/steward-webhook`;
+  try {
+    await registerStewardWebhook(webhookUrl, env);
+    console.info(`[steward] Webhook registered: ${webhookUrl}`);
+  } catch (err) {
+    console.warn(
+      `[steward] Webhook registration failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+let ensureStewardAgentPromise = null;
+function ensureStewardAgent(options = {}) {
+  if (!ensureStewardAgentPromise) {
+    ensureStewardAgentPromise = doEnsureStewardAgent(options);
+  }
+  return ensureStewardAgentPromise;
+}
+async function doEnsureStewardAgent(options = {}) {
+  const env = options.env ?? process.env;
+  const baseUrl = normalizeEnvValue(env.STEWARD_API_URL);
+  if (!baseUrl) {
+    return null;
+  }
+  const agentId = options.agentId ?? resolveStewardAgentId(env) ?? null;
+  if (!agentId) {
+    return null;
+  }
+  const agentName = options.agentName ?? agentId;
+  try {
+    const client = createStewardClient({ env });
+    if (!client) {
+      return null;
+    }
+    try {
+      const agent = await client.getAgent(agentId);
+      const result2 = {
+        agentId,
+        agentName: agent.name || agentName,
+        walletAddresses: {
+          evm: agent.walletAddresses?.evm?.trim() || agent.walletAddress?.trim() || null,
+          solana: agent.walletAddresses?.solana?.trim() || null
+        },
+        created: false
+      };
+      persistAgentCredentials(baseUrl, env, result2);
+      return result2;
+    } catch (err) {
+      if (!(err instanceof StewardApiError) || err.status !== 404) {
+        throw err;
+      }
+    }
+    console.info(`[steward] Agent "${agentId}" not found, creating...`);
+    const tenantId = normalizeEnvValue(env.STEWARD_TENANT_ID);
+    const apiKey = normalizeEnvValue(env.STEWARD_API_KEY);
+    if (tenantId && apiKey) {
+      try {
+        const tenantRes = await fetch(`${baseUrl}/tenants`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "X-Api-Key": normalizeEnvValue(env.STEWARD_MASTER_PASSWORD) ?? ""
+          },
+          body: JSON.stringify({
+            id: tenantId,
+            name: "Desktop",
+            apiKeyHash: fingerprintRandomToken(apiKey)
+          })
+        });
+        if (!tenantRes.ok) {
+          const body = await tenantRes.json().catch(() => ({}));
+          if (!body.error?.includes("already exists")) {
+            console.warn(
+              `[steward] Tenant creation returned ${tenantRes.status}: ${body.error}`
+            );
+          }
+        }
+      } catch (tenantErr) {
+        console.warn(
+          `[steward] Tenant creation failed (non-fatal): ${tenantErr instanceof Error ? tenantErr.message : String(tenantErr)}`
+        );
+      }
+    }
+    const headers = buildStewardHeaders(env);
+    const agentRes = await fetch(`${baseUrl}/agents`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ id: agentId, name: agentName })
+    });
+    if (!agentRes.ok) {
+      const errText = await agentRes.text().catch(() => "Unknown error");
+      console.warn(
+        `[steward] Agent creation failed (${agentRes.status}): ${errText}`
+      );
+      return null;
+    }
+    const agentBody = await agentRes.json();
+    if (!agentBody.ok || !agentBody.data) {
+      console.warn("[steward] Agent creation returned unexpected response");
+      return null;
+    }
+    let agentToken = "";
+    try {
+      const tokenRes = await fetch(
+        `${baseUrl}/agents/${encodeURIComponent(agentId)}/token`,
+        { method: "POST", headers }
+      );
+      if (tokenRes.ok) {
+        const tokenBody = await tokenRes.json();
+        agentToken = tokenBody.data?.token ?? "";
+      }
+    } catch {
+      console.warn("[steward] Token generation failed (non-fatal)");
+    }
+    const result = {
+      agentId,
+      agentName,
+      walletAddresses: {
+        evm: agentBody.data.walletAddresses?.evm?.trim() || agentBody.data.walletAddress?.trim() || null,
+        solana: agentBody.data.walletAddresses?.solana?.trim() || null
+      },
+      created: true
+    };
+    console.info(
+      `[steward] Agent "${agentId}" created with wallet ${result.walletAddresses.evm ?? "(none)"}`
+    );
+    persistAgentCredentials(baseUrl, env, result, agentToken);
+    return result;
+  } catch (err) {
+    console.warn(
+      `[steward] Auto-setup failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`
+    );
+    return null;
+  }
+}
+function persistAgentCredentials(apiUrl, env, result, agentToken) {
+  try {
+    const existing = loadStewardCredentials();
+    saveStewardCredentials({
+      apiUrl,
+      tenantId: normalizeEnvValue(env.STEWARD_TENANT_ID) ?? existing?.tenantId ?? "",
+      agentId: result.agentId,
+      apiKey: normalizeEnvValue(env.STEWARD_API_KEY) ?? existing?.apiKey ?? "",
+      agentToken: agentToken ?? normalizeEnvValue(env.STEWARD_AGENT_TOKEN) ?? existing?.agentToken ?? "",
+      walletAddresses: {
+        evm: result.walletAddresses.evm ?? void 0,
+        solana: result.walletAddresses.solana ?? void 0
+      },
+      agentName: result.agentName
+    });
+  } catch (credErr) {
+    console.warn(
+      `[steward] Failed to persist credentials (non-fatal): ${credErr instanceof Error ? credErr.message : String(credErr)}`
+    );
+  }
+}
+function __resetStewardAgentEnsured() {
+  ensureStewardAgentPromise = null;
+}
+export {
+  __resetStewardAgentEnsured,
+  approveStewardTransaction,
+  buildStewardHeaders,
+  createStewardClient,
+  denyStewardTransaction,
+  ensureStewardAgent,
+  formatStewardError,
+  getRecentWebhookEvents,
+  getStewardBalance,
+  getStewardBridgeStatus,
+  getStewardHistory,
+  getStewardPendingApprovals,
+  getStewardTokenBalances,
+  getStewardWalletAddresses,
+  isStewardConfigured,
+  provisionStewardWallet,
+  pushWebhookEvent,
+  registerStewardWebhook,
+  resolveStewardAgentId,
+  signTransactionWithOptionalSteward,
+  signViaSteward,
+  tryRegisterStewardWebhook
+};
+//# sourceMappingURL=steward-bridge.js.map