@agentlayer.tech/wallet 0.1.9 → 0.1.11

package/agent-wallet/agent_wallet/providers/jupiter.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import json
 import os
 from typing import Any
 
@@ -54,6 +55,38 @@ def _gateway_route_missing(status_code: int, payload: Any) -> bool:
     return False
 
 
+async def _gateway_get(path_suffix: str, *, params: dict[str, Any] | None = None) -> tuple[int, Any]:
+    """Make a GET request through provider gateway."""
+    client = get_client()
+    response = await client.get(
+        f"{_gateway_base_url()}/v1/jupiter/swap/{path_suffix}",
+        params=params,
+        headers=_gateway_headers(),
+    )
+    if not response.content:
+        return response.status_code, {}
+    try:
+        return response.status_code, response.json()
+    except ValueError:
+        return response.status_code, response.text[:500]
+
+
+async def _gateway_post(path_suffix: str, *, body: dict[str, Any]) -> tuple[int, Any]:
+    """Make a POST request through provider gateway."""
+    client = get_client()
+    response = await client.post(
+        f"{_gateway_base_url()}/v1/jupiter/swap/{path_suffix}",
+        json=body,
+        headers={**_gateway_headers(), "Content-Type": "application/json"},
+    )
+    if not response.content:
+        return response.status_code, {}
+    try:
+        return response.status_code, response.json()
+    except ValueError:
+        return response.status_code, response.text[:500]
+
+
 def _direct_jupiter_enabled() -> bool:
     return bool(settings.jupiter_api_key.strip())
 
@@ -187,7 +220,58 @@ async def fetch_quote(
     only_direct_routes: bool = False,
     swap_mode: str = "ExactIn",
 ) -> dict[str, Any]:
-    """Fetch a Jupiter quote for an exact-in swap."""
+    """Fetch a Jupiter quote for an exact-in swap.
+
+    Tries direct Jupiter API first. On free-tier errors (TOKEN_NOT_TRADABLE,
+    NOT_SUPPORTED) falls back to provider gateway when configured.
+    """
+    # Try direct first
+    try:
+        return await _fetch_quote_direct(
+            input_mint=input_mint,
+            output_mint=output_mint,
+            amount_raw=amount_raw,
+            slippage_bps=slippage_bps,
+            restrict_intermediate_tokens=restrict_intermediate_tokens,
+            only_direct_routes=only_direct_routes,
+            swap_mode=swap_mode,
+        )
+    except ProviderError as exc:
+        error_msg = str(exc).lower()
+        # Only fall back for known free-tier limitations
+        gateway_fallback_errors = (
+            "not tradable",
+            "token_not_tradable",
+            "not supported",
+            "restrict_intermediate_tokens",
+        )
+        if not any(phrase in error_msg for phrase in gateway_fallback_errors):
+            raise
+        if not _gateway_enabled():
+            raise
+        # Retry via gateway with relaxed restrictions
+        return await _fetch_quote_via_gateway(
+            input_mint=input_mint,
+            output_mint=output_mint,
+            amount_raw=amount_raw,
+            slippage_bps=slippage_bps,
+            restrict_intermediate_tokens=False,
+            only_direct_routes=only_direct_routes,
+            swap_mode=swap_mode,
+        )
+
+
+async def _fetch_quote_direct(
+    *,
+    input_mint: str,
+    output_mint: str,
+    amount_raw: int,
+    slippage_bps: int = 50,
+    restrict_intermediate_tokens: bool = True,
+    only_direct_routes: bool = False,
+    swap_mode: str = "ExactIn",
+) -> dict[str, Any]:
+    """Fetch a Jupiter quote directly from Jupiter API."""
     client = get_client()
     params = {
         "inputMint": input_mint,
@@ -211,6 +295,38 @@ async def fetch_quote(
     return data
 
 
+async def _fetch_quote_via_gateway(
+    *,
+    input_mint: str,
+    output_mint: str,
+    amount_raw: int,
+    slippage_bps: int = 50,
+    restrict_intermediate_tokens: bool = False,
+    only_direct_routes: bool = False,
+    swap_mode: str = "ExactIn",
+) -> dict[str, Any]:
+    """Fetch a Jupiter quote via provider gateway (uses API key)."""
+    params: dict[str, Any] = {
+        "inputMint": input_mint,
+        "outputMint": output_mint,
+        "amount": str(amount_raw),
+        "slippageBps": str(slippage_bps),
+        "swapMode": swap_mode,
+    }
+    if only_direct_routes:
+        params["onlyDirectRoutes"] = "true"
+
+    status_code, payload = await _gateway_get("quote", params=params)
+    if status_code != 200:
+        error_msg = payload if isinstance(payload, str) else json.dumps(payload)
+        raise ProviderError("jupiter-gateway", f"HTTP {status_code}: {error_msg}")
+    if isinstance(payload, dict) and payload.get("errorCode"):
+        raise ProviderError("jupiter-gateway", str(payload.get("error") or payload.get("errorCode")))
+    if not isinstance(payload, dict) or "outAmount" not in payload:
+        raise ProviderError("jupiter-gateway", "Unexpected quote response from gateway.")
+    return payload
+
+
 async def fetch_ultra_order(
     *,
     input_mint: str,
@@ -257,7 +373,35 @@ async def build_swap_transaction(
     quote_response: dict[str, Any],
     wrap_and_unwrap_sol: bool = True,
 ) -> dict[str, Any]:
-    """Build a serialized swap transaction from a Jupiter quote."""
+    """Build a serialized swap transaction from a Jupiter quote.
+
+    Tries direct Jupiter API first. Falls back to provider gateway on error.
+    """
+    # Try direct first
+    try:
+        return await _build_swap_direct(
+            user_public_key=user_public_key,
+            quote_response=quote_response,
+            wrap_and_unwrap_sol=wrap_and_unwrap_sol,
+        )
+    except ProviderError as exc:
+        if not _gateway_enabled():
+            raise
+        # Fall back to gateway
+        return await _build_swap_via_gateway(
+            user_public_key=user_public_key,
+            quote_response=quote_response,
+            wrap_and_unwrap_sol=wrap_and_unwrap_sol,
+        )
+
+
+async def _build_swap_direct(
+    *,
+    user_public_key: str,
+    quote_response: dict[str, Any],
+    wrap_and_unwrap_sol: bool = True,
+) -> dict[str, Any]:
+    """Build a swap transaction directly via Jupiter API."""
     client = get_client()
     body = {
         "userPublicKey": user_public_key,
@@ -279,6 +423,31 @@ async def build_swap_transaction(
     return data
 
 
+async def _build_swap_via_gateway(
+    *,
+    user_public_key: str,
+    quote_response: dict[str, Any],
+    wrap_and_unwrap_sol: bool = True,
+) -> dict[str, Any]:
+    """Build a swap transaction via provider gateway (uses API key)."""
+    body = {
+        "userPublicKey": user_public_key,
+        "quoteResponse": quote_response,
+        "wrapAndUnwrapSol": wrap_and_unwrap_sol,
+        "dynamicComputeUnitLimit": True,
+        "prioritizationFeeLamports": "auto",
+    }
+    status_code, payload = await _gateway_post("swap", body=body)
+    if status_code != 200:
+        error_msg = payload if isinstance(payload, str) else json.dumps(payload)
+        raise ProviderError("jupiter-gateway", f"HTTP {status_code}: {error_msg}")
+    if isinstance(payload, dict) and payload.get("errorCode"):
+        raise ProviderError("jupiter-gateway", str(payload.get("error") or payload.get("errorCode")))
+    if not isinstance(payload, dict) or "swapTransaction" not in payload:
+        raise ProviderError("jupiter-gateway", "Unexpected swap response from gateway.")
+    return payload
+
+
 async def execute_ultra_order(
     *,
     signed_transaction_base64: str,

package/agent-wallet/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "openclaw-agent-wallet"
-version = "0.1.9"
+version = "0.1.11"
 description = "Plugin-friendly wallet backend for OpenClaw agents"
 requires-python = ">=3.10"
 dependencies = [
@@ -14,6 +14,7 @@ dependencies = [
     "pynacl>=1.5.0",
     "python-dotenv>=1.0.0",
     "solana>=0.36.0",
+    "solders>=0.27.0",
 ]
 
 [project.optional-dependencies]

package/agent-wallet/scripts/install_agent_wallet.py

@@ -26,6 +26,7 @@ INCLUDED_RUNTIME_TOP_LEVEL_DIRS = [
     ".openclaw",
     "agent-wallet",
     "agent-a2a-gateway",
+    "hermes",
     "wdk-btc-wallet",
     "wdk-evm-wallet",
 ]

package/bin/openclaw-agent-wallet.mjs

@@ -19,6 +19,7 @@ function printHelp() {
 
 Usage:
   openclaw-agent-wallet install [options]
+  openclaw-agent-wallet hermes install [options]
   openclaw-agent-wallet update [options]
   openclaw-agent-wallet status
   openclaw-agent-wallet rollback [--to <version>]
@@ -33,6 +34,7 @@ Common install options:
 
 Examples:
   npx @agentlayer.tech/wallet install --yes
+  npx @agentlayer.tech/wallet hermes install --yes
   npx @agentlayer.tech/wallet install --backend none
   npx @agentlayer.tech/wallet update --yes
   npx @agentlayer.tech/wallet status
@@ -65,6 +67,10 @@ function resolveRuntimeBase(env = process.env) {
   return path.join(resolveOpenclawHome(env), "agent-wallet-runtime");
 }
 
+function resolveHermesHome(env = process.env) {
+  return path.resolve(expandHome(env.HERMES_HOME || "~/.hermes"));
+}
+
 function releaseRootFor(version, env = process.env) {
   return path.join(resolveRuntimeBase(env), "releases", version);
 }
@@ -73,6 +79,21 @@ function currentRuntimePath(env = process.env) {
   return path.join(resolveRuntimeBase(env), "current");
 }
 
+function resolvedCurrentRuntimeRoot(env = process.env) {
+  const currentPath = currentRuntimePath(env);
+  const currentTarget = readLinkOrNull(currentPath);
+  if (currentTarget) {
+    return path.resolve(path.dirname(currentPath), currentTarget);
+  }
+  try {
+    const stat = fs.statSync(currentPath);
+    if (stat.isDirectory()) return currentPath;
+  } catch (error) {
+    if (error?.code !== "ENOENT") throw error;
+  }
+  return "";
+}
+
 function previousRuntimePath(env = process.env) {
   return path.join(resolveRuntimeBase(env), "previous");
 }
@@ -282,6 +303,31 @@ function envFileSet(pathname, updates) {
   }
 }
 
+function envFileUnset(pathname, keys) {
+  let lines = [];
+  try {
+    lines = fs.readFileSync(pathname, "utf8").split(/\r?\n/);
+  } catch (error) {
+    if (error?.code === "ENOENT") return;
+    throw error;
+  }
+  const blocked = new Set(keys);
+  const next = [];
+  for (const line of lines) {
+    const match = line.match(/^([A-Za-z_][A-Za-z0-9_]*)=/);
+    if (match && blocked.has(match[1])) {
+      continue;
+    }
+    if (line.length > 0) next.push(line);
+  }
+  fs.writeFileSync(pathname, `${next.join("\n")}\n`, { mode: 0o600 });
+  try {
+    fs.chmodSync(pathname, 0o600);
+  } catch {
+    // ignored
+  }
+}
+
 function readEnvFile(pathname) {
   try {
     const result = {};
@@ -297,13 +343,55 @@ function readEnvFile(pathname) {
 }
 
 function currentBootKey(env = process.env) {
-  const currentPath = currentRuntimePath(env);
-  const currentTarget = readLinkOrNull(currentPath);
-  if (!currentTarget) return "";
-  const currentRoot = path.resolve(path.dirname(currentPath), currentTarget);
+  const currentRoot = resolvedCurrentRuntimeRoot(env);
+  if (!currentRoot) return "";
   return readEnvFile(path.join(currentRoot, "agent-wallet", ".env")).AGENT_WALLET_BOOT_KEY || "";
 }
 
+function readTextIfExists(pathname) {
+  try {
+    return fs.readFileSync(pathname, "utf8");
+  } catch (error) {
+    if (error?.code === "ENOENT") return "";
+    throw error;
+  }
+}
+
+function writeSecretFile(pathname, value) {
+  fs.mkdirSync(path.dirname(pathname), { recursive: true });
+  fs.writeFileSync(pathname, `${String(value || "").trim()}\n`, { mode: 0o600 });
+  try {
+    fs.chmodSync(pathname, 0o600);
+  } catch {
+    // ignored
+  }
+}
+
+function resolveBootKeyFromFile(env = process.env) {
+  const keyFile = String(env.AGENT_WALLET_BOOT_KEY_FILE || "").trim();
+  if (!keyFile) return "";
+  return readTextIfExists(path.resolve(expandHome(keyFile))).trim();
+}
+
+function defaultBootKeyFile(env = process.env) {
+  return path.join(resolveRuntimeBase(env), "boot-key");
+}
+
+function ensureBootKeyFile(env = process.env) {
+  const configuredFile = String(env.AGENT_WALLET_BOOT_KEY_FILE || "").trim();
+  const keyFile = configuredFile ? path.resolve(expandHome(configuredFile)) : defaultBootKeyFile(env);
+  const existing = readTextIfExists(keyFile).trim();
+  if (existing) {
+    return { path: keyFile, status: "existing" };
+  }
+  const bootKey = String(env.AGENT_WALLET_BOOT_KEY || "").trim() || resolveBootKeyFromFile(env) || currentBootKey(env);
+  if (!bootKey) {
+    return { path: keyFile, status: "missing" };
+  }
+  writeSecretFile(keyFile, bootKey);
+  return { path: keyFile, status: "created" };
+}
+
 function runDoctor() {
   const requiredPaths = [
     ["setup.sh", setupPath],
@@ -380,7 +468,7 @@ function buildInstallerEnv(args) {
   const sealedKeysPath = path.join(resolveOpenclawHome(env), "sealed_keys.json");
   const sealedKeysExist = fs.existsSync(sealedKeysPath);
   if (!env.AGENT_WALLET_BOOT_KEY) {
-    const existingBootKey = currentBootKey(env);
+    const existingBootKey = resolveBootKeyFromFile(env) || currentBootKey(env);
     if (existingBootKey) {
       env.AGENT_WALLET_BOOT_KEY = existingBootKey;
     }
@@ -523,6 +611,132 @@ function runRollback(args) {
   return 0;
 }
 
+function resolveHermesPluginSource() {
+  const currentRoot = resolvedCurrentRuntimeRoot();
+  const candidates = [];
+  if (currentRoot) {
+    candidates.push(path.join(currentRoot, "hermes", "plugins", "agent_wallet"));
+  }
+  candidates.push(path.join(packageRoot, "hermes", "plugins", "agent_wallet"));
+  for (const source of candidates) {
+    if (fs.existsSync(path.join(source, "plugin.yaml"))) {
+      return source;
+    }
+  }
+  throw new Error(`Missing Hermes plugin bundle. Checked: ${candidates.join(", ")}`);
+}
+
+function resolveAgentWalletPackageRoot(env = process.env) {
+  const currentRoot = resolvedCurrentRuntimeRoot(env);
+  if (currentRoot) {
+    const runtimePackage = path.join(currentRoot, "agent-wallet");
+    if (fs.existsSync(path.join(runtimePackage, "agent_wallet", "__init__.py"))) {
+      return runtimePackage;
+    }
+  }
+  return path.join(packageRoot, "agent-wallet");
+}
+
+function resolveAgentWalletPython(packageRootPath) {
+  for (const candidate of [
+    process.env.AGENT_WALLET_PYTHON,
+    process.env.OPENCLAW_AGENT_WALLET_PYTHON,
+    path.join(packageRootPath, ".venv", "bin", "python"),
+    path.join(packageRootPath, ".runtime-venv", "bin", "python"),
+    commandPath("python3"),
+  ]) {
+    if (!candidate) continue;
+    if (path.isAbsolute(candidate) && !fs.existsSync(candidate)) continue;
+    return candidate;
+  }
+  return "python3";
+}
+
+function runHermesInstall(args) {
+  const hermesHome = resolveHermesHome();
+  const userPluginsDir = path.join(hermesHome, "plugins");
+  const pluginSource = resolveHermesPluginSource();
+  const pluginTarget = path.join(userPluginsDir, "agent_wallet");
+  const force = hasFlag(args, "--force");
+  const skipEnable = hasFlag(args, "--skip-enable");
+  const hermesBin = commandPath("hermes");
+  const agentWalletPackageRoot = resolveAgentWalletPackageRoot();
+  const agentWalletPython = resolveAgentWalletPython(agentWalletPackageRoot);
+  const hermesEnvPath = path.join(hermesHome, ".env");
+  const existingHermesEnv = readEnvFile(hermesEnvPath);
+  const bootKeyFile = ensureBootKeyFile({ ...process.env, ...existingHermesEnv });
+
+  fs.mkdirSync(userPluginsDir, { recursive: true });
+  try {
+    const existing = fs.lstatSync(pluginTarget);
+    if (!existing.isSymbolicLink()) {
+      if (!force) {
+        throw new Error(`${pluginTarget} exists and is not a symlink. Pass --force to replace it.`);
+      }
+      fs.rmSync(pluginTarget, { recursive: true, force: true });
+    } else {
+      fs.unlinkSync(pluginTarget);
+    }
+  } catch (error) {
+    if (error?.code !== "ENOENT") throw error;
+  }
+  fs.symlinkSync(pluginSource, pluginTarget, "dir");
+
+  envFileSet(hermesEnvPath, {
+    AGENT_WALLET_PACKAGE_ROOT: agentWalletPackageRoot,
+    AGENT_WALLET_PYTHON: agentWalletPython,
+    AGENT_WALLET_BOOT_KEY_FILE: bootKeyFile.path,
+  });
+  if (bootKeyFile.status !== "missing") {
+    envFileUnset(hermesEnvPath, ["AGENT_WALLET_BOOT_KEY"]);
+  }
+
+  let enable = { attempted: false, ok: false, skipped: skipEnable, error: "" };
+  if (!skipEnable) {
+    if (!hermesBin) {
+      enable = {
+        attempted: false,
+        ok: false,
+        skipped: false,
+        error: "Hermes CLI was not found on PATH. Run `hermes plugins enable agent-wallet` after installing Hermes.",
+      };
+    } else {
+      const result = spawnSync(hermesBin, ["plugins", "enable", "agent-wallet"], {
+        cwd: packageRoot,
+        encoding: "utf8",
+        env: { ...process.env, HERMES_HOME: hermesHome },
+      });
+      enable = {
+        attempted: true,
+        ok: result.status === 0,
+        skipped: false,
+        error: result.status === 0 ? "" : (result.stderr || result.stdout || "").trim(),
+      };
+    }
+  }
+
+  console.log(
+    JSON.stringify(
+      {
+        ok: enable.skipped || enable.ok,
+        hermes_home: hermesHome,
+        plugin_source: pluginSource,
+        plugin_target: pluginTarget,
+        env_path: hermesEnvPath,
+        agent_wallet_package_root: agentWalletPackageRoot,
+        agent_wallet_python: agentWalletPython,
+        boot_key_file: bootKeyFile.path,
+        boot_key_file_status: bootKeyFile.status,
+        hermes_enable: enable,
+        restart_required: true,
+      },
+      null,
+      2,
+    ),
+  );
+  return enable.skipped || enable.ok ? 0 : 1;
+}
+
 const args = process.argv.slice(2);
 const command = args[0] || "install";
 
@@ -556,6 +770,16 @@ if (command === "rollback") {
   process.exit(runRollback(args.slice(1)));
 }
 
+if (command === "hermes") {
+  const subcommand = args[1] || "install";
+  if (subcommand === "install" || subcommand === "setup") {
+    process.exit(runHermesInstall(args.slice(2)));
+  }
+  console.error(`Unknown hermes command: ${subcommand}`);
+  console.error("Run `openclaw-agent-wallet hermes install --yes` to connect Hermes Agent.");
+  process.exit(2);
+}
+
 if (command.startsWith("-")) {
   process.exit(runInstall(args, { commandName: "install" }));
 }

package/hermes/plugins/agent_wallet/README.md

@@ -0,0 +1,54 @@
+# AgentLayer Wallet Hermes Plugin
+
+This is a thin Hermes Agent bridge to the existing AgentLayer/OpenClaw wallet backend.
+
+It intentionally does not copy the OpenClaw TypeScript extension or reimplement wallet policy. Hermes gets three tools:
+
+- `agent_wallet_tools` - lists the underlying wallet tools and schemas from the Python adapter without creating or unlocking a wallet.
+- `agent_wallet_invoke` - forwards one tool call to `python -m agent_wallet.openclaw_cli invoke`.
+- `agent_wallet_approve` - issues a short-lived approval token through `python -m agent_wallet.openclaw_cli issue-approval` after explicit user confirmation of the exact preview summary.
+
+OpenClaw remains the primary local environment. This plugin only expands the same backend into Hermes.
+
+## Integration Plan
+
+1. Keep wallet behavior and safety policy in `agent-wallet/`.
+2. Keep OpenClaw as the primary environment and leave `.openclaw/extensions/agent-wallet` unchanged.
+3. Register a small Hermes bridge instead of one Hermes tool per wallet operation.
+4. Use discovery from `OpenClawWalletAdapter.list_tools()` so Hermes sees the current backend schemas without duplicated metadata.
+5. Forward execution to `agent_wallet.openclaw_cli invoke` so config validation, sealed secrets, approval-token checks, and backend dispatch stay authoritative in Python.
+6. Forward token issuance to `agent_wallet.openclaw_cli issue-approval` so Hermes can complete preview/approve/execute without learning sealed secrets.
+7. Cache successful Solana swap previews briefly in Hermes and bind the cached payload digest into the approval token. Execute can then reuse the exact Jupiter preview the user approved instead of re-quoting volatile markets.
+8. Add broader Hermes ergonomics later only where it improves safety, such as an installer wrapper or read-only status command.
+
+## Install
+
+Copy or symlink this directory into a Hermes plugin path:
+
+```bash
+mkdir -p ~/.hermes/plugins
+ln -s /absolute/path/to/openclaw_skill/hermes/plugins/agent_wallet ~/.hermes/plugins/agent_wallet
+```
+
+Set the wallet package root if Hermes is not launched from this repository:
+
+```bash
+export AGENT_WALLET_PACKAGE_ROOT=/absolute/path/to/openclaw_skill/agent-wallet
+export AGENT_WALLET_PYTHON=python3
+```
+
+Then enable or reload plugins in Hermes:
+
+```bash
+hermes plugins
+hermes chat
+```
+
+## Runtime Notes
+
+- Secrets must stay in the existing protected runtime path, especially `~/.openclaw/sealed_keys.json`.
+- Do not pass `privateKey`, `masterKey`, or `approvalSecret` through Hermes tool config.
+- Write-capable wallet tools still require preview first and an `approval_token` bound to the exact `confirmation_summary`.
+- Use `agent_wallet_approve` only after the user explicitly confirms the exact operation. Mainnet execute requires `mainnet_confirmed=true`.
+- Use `agent_wallet_tools` before invoking unfamiliar tool names.
+- Solana swap previews are cached at `~/.hermes/agent_wallet_preview_cache.json` with `0600` permissions for a short window. The cache contains unsigned preview payloads only; signing and approval checks remain in `agent-wallet/`.

package/hermes/plugins/agent_wallet/__init__.py

@@ -0,0 +1,29 @@
+"""Hermes Agent plugin bridge for AgentLayer wallet tools."""
+
+from .schemas import AGENT_WALLET_APPROVE, AGENT_WALLET_INVOKE, AGENT_WALLET_TOOLS
+from .tools import agent_wallet_approve, agent_wallet_invoke, agent_wallet_tools
+
+
+def register(ctx):
+    """Register a narrow dispatcher instead of duplicating wallet tools."""
+    ctx.register_tool(
+        name=AGENT_WALLET_TOOLS["name"],
+        toolset="agent_wallet",
+        schema=AGENT_WALLET_TOOLS,
+        handler=agent_wallet_tools,
+        description=AGENT_WALLET_TOOLS["description"],
+    )
+    ctx.register_tool(
+        name=AGENT_WALLET_INVOKE["name"],
+        toolset="agent_wallet",
+        schema=AGENT_WALLET_INVOKE,
+        handler=agent_wallet_invoke,
+        description=AGENT_WALLET_INVOKE["description"],
+    )
+    ctx.register_tool(
+        name=AGENT_WALLET_APPROVE["name"],
+        toolset="agent_wallet",
+        schema=AGENT_WALLET_APPROVE,
+        handler=agent_wallet_approve,
+        description=AGENT_WALLET_APPROVE["description"],
+    )

package/hermes/plugins/agent_wallet/plugin.yaml

@@ -0,0 +1,7 @@
+name: agent-wallet
+version: 0.1.0
+description: Thin Hermes Agent bridge to the existing AgentLayer/OpenClaw wallet backend
+provides_tools:
+  - agent_wallet_tools
+  - agent_wallet_invoke
+  - agent_wallet_approve