agentbnb 4.0.4 → 5.1.1

package/dist/chunk-MLS6IGGG.js

@@ -0,0 +1,294 @@
+import {
+  searchCards
+} from "./chunk-NH2FIERR.js";
+
+// src/cli/onboarding.ts
+import { randomUUID } from "crypto";
+import { createConnection } from "net";
+var KNOWN_API_KEYS = [
+  "OPENAI_API_KEY",
+  "ANTHROPIC_API_KEY",
+  "ELEVENLABS_API_KEY",
+  "KLING_API_KEY",
+  "STABILITY_API_KEY",
+  "REPLICATE_API_TOKEN",
+  "GOOGLE_API_KEY",
+  "AZURE_OPENAI_API_KEY",
+  "COHERE_API_KEY",
+  "MISTRAL_API_KEY"
+];
+var API_TEMPLATES = {
+  OPENAI_API_KEY: {
+    name: "OpenAI Text Generation",
+    description: "Text completion and chat via OpenAI API",
+    level: 1,
+    inputs: [{ name: "prompt", type: "text", required: true }],
+    outputs: [{ name: "completion", type: "text", required: true }],
+    pricing: { credits_per_call: 5 },
+    powered_by: [{ provider: "OpenAI", model: "GPT-4o" }],
+    metadata: { apis_used: ["openai"], tags: ["llm", "text", "generation"] }
+  },
+  ANTHROPIC_API_KEY: {
+    name: "Anthropic Claude",
+    description: "Text reasoning and analysis via Anthropic Claude API",
+    level: 1,
+    inputs: [{ name: "prompt", type: "text", required: true }],
+    outputs: [{ name: "response", type: "text", required: true }],
+    pricing: { credits_per_call: 5 },
+    powered_by: [{ provider: "Anthropic", model: "Claude" }],
+    metadata: { apis_used: ["anthropic"], tags: ["llm", "text", "reasoning"] }
+  },
+  ELEVENLABS_API_KEY: {
+    name: "ElevenLabs Text-to-Speech",
+    description: "High-quality voice synthesis via ElevenLabs API",
+    level: 1,
+    inputs: [{ name: "text", type: "text", required: true }],
+    outputs: [{ name: "audio", type: "audio", required: true }],
+    pricing: { credits_per_call: 10 },
+    powered_by: [{ provider: "ElevenLabs" }],
+    metadata: { apis_used: ["elevenlabs"], tags: ["tts", "audio", "voice"] }
+  },
+  KLING_API_KEY: {
+    name: "Kling Video Generation",
+    description: "AI video generation via Kling API",
+    level: 1,
+    inputs: [{ name: "prompt", type: "text", required: true }],
+    outputs: [{ name: "video", type: "video", required: true }],
+    pricing: { credits_per_call: 50 },
+    powered_by: [{ provider: "Kling", model: "v1.5" }],
+    metadata: { apis_used: ["kling"], tags: ["video", "generation", "ai"] }
+  },
+  STABILITY_API_KEY: {
+    name: "Stability AI Image Generation",
+    description: "Image generation via Stability AI (Stable Diffusion)",
+    level: 1,
+    inputs: [{ name: "prompt", type: "text", required: true }],
+    outputs: [{ name: "image", type: "image", required: true }],
+    pricing: { credits_per_call: 8 },
+    powered_by: [{ provider: "Stability AI", model: "SDXL" }],
+    metadata: { apis_used: ["stability"], tags: ["image", "generation", "diffusion"] }
+  },
+  REPLICATE_API_TOKEN: {
+    name: "Replicate Model Runner",
+    description: "Run open-source models via Replicate API",
+    level: 1,
+    inputs: [{ name: "input", type: "json", required: true }],
+    outputs: [{ name: "output", type: "json", required: true }],
+    pricing: { credits_per_call: 10 },
+    powered_by: [{ provider: "Replicate" }],
+    metadata: { apis_used: ["replicate"], tags: ["ml", "inference"] }
+  },
+  GOOGLE_API_KEY: {
+    name: "Google AI (Gemini)",
+    description: "Multimodal AI via Google Gemini API",
+    level: 1,
+    inputs: [{ name: "prompt", type: "text", required: true }],
+    outputs: [{ name: "response", type: "text", required: true }],
+    pricing: { credits_per_call: 5 },
+    powered_by: [{ provider: "Google", model: "Gemini" }],
+    metadata: { apis_used: ["google"], tags: ["llm", "multimodal", "text"] }
+  },
+  AZURE_OPENAI_API_KEY: {
+    name: "Azure OpenAI Service",
+    description: "OpenAI models hosted on Azure cloud",
+    level: 1,
+    inputs: [{ name: "prompt", type: "text", required: true }],
+    outputs: [{ name: "completion", type: "text", required: true }],
+    pricing: { credits_per_call: 5 },
+    powered_by: [{ provider: "Azure OpenAI" }],
+    metadata: { apis_used: ["azure-openai"], tags: ["llm", "text", "azure"] }
+  },
+  COHERE_API_KEY: {
+    name: "Cohere Language AI",
+    description: "Text generation and embeddings via Cohere API",
+    level: 1,
+    inputs: [{ name: "text", type: "text", required: true }],
+    outputs: [{ name: "response", type: "text", required: true }],
+    pricing: { credits_per_call: 3 },
+    powered_by: [{ provider: "Cohere" }],
+    metadata: { apis_used: ["cohere"], tags: ["llm", "embeddings", "text"] }
+  },
+  MISTRAL_API_KEY: {
+    name: "Mistral AI",
+    description: "Text generation via Mistral AI API",
+    level: 1,
+    inputs: [{ name: "prompt", type: "text", required: true }],
+    outputs: [{ name: "response", type: "text", required: true }],
+    pricing: { credits_per_call: 4 },
+    powered_by: [{ provider: "Mistral" }],
+    metadata: { apis_used: ["mistral"], tags: ["llm", "text", "generation"] }
+  }
+};
+function detectApiKeys(knownKeys) {
+  return knownKeys.filter((key) => key in process.env);
+}
+async function isPortOpen(port, host = "127.0.0.1", timeoutMs = 300) {
+  return new Promise((resolve) => {
+    const socket = createConnection({ port, host });
+    const timer = setTimeout(() => {
+      socket.destroy();
+      resolve(false);
+    }, timeoutMs);
+    socket.on("connect", () => {
+      clearTimeout(timer);
+      socket.destroy();
+      resolve(true);
+    });
+    socket.on("error", () => {
+      clearTimeout(timer);
+      resolve(false);
+    });
+  });
+}
+async function detectOpenPorts(ports) {
+  const results = await Promise.all(
+    ports.map(async (port) => ({ port, open: await isPortOpen(port) }))
+  );
+  return results.filter((r) => r.open).map((r) => r.port);
+}
+function buildDraftCard(apiKey, owner) {
+  const template = API_TEMPLATES[apiKey];
+  if (!template) return null;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    spec_version: "1.0",
+    id: randomUUID(),
+    owner,
+    name: template.name,
+    description: template.description,
+    level: template.level,
+    inputs: template.inputs,
+    outputs: template.outputs,
+    pricing: template.pricing,
+    availability: { online: true },
+    powered_by: template.powered_by,
+    metadata: {
+      apis_used: template.metadata.apis_used,
+      tags: template.metadata.tags
+    },
+    created_at: now,
+    updated_at: now
+  };
+}
+
+// src/registry/pricing.ts
+function getPricingStats(db, query) {
+  const cards = searchCards(db, query);
+  const prices = [];
+  const queryLower = query.toLowerCase();
+  const queryWords = queryLower.split(/\s+/).filter((w) => w.length > 0);
+  for (const card of cards) {
+    const v2 = card;
+    if (v2.skills && v2.skills.length > 0) {
+      for (const skill of v2.skills) {
+        const nameMatch = skillMatchesQuery(skill, queryWords);
+        if (nameMatch) {
+          prices.push(skill.pricing.credits_per_call);
+        }
+      }
+    } else {
+      prices.push(card.pricing.credits_per_call);
+    }
+  }
+  if (prices.length === 0) {
+    return { min: 0, max: 0, median: 0, mean: 0, count: 0 };
+  }
+  prices.sort((a, b) => a - b);
+  const min = prices[0];
+  const max = prices[prices.length - 1];
+  const mean = prices.reduce((sum, p) => sum + p, 0) / prices.length;
+  const median = computeMedian(prices);
+  return { min, max, median, mean, count: prices.length };
+}
+function skillMatchesQuery(skill, queryWords) {
+  const text = `${skill.name} ${skill.description}`.toLowerCase();
+  return queryWords.some((word) => text.includes(word));
+}
+function computeMedian(sorted) {
+  const mid = Math.floor(sorted.length / 2);
+  if (sorted.length % 2 === 1) {
+    return sorted[mid];
+  }
+  return (sorted[mid - 1] + sorted[mid]) / 2;
+}
+
+// src/discovery/mdns.ts
+import { Bonjour } from "bonjour-service";
+var bonjourInstance = null;
+function getBonjour() {
+  if (bonjourInstance === null) {
+    bonjourInstance = new Bonjour();
+  }
+  return bonjourInstance;
+}
+function announceGateway(owner, port, metadata) {
+  const bonjour = getBonjour();
+  const txt = {
+    owner,
+    version: "1.0",
+    ...metadata
+  };
+  bonjour.publish({
+    name: owner,
+    type: "agentbnb",
+    port,
+    txt
+  });
+}
+function discoverLocalAgents(onFound, onDown) {
+  const bonjour = getBonjour();
+  const browser = bonjour.find({ type: "agentbnb" });
+  browser.on("up", (service) => {
+    const addresses = service.addresses ?? [];
+    const ipv4Addresses = addresses.filter((addr) => !addr.includes(":"));
+    const host = ipv4Addresses.length > 0 ? ipv4Addresses[0] : service.host;
+    const url = `http://${host}:${service.port}`;
+    const owner = service.txt?.owner ?? service.name;
+    onFound({
+      name: service.name,
+      url,
+      owner
+    });
+  });
+  if (onDown) {
+    browser.on("down", (service) => {
+      const addresses = service.addresses ?? [];
+      const ipv4Addresses = addresses.filter((addr) => !addr.includes(":"));
+      const host = ipv4Addresses.length > 0 ? ipv4Addresses[0] : service.host;
+      const url = `http://${host}:${service.port}`;
+      const owner = service.txt?.owner ?? service.name;
+      onDown({
+        name: service.name,
+        url,
+        owner
+      });
+    });
+  }
+  return {
+    stop: () => browser.stop()
+  };
+}
+async function stopAnnouncement() {
+  if (bonjourInstance === null) {
+    return;
+  }
+  const instance = bonjourInstance;
+  bonjourInstance = null;
+  await new Promise((resolve) => {
+    instance.unpublishAll(() => {
+      instance.destroy();
+      resolve();
+    });
+  });
+}
+
+export {
+  KNOWN_API_KEYS,
+  detectApiKeys,
+  detectOpenPorts,
+  buildDraftCard,
+  getPricingStats,
+  announceGateway,
+  discoverLocalAgents,
+  stopAnnouncement
+};

package/dist/{chunk-4P3EMGL4.js → chunk-MNO4COST.js}

@@ -3,11 +3,13 @@ import {
 } from "./chunk-3MJT4PZG.js";
 import {
   scorePeers
-} from "./chunk-GGYC5U2Z.js";
+} from "./chunk-BTTL24TZ.js";
+import {
+  fetchRemoteCards
+} from "./chunk-ZX5623ER.js";
 import {
-  fetchRemoteCards,
   searchCards
-} from "./chunk-FF226TIV.js";
+} from "./chunk-NH2FIERR.js";
 import {
   requestCapability
 } from "./chunk-XND2DWTZ.js";

package/dist/chunk-NH2FIERR.js

@@ -0,0 +1,138 @@
+import {
+  getFeedbackForProvider
+} from "./chunk-EANI2N2V.js";
+
+// 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;
+}
+
+export {
+  computeReputation,
+  searchCards,
+  filterCards,
+  buildReputationMap
+};

package/dist/chunk-UKT6H7YT.js

@@ -0,0 +1,29 @@
+import {
+  confirmEscrowDebit,
+  recordEarning,
+  releaseEscrow
+} from "./chunk-EANI2N2V.js";
+
+// src/credit/settlement.ts
+function settleProviderEarning(providerDb, providerOwner, receipt) {
+  recordEarning(
+    providerDb,
+    providerOwner,
+    receipt.amount,
+    receipt.card_id,
+    receipt.nonce
+  );
+  return { settled: true };
+}
+function settleRequesterEscrow(requesterDb, escrowId) {
+  confirmEscrowDebit(requesterDb, escrowId);
+}
+function releaseRequesterEscrow(requesterDb, escrowId) {
+  releaseEscrow(requesterDb, escrowId);
+}
+
+export {
+  settleProviderEarning,
+  settleRequesterEscrow,
+  releaseRequesterEscrow
+};

package/dist/{chunk-BH6WGYFB.js → chunk-VE3E4AMH.js}

@@ -1,13 +1,16 @@
+import {
+  RelayClient
+} from "./chunk-JOY533UH.js";
 import {
   BudgetController,
   ORCHESTRATION_FEE,
   decompose,
   matchSubTasks,
   orchestrate
-} from "./chunk-4P3EMGL4.js";
+} from "./chunk-MNO4COST.js";
 import {
   BudgetManager
-} from "./chunk-GGYC5U2Z.js";
+} from "./chunk-BTTL24TZ.js";
 import {
   loadPeers
 } from "./chunk-5AH3CMOX.js";
@@ -16,13 +19,10 @@ import {
 } from "./chunk-75OC6E4F.js";
 import {
   openDatabase
-} from "./chunk-T7NS2J2B.js";
+} from "./chunk-DFBX3BBD.js";
 import {
   openCreditDb
-} from "./chunk-DNWT5FZQ.js";
-import {
-  RelayClient
-} from "./chunk-JOY533UH.js";
+} from "./chunk-EANI2N2V.js";
 
 // src/cli/conduct.ts
 async function conductAction(task, opts) {
@@ -103,7 +103,7 @@ async function conductAction(task, opts) {
       return { url: `relay://${owner}`, cardId };
     }
     throw new Error(
-      `Unknown peer "${owner}". Add with: agentbnb peers add ${owner} <url> <token>`
+      `Unknown peer "${owner}". Add with: agentbnb connect ${owner} <url> <token>`
     );
   };
   let relay;