agentbnb 8.0.1 → 8.2.0

package/skills/agentbnb/openclaw-tools.ts

@@ -0,0 +1,297 @@
+/**
+ * OpenClaw tool factory — bridges AgentBnB MCP tool handlers into
+ * OpenClaw's native plugin tool system.
+ *
+ * Each tool delegates to the existing `handle*()` functions from src/mcp/tools/.
+ * Context is lazily constructed and per-agent cached to avoid process.env mutation.
+ */
+
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { ensureIdentity } from '../../src/identity/identity.js';
+import type { AgentBnBConfig } from '../../src/cli/config.js';
+import type { McpServerContext } from '../../src/mcp/server.js';
+import { handleDiscover } from '../../src/mcp/tools/discover.js';
+import { handleRequest } from '../../src/mcp/tools/request.js';
+import { handleConduct } from '../../src/mcp/tools/conduct.js';
+import { handleStatus } from '../../src/mcp/tools/status.js';
+import { handlePublish } from '../../src/mcp/tools/publish.js';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+/** Subset of OpenClaw's plugin tool context passed to tool factories. */
+export interface OpenClawToolContext {
+  workspaceDir?: string;
+  agentDir?: string;
+}
+
+/** OpenClaw-compatible tool result. */
+export interface AgentToolResult {
+  content: string;
+  details?: unknown;
+}
+
+/** OpenClaw-compatible tool shape. */
+export interface AgentTool {
+  name: string;
+  label: string;
+  description: string;
+  parameters: Record<string, unknown>;
+  execute: (toolCallId: string, params: Record<string, unknown>) => Promise<AgentToolResult>;
+}
+
+// ---------------------------------------------------------------------------
+// Context cache — per-agent isolation keyed by configDir
+// ---------------------------------------------------------------------------
+
+const contextCache = new Map<string, McpServerContext>();
+
+/** Clears the per-agent context cache. Useful for tests and daemon restarts. */
+export function resetContextCache(): void {
+  contextCache.clear();
+}
+
+/**
+ * Resolves the configDir from OpenClaw tool context.
+ *
+ * Priority:
+ * 1. agentDir (if ends with .agentbnb, use directly; else append .agentbnb)
+ * 2. workspaceDir + /.agentbnb
+ * 3. Fallback: ~/.agentbnb
+ */
+export function resolveConfigDir(toolCtx: OpenClawToolContext): string {
+  if (toolCtx.agentDir) {
+    return toolCtx.agentDir.endsWith('.agentbnb')
+      ? toolCtx.agentDir
+      : join(toolCtx.agentDir, '.agentbnb');
+  }
+  if (toolCtx.workspaceDir) {
+    return join(toolCtx.workspaceDir, '.agentbnb');
+  }
+  return join(homedir(), '.agentbnb');
+}
+
+/**
+ * Constructs an McpServerContext from OpenClaw tool context.
+ * Per-agent cached — same configDir reuses the same context.
+ *
+ * Reads config directly from configDir/config.json instead of mutating
+ * process.env.AGENTBNB_DIR, which avoids race conditions in the shared
+ * OpenClaw daemon process.
+ */
+export function buildMcpContext(toolCtx: OpenClawToolContext): McpServerContext {
+  const configDir = resolveConfigDir(toolCtx);
+
+  const cached = contextCache.get(configDir);
+  if (cached) return cached;
+
+  const configPath = join(configDir, 'config.json');
+  if (!existsSync(configPath)) {
+    throw new Error(
+      `AgentBnB not initialized at ${configDir}. Run \`agentbnb init\` or activate the plugin first.`,
+    );
+  }
+
+  const config = JSON.parse(readFileSync(configPath, 'utf-8')) as AgentBnBConfig;
+  const identity = ensureIdentity(configDir, config.owner);
+
+  const ctx: McpServerContext = { configDir, config, identity };
+  contextCache.set(configDir, ctx);
+  return ctx;
+}
+
+// ---------------------------------------------------------------------------
+// Result conversion
+// ---------------------------------------------------------------------------
+
+/**
+ * Converts MCP result format to OpenClaw AgentToolResult.
+ * MCP returns `{ content: [{type:'text', text: '<json>'}] }`.
+ * OpenClaw expects `{ content: string, details?: unknown }`.
+ */
+export function toAgentToolResult(
+  mcpResult: { content: Array<{ type: string; text: string }> },
+): AgentToolResult {
+  const text = mcpResult.content[0]?.text ?? '{}';
+  let details: unknown;
+  try {
+    details = JSON.parse(text);
+  } catch {
+    details = undefined;
+  }
+  return { content: text, details };
+}
+
+// ---------------------------------------------------------------------------
+// Tool creators
+// ---------------------------------------------------------------------------
+
+/** Creates the agentbnb-discover tool. */
+export function createDiscoverTool(toolCtx: OpenClawToolContext): AgentTool {
+  return {
+    name: 'agentbnb-discover',
+    label: 'AgentBnB Discover',
+    description:
+      'Search for agent capabilities on the AgentBnB network. Returns matching capability cards from both local and remote registries.',
+    parameters: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Natural language search query' },
+        level: {
+          type: 'number',
+          description: 'Filter by capability level (1=Atomic, 2=Pipeline, 3=Environment)',
+        },
+        online_only: { type: 'boolean', description: 'Only show online agents' },
+      },
+      required: ['query'],
+    },
+    async execute(_toolCallId, params) {
+      const ctx = buildMcpContext(toolCtx);
+      const result = await handleDiscover(
+        params as { query: string; level?: number; online_only?: boolean },
+        ctx,
+      );
+      return toAgentToolResult(result);
+    },
+  };
+}
+
+/** Creates the agentbnb-request tool. */
+export function createRequestTool(toolCtx: OpenClawToolContext): AgentTool {
+  return {
+    name: 'agentbnb-request',
+    label: 'AgentBnB Request',
+    description:
+      'Request execution of a skill from another agent on the AgentBnB network. Handles credit escrow automatically.',
+    parameters: {
+      type: 'object',
+      properties: {
+        query: {
+          type: 'string',
+          description: 'Search query to find a matching capability (auto-request mode)',
+        },
+        card_id: { type: 'string', description: 'Direct card ID to request (skips search)' },
+        skill_id: { type: 'string', description: 'Specific skill within a v2.0 card' },
+        params: { type: 'object', description: 'Input parameters for the capability' },
+        max_cost: {
+          type: 'number',
+          description: 'Maximum credits to spend (default: 50)',
+        },
+      },
+      required: [],
+    },
+    async execute(_toolCallId, params) {
+      const ctx = buildMcpContext(toolCtx);
+      const result = await handleRequest(
+        params as {
+          query?: string;
+          card_id?: string;
+          skill_id?: string;
+          params?: Record<string, unknown>;
+          max_cost?: number;
+        },
+        ctx,
+      );
+      return toAgentToolResult(result);
+    },
+  };
+}
+
+/** Creates the agentbnb-conduct tool. */
+export function createConductTool(toolCtx: OpenClawToolContext): AgentTool {
+  return {
+    name: 'agentbnb-conduct',
+    label: 'AgentBnB Conduct',
+    description:
+      'Orchestrate a complex task across multiple agents on the AgentBnB network. Decomposes the task, matches sub-tasks to agents, and executes the pipeline.',
+    parameters: {
+      type: 'object',
+      properties: {
+        task: { type: 'string', description: 'Natural language task description' },
+        plan_only: {
+          type: 'boolean',
+          description: 'If true, return execution plan without executing',
+        },
+        max_budget: {
+          type: 'number',
+          description: 'Maximum credits to spend (default: 100)',
+        },
+      },
+      required: ['task'],
+    },
+    async execute(_toolCallId, params) {
+      const ctx = buildMcpContext(toolCtx);
+      const result = await handleConduct(
+        params as { task: string; plan_only?: boolean; max_budget?: number },
+        ctx,
+      );
+      return toAgentToolResult(result);
+    },
+  };
+}
+
+/** Creates the agentbnb-status tool. */
+export function createStatusTool(toolCtx: OpenClawToolContext): AgentTool {
+  return {
+    name: 'agentbnb-status',
+    label: 'AgentBnB Status',
+    description:
+      'Check your AgentBnB agent status: identity, credit balance, and configuration.',
+    parameters: {
+      type: 'object',
+      properties: {},
+      required: [],
+    },
+    async execute(_toolCallId, _params) {
+      const ctx = buildMcpContext(toolCtx);
+      const result = await handleStatus(ctx);
+      return toAgentToolResult(result);
+    },
+  };
+}
+
+/** Creates the agentbnb-publish tool. */
+export function createPublishTool(toolCtx: OpenClawToolContext): AgentTool {
+  return {
+    name: 'agentbnb-publish',
+    label: 'AgentBnB Publish',
+    description:
+      'Publish a capability card to the AgentBnB network. Stores locally and optionally syncs to remote registry.',
+    parameters: {
+      type: 'object',
+      properties: {
+        card_json: {
+          type: 'string',
+          description: 'JSON string of the capability card to publish',
+        },
+      },
+      required: ['card_json'],
+    },
+    async execute(_toolCallId, params) {
+      const ctx = buildMcpContext(toolCtx);
+      const result = await handlePublish(params as { card_json: string }, ctx);
+      return toAgentToolResult(result);
+    },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+
+/**
+ * Creates all 5 AgentBnB tools for an OpenClaw bot.
+ * Called by the plugin's `register()` method via `api.registerTool()`.
+ */
+export function createAllTools(toolCtx: OpenClawToolContext): AgentTool[] {
+  return [
+    createDiscoverTool(toolCtx),
+    createRequestTool(toolCtx),
+    createConductTool(toolCtx),
+    createStatusTool(toolCtx),
+    createPublishTool(toolCtx),
+  ];
+}

package/dist/chunk-B2VJTKO5.js

@@ -1,393 +0,0 @@
-import {
-  getFeedbackForProvider,
-  signEscrowReceipt
-} from "./chunk-7EF3HYVZ.js";
-import {
-  AgentBnBError
-} from "./chunk-WVY2W7AA.js";
-
-// src/gateway/client.ts
-import { randomUUID } from "crypto";
-async function requestCapability(opts) {
-  const { gatewayUrl, token, cardId, params = {}, timeoutMs = 3e5, escrowReceipt, identity } = opts;
-  const id = randomUUID();
-  const payload = {
-    jsonrpc: "2.0",
-    id,
-    method: "capability.execute",
-    params: {
-      card_id: cardId,
-      ...params,
-      ...escrowReceipt ? { escrow_receipt: escrowReceipt } : {}
-    }
-  };
-  const headers = { "Content-Type": "application/json" };
-  if (identity) {
-    const signature = signEscrowReceipt(payload, identity.privateKey);
-    headers["X-Agent-Id"] = identity.agentId;
-    headers["X-Agent-Public-Key"] = identity.publicKey;
-    headers["X-Agent-Signature"] = signature;
-  } else if (token) {
-    headers["Authorization"] = `Bearer ${token}`;
-  }
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-  let response;
-  try {
-    response = await fetch(`${gatewayUrl}/rpc`, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(payload),
-      signal: controller.signal
-    });
-  } catch (err) {
-    clearTimeout(timer);
-    const isTimeout = err instanceof Error && err.name === "AbortError";
-    throw new AgentBnBError(
-      isTimeout ? "Request timed out" : `Network error: ${String(err)}`,
-      isTimeout ? "TIMEOUT" : "NETWORK_ERROR"
-    );
-  } finally {
-    clearTimeout(timer);
-  }
-  const body = await response.json();
-  if (body.error) {
-    throw new AgentBnBError(body.error.message, `RPC_ERROR_${body.error.code}`);
-  }
-  return body.result;
-}
-async function requestViaRelay(relay, opts) {
-  try {
-    return await relay.request({
-      targetOwner: opts.targetOwner,
-      cardId: opts.cardId,
-      skillId: opts.skillId,
-      params: opts.params ?? {},
-      requester: opts.requester,
-      escrowReceipt: opts.escrowReceipt,
-      timeoutMs: opts.timeoutMs
-    });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    if (message.includes("timeout")) {
-      throw new AgentBnBError(message, "TIMEOUT");
-    }
-    if (message.includes("offline")) {
-      throw new AgentBnBError(message, "AGENT_OFFLINE");
-    }
-    throw new AgentBnBError(message, "RELAY_ERROR");
-  }
-}
-
-// src/utils/interpolation.ts
-function resolvePath(obj, path) {
-  const segments = path.replace(/\[(\d+)\]/g, ".$1").split(".").filter((s) => s.length > 0);
-  let current = obj;
-  for (const segment of segments) {
-    if (current === null || current === void 0) {
-      return void 0;
-    }
-    if (typeof current !== "object") {
-      return void 0;
-    }
-    current = current[segment];
-  }
-  return current;
-}
-function interpolate(template, context) {
-  return template.replace(/\$\{([^}]+)\}/g, (_match, expression) => {
-    const resolved = resolvePath(context, expression.trim());
-    if (resolved === void 0 || resolved === null) {
-      return "";
-    }
-    if (typeof resolved === "object") {
-      return JSON.stringify(resolved);
-    }
-    return String(resolved);
-  });
-}
-function interpolateObject(obj, context) {
-  const result = {};
-  for (const [key, value] of Object.entries(obj)) {
-    result[key] = interpolateValue(value, context);
-  }
-  return result;
-}
-function interpolateValue(value, context) {
-  if (typeof value === "string") {
-    return interpolate(value, context);
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => interpolateValue(item, context));
-  }
-  if (value !== null && typeof value === "object") {
-    return interpolateObject(value, context);
-  }
-  return value;
-}
-
-// src/feedback/reputation.ts
-var QUALITY_SCORES = {
-  excellent: 1,
-  good: 0.8,
-  acceptable: 0.6,
-  poor: 0.3,
-  failed: 0
-};
-var COST_VALUE_SCORES = {
-  great: 1,
-  fair: 0.6,
-  overpriced: 0.2
-};
-var DECAY_DAYS = 30;
-var WEIGHTS = {
-  rating: 0.4,
-  quality: 0.3,
-  would_reuse: 0.2,
-  cost_value: 0.1
-};
-function computeReputation(feedbacks) {
-  if (feedbacks.length === 0) return 0.5;
-  const now = Date.now();
-  let weightedSum = 0;
-  let totalWeight = 0;
-  for (const fb of feedbacks) {
-    const feedbackDate = new Date(fb.timestamp).getTime();
-    const ageDays = Math.max(0, (now - feedbackDate) / (1e3 * 60 * 60 * 24));
-    const recencyWeight = Math.exp(-ageDays / DECAY_DAYS);
-    const ratingScore = (fb.rating - 1) / 4;
-    const qualityScore = QUALITY_SCORES[fb.result_quality];
-    const reuseScore = fb.would_reuse ? 1 : 0;
-    const costScore = COST_VALUE_SCORES[fb.cost_value_ratio];
-    const componentScore = WEIGHTS.rating * ratingScore + WEIGHTS.quality * qualityScore + WEIGHTS.would_reuse * reuseScore + WEIGHTS.cost_value * costScore;
-    weightedSum += recencyWeight * componentScore;
-    totalWeight += recencyWeight;
-  }
-  if (totalWeight === 0) return 0.5;
-  const raw = weightedSum / totalWeight;
-  return Math.max(0, Math.min(1, raw));
-}
-function getReputationScore(db, agentId) {
-  const feedbacks = getFeedbackForProvider(db, agentId);
-  return computeReputation(feedbacks);
-}
-
-// src/registry/matcher.ts
-function searchCards(db, query, filters = {}) {
-  const words = query.trim().split(/\s+/).map((w) => w.replace(/["*^{}():]/g, "")).filter((w) => w.length > 0);
-  if (words.length === 0) return [];
-  const ftsQuery = words.map((w) => `"${w}"`).join(" OR ");
-  const conditions = [];
-  const params = [ftsQuery];
-  if (filters.level !== void 0) {
-    conditions.push(`json_extract(cc.data, '$.level') = ?`);
-    params.push(filters.level);
-  }
-  if (filters.online !== void 0) {
-    conditions.push(`json_extract(cc.data, '$.availability.online') = ?`);
-    params.push(filters.online ? 1 : 0);
-  }
-  const whereClause = conditions.length > 0 ? `AND ${conditions.join(" AND ")}` : "";
-  const sql = `
-    SELECT cc.data
-    FROM capability_cards cc
-    JOIN cards_fts ON cc.rowid = cards_fts.rowid
-    WHERE cards_fts MATCH ?
-      ${whereClause}
-    ORDER BY bm25(cards_fts)
-    LIMIT 50
-  `;
-  const stmt = db.prepare(sql);
-  const rows = stmt.all(...params);
-  const results = rows.map((row) => JSON.parse(row.data));
-  let filtered = results;
-  if (filters.apis_used && filters.apis_used.length > 0) {
-    const requiredApis = filters.apis_used;
-    filtered = filtered.filter((card) => {
-      const cardApis = card.metadata?.apis_used ?? [];
-      return requiredApis.every((api) => cardApis.includes(api));
-    });
-  }
-  if (filters.min_reputation !== void 0 && filters.min_reputation > 0) {
-    filtered = applyReputationFilter(db, filtered, filters.min_reputation);
-  }
-  return filtered;
-}
-function filterCards(db, filters) {
-  const conditions = [];
-  const params = [];
-  if (filters.level !== void 0) {
-    conditions.push(`json_extract(data, '$.level') = ?`);
-    params.push(filters.level);
-  }
-  if (filters.online !== void 0) {
-    conditions.push(`json_extract(data, '$.availability.online') = ?`);
-    params.push(filters.online ? 1 : 0);
-  }
-  const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-  const sql = `SELECT data FROM capability_cards ${whereClause}`;
-  const stmt = db.prepare(sql);
-  const rows = stmt.all(...params);
-  let cards = rows.map((row) => JSON.parse(row.data));
-  if (filters.min_reputation !== void 0 && filters.min_reputation > 0) {
-    cards = applyReputationFilter(db, cards, filters.min_reputation);
-  }
-  return cards;
-}
-function applyReputationFilter(db, cards, minReputation) {
-  const owners = [...new Set(cards.map((c) => c.owner))];
-  const reputationMap = /* @__PURE__ */ new Map();
-  for (const owner of owners) {
-    reputationMap.set(owner, getReputationScore(db, owner));
-  }
-  return cards.filter((card) => {
-    const score = reputationMap.get(card.owner) ?? 0.5;
-    return score >= minReputation;
-  });
-}
-function buildReputationMap(db, owners) {
-  const unique = [...new Set(owners)];
-  const map = /* @__PURE__ */ new Map();
-  for (const owner of unique) {
-    map.set(owner, getReputationScore(db, owner));
-  }
-  return map;
-}
-
-// src/autonomy/tiers.ts
-import { randomUUID as randomUUID2 } from "crypto";
-var DEFAULT_AUTONOMY_CONFIG = {
-  tier1_max_credits: 0,
-  tier2_max_credits: 0
-};
-function getAutonomyTier(creditAmount, config) {
-  if (creditAmount < config.tier1_max_credits) return 1;
-  if (creditAmount < config.tier2_max_credits) return 2;
-  return 3;
-}
-function insertAuditEvent(db, event) {
-  const isShareEvent = event.type === "auto_share" || event.type === "auto_share_notify" || event.type === "auto_share_pending";
-  const cardId = isShareEvent ? "system" : event.card_id;
-  const creditsCharged = isShareEvent ? 0 : event.credits;
-  const stmt = db.prepare(`
-    INSERT INTO request_log (
-      id, card_id, card_name, requester, status, latency_ms, credits_charged,
-      created_at, skill_id, action_type, tier_invoked
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `);
-  stmt.run(
-    randomUUID2(),
-    cardId,
-    "autonomy-audit",
-    "self",
-    "success",
-    0,
-    creditsCharged,
-    (/* @__PURE__ */ new Date()).toISOString(),
-    event.skill_id,
-    event.type,
-    event.tier_invoked
-  );
-}
-
-// src/cli/remote-registry.ts
-var RegistryTimeoutError = class extends AgentBnBError {
-  constructor(url) {
-    super(
-      `Registry at ${url} did not respond within 5s. Showing local results only.`,
-      "REGISTRY_TIMEOUT"
-    );
-    this.name = "RegistryTimeoutError";
-  }
-};
-var RegistryConnectionError = class extends AgentBnBError {
-  constructor(url) {
-    super(
-      `Cannot reach ${url}. Is the registry running? Showing local results only.`,
-      "REGISTRY_CONNECTION"
-    );
-    this.name = "RegistryConnectionError";
-  }
-};
-var RegistryAuthError = class extends AgentBnBError {
-  constructor(url) {
-    super(
-      `Authentication failed for ${url}. Run \`agentbnb config set token <your-token>\`.`,
-      "REGISTRY_AUTH"
-    );
-    this.name = "RegistryAuthError";
-  }
-};
-async function fetchRemoteCards(registryUrl, params, timeoutMs = 5e3) {
-  let cardsUrl;
-  try {
-    cardsUrl = new URL("/cards", registryUrl);
-  } catch {
-    throw new AgentBnBError(`Invalid registry URL: ${registryUrl}`, "INVALID_REGISTRY_URL");
-  }
-  const searchParams = new URLSearchParams();
-  if (params.q !== void 0) searchParams.set("q", params.q);
-  if (params.level !== void 0) searchParams.set("level", String(params.level));
-  if (params.online !== void 0) searchParams.set("online", String(params.online));
-  if (params.tag !== void 0) searchParams.set("tag", params.tag);
-  searchParams.set("limit", "100");
-  cardsUrl.search = searchParams.toString();
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-  let response;
-  try {
-    response = await fetch(cardsUrl.toString(), { signal: controller.signal });
-  } catch (err) {
-    clearTimeout(timer);
-    const isTimeout = err instanceof Error && err.name === "AbortError";
-    if (isTimeout) {
-      throw new RegistryTimeoutError(registryUrl);
-    }
-    throw new RegistryConnectionError(registryUrl);
-  } finally {
-    clearTimeout(timer);
-  }
-  if (response.status === 401 || response.status === 403) {
-    throw new RegistryAuthError(registryUrl);
-  }
-  if (!response.ok) {
-    throw new RegistryConnectionError(registryUrl);
-  }
-  const body = await response.json();
-  return body.items;
-}
-
-// src/autonomy/pending-requests.ts
-import { randomUUID as randomUUID3 } from "crypto";
-function listPendingRequests(db) {
-  const rows = db.prepare(`SELECT * FROM pending_requests WHERE status = 'pending' ORDER BY created_at DESC`).all();
-  return rows;
-}
-function resolvePendingRequest(db, id, resolution) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const result = db.prepare(
-    `UPDATE pending_requests SET status = ?, resolved_at = ? WHERE id = ?`
-  ).run(resolution, now, id);
-  if (result.changes === 0) {
-    throw new AgentBnBError(
-      `Pending request not found: ${id}`,
-      "NOT_FOUND"
-    );
-  }
-}
-
-export {
-  interpolateObject,
-  computeReputation,
-  searchCards,
-  filterCards,
-  buildReputationMap,
-  requestCapability,
-  requestViaRelay,
-  DEFAULT_AUTONOMY_CONFIG,
-  getAutonomyTier,
-  insertAuditEvent,
-  listPendingRequests,
-  resolvePendingRequest,
-  fetchRemoteCards
-};