@agentlayer.tech/wallet 0.1.101 → 0.1.102

package/.openclaw/extensions/agent-wallet/dist/index.js

@@ -1,4 +1,4 @@
-import { execFile } from "node:child_process";
+import { execFile, execFileSync } from "node:child_process";
 import crypto from "node:crypto";
 import fs from "node:fs";
 import os from "node:os";
@@ -423,6 +423,50 @@ function buildCliEnv(packageRoot) {
   return env;
 }
 
+function loadConnectorToolDefinitions(api) {
+  const config = resolvePluginConfig(api);
+  try {
+    const packageRoot = resolvePackageRoot(config);
+    const stdout = execFileSync(
+      resolvePythonBin(config),
+      ["-m", "agent_wallet.connector_cli", "tools"],
+      {
+        cwd: packageRoot,
+        env: {
+          ...buildCliEnv(packageRoot),
+          OPENCLAW_HOME: resolveOpenclawHome(config),
+        },
+        encoding: "utf8",
+        maxBuffer: 1024 * 1024 * 2,
+        timeout: 10_000,
+      }
+    );
+    const payload = JSON.parse(stdout);
+    if (payload?.ok !== true || !Array.isArray(payload?.tools)) return [];
+    return payload.tools
+      .filter(
+        (tool) =>
+          tool?.read_only === true &&
+          typeof tool?.name === "string" &&
+          tool.name.startsWith("connector__") &&
+          typeof tool?.description === "string" &&
+          tool?.input_schema &&
+          typeof tool.input_schema === "object"
+      )
+      .map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.input_schema,
+        optional: true,
+      }));
+  } catch (error) {
+    api?.logger?.warn?.(
+      `[agent-wallet] connector tools unavailable; built-in tools remain active: ${String(error?.message || error)}`
+    );
+    return [];
+  }
+}
+
 async function callWalletCli(api, command, extraArgs = [], configOverride = null) {
   const config = configOverride || resolvePluginConfig(api);
   const packageRoot = resolvePackageRoot(config);
@@ -2184,6 +2228,7 @@ export default function registerAgentWalletPlugin(api) {
     ...solanaToolDefinitions.filter((item) => !duplicateSessionToolNames.has(item.name)),
     ...btcToolDefinitions.filter((item) => !duplicateSessionToolNames.has(item.name)),
     ...evmToolDefinitions.filter((item) => !duplicateSessionToolNames.has(item.name)),
+    ...loadConnectorToolDefinitions(api),
   ]) {
     if (seen.has(definition.name)) {
       continue;

package/.openclaw/extensions/agent-wallet/index.ts

@@ -1,4 +1,4 @@
-import { execFile } from "node:child_process";
+import { execFile, execFileSync } from "node:child_process";
 import crypto from "node:crypto";
 import fs from "node:fs";
 import os from "node:os";
@@ -423,6 +423,50 @@ function buildCliEnv(packageRoot) {
   return env;
 }
 
+function loadConnectorToolDefinitions(api) {
+  const config = resolvePluginConfig(api);
+  try {
+    const packageRoot = resolvePackageRoot(config);
+    const stdout = execFileSync(
+      resolvePythonBin(config),
+      ["-m", "agent_wallet.connector_cli", "tools"],
+      {
+        cwd: packageRoot,
+        env: {
+          ...buildCliEnv(packageRoot),
+          OPENCLAW_HOME: resolveOpenclawHome(config),
+        },
+        encoding: "utf8",
+        maxBuffer: 1024 * 1024 * 2,
+        timeout: 10_000,
+      }
+    );
+    const payload = JSON.parse(stdout);
+    if (payload?.ok !== true || !Array.isArray(payload?.tools)) return [];
+    return payload.tools
+      .filter(
+        (tool) =>
+          tool?.read_only === true &&
+          typeof tool?.name === "string" &&
+          tool.name.startsWith("connector__") &&
+          typeof tool?.description === "string" &&
+          tool?.input_schema &&
+          typeof tool.input_schema === "object"
+      )
+      .map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.input_schema,
+        optional: true,
+      }));
+  } catch (error) {
+    api?.logger?.warn?.(
+      `[agent-wallet] connector tools unavailable; built-in tools remain active: ${String(error?.message || error)}`
+    );
+    return [];
+  }
+}
+
 async function callWalletCli(api, command, extraArgs = [], configOverride = null) {
   const config = configOverride || resolvePluginConfig(api);
   const packageRoot = resolvePackageRoot(config);
@@ -2184,6 +2228,7 @@ export default function registerAgentWalletPlugin(api) {
     ...solanaToolDefinitions.filter((item) => !duplicateSessionToolNames.has(item.name)),
     ...btcToolDefinitions.filter((item) => !duplicateSessionToolNames.has(item.name)),
     ...evmToolDefinitions.filter((item) => !duplicateSessionToolNames.has(item.name)),
+    ...loadConnectorToolDefinitions(api),
   ]) {
     if (seen.has(definition.name)) {
       continue;

package/.openclaw/extensions/agent-wallet/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "agent-wallet",
   "name": "Agent Wallet",
   "description": "Official OpenClaw plugin bridge for the agent-wallet backends, including Solana, local BTC, and local EVM.",
-  "version": "0.1.101",
+  "version": "0.1.102",
   "contracts": {
     "tools": [
       "agentlayer_autonomous_approve",

package/.openclaw/extensions/agent-wallet/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentlayertech/agent-wallet-plugin",
-  "version": "0.1.101",
+  "version": "0.1.102",
   "description": "OpenClaw plugin bridge for the AgentLayer wallet runtime.",
   "type": "module",
   "license": "SEE LICENSE IN ../../../LICENSE",

package/README.md

@@ -114,6 +114,24 @@ wallet update --yes
 wallet rollback
 ```
 
+## Optional connectors
+
+Connectors add optional third-party crypto and DeFi read tools without moving
+existing integrations such as Aave, Kamino, or Morpho out of the wallet core.
+
+```bash
+wallet connectors inspect ./connector.json
+wallet connectors install ./connector.json --enable --yes
+wallet connectors list
+wallet connectors disable com.example.protocol
+wallet connectors doctor
+```
+
+Enabled read-only connectors appear in OpenClaw and Codex after the host is
+restarted. Write-capable connectors remain unavailable until their verified,
+AgentLayer-hosted execution path is fully enabled. See
+[`connectors/README.md`](connectors/README.md) for the trust model and protocol.
+
 ## What AgentLayer provides
 
 AgentLayer connects supported agents to one local wallet runtime. The agent can:

package/VERSION

@@ -1 +1 @@
-0.1.101
+0.1.102

package/agent-wallet/agent_wallet/__init__.py

@@ -2,7 +2,7 @@
 
 # Keep in sync with package.json, pyproject.toml, and the npm installer version.
 # scripts/check_release_version.mjs enforces this on release.
-__version__ = "0.1.101"
+__version__ = "0.1.102"
 
 __all__ = [
     "config",

package/agent-wallet/agent_wallet/connector_cli.py

@@ -0,0 +1,198 @@
+"""JSON CLI for installing and managing optional AgentLayer connectors."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+from agent_wallet.connectors.catalog import enabled_connector_tools
+from agent_wallet.connectors.manifest import ConnectorManifestError, validate_connector_manifest
+from agent_wallet.connectors.registry import ConnectorRegistry, ConnectorRegistryError
+
+
+MAX_MANIFEST_BYTES = 1024 * 1024
+
+
+def _print(payload: Any) -> None:
+    print(json.dumps(payload, indent=2, sort_keys=True))
+
+
+def _load_manifest_file(value: str) -> tuple[dict[str, Any], str]:
+    path = Path(value).expanduser().resolve()
+    try:
+        size = path.stat().st_size
+    except OSError as exc:
+        raise ConnectorRegistryError(f"Connector manifest cannot be read: {path}: {exc}") from exc
+    if size > MAX_MANIFEST_BYTES:
+        raise ConnectorRegistryError(
+            f"Connector manifest exceeds the {MAX_MANIFEST_BYTES}-byte limit."
+        )
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError) as exc:
+        raise ConnectorRegistryError(f"Connector manifest is invalid JSON: {path}: {exc}") from exc
+    if not isinstance(payload, dict):
+        raise ConnectorRegistryError("Connector manifest root must be an object.")
+    return payload, str(path)
+
+
+def _permission_review(manifest_payload: dict[str, Any]) -> dict[str, Any]:
+    manifest = validate_connector_manifest(manifest_payload)
+    permissions = manifest["permissions"]
+    warnings = ["Connector responses are untrusted external data."]
+    if permissions["wallet_address"]:
+        warnings.append("The connector may receive the active public wallet address.")
+    return {
+        "id": manifest["id"],
+        "version": manifest["version"],
+        "publisher": manifest["publisher"],
+        "trust": manifest["trust"],
+        "endpoint": manifest["transport"]["url"],
+        "permissions": permissions,
+        "tools": [tool["name"] for tool in manifest["tools"]],
+        "warnings": warnings,
+    }
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="wallet connectors")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    subparsers.add_parser("list", help="List locally installed connectors.")
+    subparsers.add_parser("tools", help="List enabled read-only connector tools for host registration.")
+
+    info = subparsers.add_parser("info", help="Show one installed connector.")
+    info.add_argument("connector_id")
+
+    inspect = subparsers.add_parser("inspect", help="Review a manifest before installation.")
+    inspect.add_argument("manifest", help="Path to a connector manifest JSON file.")
+
+    install = subparsers.add_parser("install", help="Install an immutable connector manifest.")
+    install.add_argument("manifest", help="Path to a connector manifest JSON file.")
+    install.add_argument("--enable", action="store_true", help="Enable this exact version.")
+    install.add_argument("--yes", action="store_true", help="Confirm permissions when enabling.")
+
+    enable = subparsers.add_parser("enable", help="Enable an installed connector version.")
+    enable.add_argument("connector_id")
+    enable.add_argument("--version", default=None)
+    enable.add_argument("--yes", action="store_true", help="Confirm the installed permissions.")
+
+    disable = subparsers.add_parser("disable", help="Disable an installed connector.")
+    disable.add_argument("connector_id")
+
+    remove = subparsers.add_parser("remove", help="Remove a disabled connector version.")
+    remove.add_argument("connector_id")
+    remove.add_argument("--version", default=None)
+    remove.add_argument("--yes", action="store_true", help="Confirm removal.")
+
+    subparsers.add_parser("doctor", help="Validate the registry and all installed manifests.")
+    return parser
+
+
+def _doctor(registry: ConnectorRegistry) -> dict[str, Any]:
+    entries = registry.list()
+    checks: list[dict[str, Any]] = []
+    ok = True
+    for entry in entries:
+        connector_id = str(entry["id"])
+        for version in entry["installed_versions"]:
+            try:
+                registry.load_manifest(connector_id, str(version))
+                checks.append(
+                    {
+                        "connector_id": connector_id,
+                        "version": version,
+                        "ok": True,
+                    }
+                )
+            except (ConnectorManifestError, ConnectorRegistryError) as exc:
+                ok = False
+                checks.append(
+                    {
+                        "connector_id": connector_id,
+                        "version": version,
+                        "ok": False,
+                        "error": str(exc),
+                    }
+                )
+    return {
+        "ok": ok,
+        "registry_path": str(registry.registry_path),
+        "connector_count": len(entries),
+        "checks": checks,
+    }
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+    registry = ConnectorRegistry()
+    try:
+        if args.command == "list":
+            _print({"ok": True, "connectors": registry.list()})
+            return 0
+        if args.command == "tools":
+            _print({"ok": True, "tools": enabled_connector_tools(registry, include_write=False)})
+            return 0
+        if args.command == "info":
+            _print({"ok": True, "connector": registry.describe(args.connector_id)})
+            return 0
+        if args.command == "inspect":
+            manifest, source = _load_manifest_file(args.manifest)
+            _print({"ok": True, "source": source, "review": _permission_review(manifest)})
+            return 0
+        if args.command == "install":
+            manifest, source = _load_manifest_file(args.manifest)
+            review = _permission_review(manifest)
+            if args.enable and not args.yes:
+                raise ConnectorRegistryError(
+                    "install --enable requires --yes after reviewing connector permissions "
+                    "with `wallet connectors inspect <manifest>`."
+                )
+            connector = registry.install(manifest, source=source, enable=bool(args.enable))
+            _print({"ok": True, "connector": connector, "review": review})
+            return 0
+        if args.command == "enable":
+            if not args.yes:
+                raise ConnectorRegistryError(
+                    "enable requires --yes after reviewing the installed connector with "
+                    "`wallet connectors info <connector_id>`."
+                )
+            connector = registry.enable(args.connector_id, version=args.version)
+            _print({"ok": True, "connector": connector})
+            return 0
+        if args.command == "disable":
+            connector = registry.disable(args.connector_id)
+            _print({"ok": True, "connector": connector})
+            return 0
+        if args.command == "remove":
+            if not args.yes:
+                raise ConnectorRegistryError("remove requires --yes after the connector is disabled.")
+            result = registry.remove(args.connector_id, version=args.version)
+            _print({"ok": True, **result})
+            return 0
+        if args.command == "doctor":
+            result = _doctor(registry)
+            _print(result)
+            return 0 if result["ok"] else 1
+        raise ConnectorRegistryError(f"Unsupported connectors command: {args.command}.")
+    except (ConnectorManifestError, ConnectorRegistryError) as exc:
+        print(
+            json.dumps(
+                {
+                    "ok": False,
+                    "error": str(exc),
+                    "error_type": type(exc).__name__,
+                },
+                sort_keys=True,
+            ),
+            file=sys.stderr,
+        )
+        return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/agent-wallet/agent_wallet/connectors/__init__.py

@@ -0,0 +1,28 @@
+"""Optional AgentLayer connector contracts and local registry support."""
+
+from agent_wallet.connectors.catalog import enabled_connector_tools, resolve_connector_tool
+from agent_wallet.connectors.client import ConnectorInvocationError, ConnectorReadClient
+from agent_wallet.connectors.intent_policy import (
+    ConnectorIntentPolicyError,
+    validate_evm_transaction_intent,
+)
+from agent_wallet.connectors.manifest import (
+    ConnectorManifestError,
+    connector_tool_name,
+    validate_connector_manifest,
+)
+from agent_wallet.connectors.registry import ConnectorRegistry, ConnectorRegistryError
+
+__all__ = [
+    "ConnectorManifestError",
+    "ConnectorInvocationError",
+    "ConnectorIntentPolicyError",
+    "ConnectorReadClient",
+    "ConnectorRegistry",
+    "ConnectorRegistryError",
+    "connector_tool_name",
+    "enabled_connector_tools",
+    "resolve_connector_tool",
+    "validate_connector_manifest",
+    "validate_evm_transaction_intent",
+]

package/agent-wallet/agent_wallet/connectors/catalog.py

@@ -0,0 +1,68 @@
+"""Build the safe host-facing catalog of enabled connector tools."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from agent_wallet.connectors.manifest import connector_tool_name
+from agent_wallet.connectors.registry import ConnectorRegistry, ConnectorRegistryError
+
+
+def enabled_connector_tools(
+    registry: ConnectorRegistry | None = None,
+    *,
+    include_write: bool = False,
+) -> list[dict[str, Any]]:
+    """Return enabled tools, withholding writes until their policy is available."""
+
+    active_registry = registry or ConnectorRegistry()
+    result: list[dict[str, Any]] = []
+    seen: set[str] = set()
+    for entry in active_registry.list():
+        if not entry["enabled"]:
+            continue
+        connector_id = str(entry["id"])
+        version = str(entry["enabled_version"])
+        manifest = active_registry.load_manifest(connector_id, version)
+        for raw_tool in manifest["tools"]:
+            if not isinstance(raw_tool, dict):
+                raise ConnectorRegistryError(f"Connector tool is invalid: {connector_id}.")
+            read_only = raw_tool.get("read_only") is True
+            if not read_only and not include_write:
+                continue
+            host_name = connector_tool_name(connector_id, str(raw_tool.get("name") or ""))
+            if host_name in seen:
+                raise ConnectorRegistryError(f"Duplicate host connector tool name: {host_name}.")
+            seen.add(host_name)
+            result.append(
+                {
+                    "name": host_name,
+                    "description": (
+                        "[External connector: untrusted read-only data] "
+                        + str(raw_tool["description"])
+                    ),
+                    "input_schema": raw_tool["input_schema"],
+                    "output_schema": raw_tool["output_schema"],
+                    "read_only": read_only,
+                    "risk_level": str(raw_tool["risk_level"]),
+                    "connector_id": connector_id,
+                    "connector_version": version,
+                    "connector_tool": str(raw_tool["name"]),
+                    "connector_trust": str(manifest["trust"]),
+                }
+            )
+    return sorted(result, key=lambda item: str(item["name"]))
+
+
+def resolve_connector_tool(
+    host_tool_name: str,
+    registry: ConnectorRegistry | None = None,
+    *,
+    include_write: bool = False,
+) -> dict[str, Any]:
+    """Resolve one host tool through the enabled immutable catalog."""
+
+    for tool in enabled_connector_tools(registry, include_write=include_write):
+        if tool["name"] == host_tool_name:
+            return tool
+    raise ConnectorRegistryError(f"Enabled connector tool was not found: {host_tool_name}.")