agentbnb 9.0.2 → 9.1.0

package/dist/chunk-QXRNW4OJ.js

@@ -0,0 +1,35 @@
+import {
+  __require
+} from "./chunk-3RG5ZIWI.js";
+
+// src/core-config.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+var coreBasePath = null;
+var coreResolved = false;
+function resolveCoreBase() {
+  if (coreResolved) return coreBasePath;
+  coreResolved = true;
+  try {
+    const pkgPath = __require.resolve("@agentbnb/core/package.json");
+    coreBasePath = join(pkgPath, "..");
+    return coreBasePath;
+  } catch {
+    return null;
+  }
+}
+function loadCoreConfig(configName) {
+  const base = resolveCoreBase();
+  if (!base) return null;
+  try {
+    const filePath = join(base, "config", `${configName}.json`);
+    const raw = readFileSync(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+export {
+  loadCoreConfig
+};

package/dist/{chunk-UR3MISL2.js → chunk-UPNREF4L.js}

@@ -1,6 +1,6 @@
 import {
   RelayMessageSchema
-} from "./chunk-3466S65P.js";
+} from "./chunk-Q5OFZ2JR.js";
 
 // src/relay/websocket-client.ts
 import WebSocket from "ws";

package/dist/{chunk-SMQDT7CT.js → chunk-UXL7DV7P.js}

@@ -3,13 +3,16 @@ import {
 } from "./chunk-3MJT4PZG.js";
 import {
   scorePeers
-} from "./chunk-UQCQ2JCG.js";
+} from "./chunk-JJHQAZWE.js";
 import {
   fetchRemoteCards
 } from "./chunk-ELFGYC22.js";
 import {
   searchCards
-} from "./chunk-QEDVPJKP.js";
+} from "./chunk-4DBSSFHG.js";
+import {
+  loadCoreConfig
+} from "./chunk-QXRNW4OJ.js";
 import {
   requestCapability,
   requestCapabilityBatch
@@ -321,7 +324,8 @@ async function matchSubTasks(opts) {
 }
 
 // src/conductor/budget-controller.ts
-var ORCHESTRATION_FEE = 5;
+var coreConductor = loadCoreConfig("economics");
+var ORCHESTRATION_FEE = coreConductor?.conductor?.orchestration_fee ?? 5;
 var BudgetController = class {
   /**
    * Creates a new BudgetController.

package/dist/{chunk-PG3CLSAH.js → chunk-VJ2Q33AP.js}

@@ -1,3 +1,6 @@
+import {
+  createRequestLogTable
+} from "./chunk-4XTYT4JW.js";
 import {
   ensureAgentsTable,
   resolveCanonicalIdentity
@@ -8,136 +11,6 @@ import {
   CapabilityCardSchema
 } from "./chunk-UVCNMRPS.js";
 
-// src/registry/request-log.ts
-var SINCE_MS = {
-  "24h": 864e5,
-  "7d": 6048e5,
-  "30d": 2592e6
-};
-function createRequestLogTable(db) {
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS request_log (
-      id TEXT PRIMARY KEY,
-      card_id TEXT NOT NULL,
-      card_name TEXT NOT NULL,
-      requester TEXT NOT NULL,
-      status TEXT NOT NULL CHECK(status IN ('success', 'failure', 'timeout')),
-      latency_ms INTEGER NOT NULL,
-      credits_charged INTEGER NOT NULL,
-      created_at TEXT NOT NULL
-    );
-
-    CREATE INDEX IF NOT EXISTS request_log_created_at_idx
-      ON request_log (created_at DESC);
-  `);
-  try {
-    db.exec("ALTER TABLE request_log ADD COLUMN skill_id TEXT");
-  } catch {
-  }
-  try {
-    db.exec("ALTER TABLE request_log ADD COLUMN action_type TEXT");
-  } catch {
-  }
-  try {
-    db.exec("ALTER TABLE request_log ADD COLUMN tier_invoked INTEGER");
-  } catch {
-  }
-  try {
-    db.exec("ALTER TABLE request_log ADD COLUMN failure_reason TEXT");
-  } catch {
-  }
-  try {
-    db.exec("ALTER TABLE request_log ADD COLUMN team_id TEXT");
-  } catch {
-  }
-  try {
-    db.exec("ALTER TABLE request_log ADD COLUMN role TEXT");
-  } catch {
-  }
-  try {
-    db.exec("ALTER TABLE request_log ADD COLUMN capability_type TEXT");
-  } catch {
-  }
-}
-function insertRequestLog(db, entry) {
-  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, failure_reason, team_id, role, capability_type)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `);
-  stmt.run(
-    entry.id,
-    entry.card_id,
-    entry.card_name,
-    entry.requester,
-    entry.status,
-    entry.latency_ms,
-    entry.credits_charged,
-    entry.created_at,
-    entry.skill_id ?? null,
-    entry.action_type ?? null,
-    entry.tier_invoked ?? null,
-    entry.failure_reason ?? null,
-    entry.team_id ?? null,
-    entry.role ?? null,
-    entry.capability_type ?? null
-  );
-}
-function getSkillRequestCount(db, skillId, windowMs) {
-  const cutoff = new Date(Date.now() - windowMs).toISOString();
-  const stmt = db.prepare(
-    `SELECT COUNT(*) as cnt FROM request_log
-     WHERE skill_id = ? AND created_at >= ? AND status = 'success' AND action_type IS NULL`
-  );
-  const row = stmt.get(skillId, cutoff);
-  return row.cnt;
-}
-function getActivityFeed(db, limit = 20, since) {
-  const effectiveLimit = Math.min(limit, 100);
-  if (since !== void 0) {
-    const stmt2 = db.prepare(`
-      SELECT r.id, r.card_name, r.requester, c.owner AS provider,
-             r.status, r.credits_charged, r.latency_ms, r.created_at, r.action_type
-      FROM request_log r
-      LEFT JOIN capability_cards c ON r.card_id = c.id
-      WHERE (r.action_type IS NULL OR r.action_type IN ('auto_share', 'agent_joined'))
-        AND r.created_at > ?
-      ORDER BY r.created_at DESC
-      LIMIT ?
-    `);
-    return stmt2.all(since, effectiveLimit);
-  }
-  const stmt = db.prepare(`
-    SELECT r.id, r.card_name, r.requester, c.owner AS provider,
-           r.status, r.credits_charged, r.latency_ms, r.created_at, r.action_type
-    FROM request_log r
-    LEFT JOIN capability_cards c ON r.card_id = c.id
-    WHERE (r.action_type IS NULL OR r.action_type IN ('auto_share', 'agent_joined'))
-    ORDER BY r.created_at DESC
-    LIMIT ?
-  `);
-  return stmt.all(effectiveLimit);
-}
-function getRequestLog(db, limit = 10, since) {
-  if (since !== void 0) {
-    const cutoff = new Date(Date.now() - SINCE_MS[since]).toISOString();
-    const stmt2 = db.prepare(`
-      SELECT id, card_id, card_name, requester, status, latency_ms, credits_charged, created_at, skill_id, action_type, tier_invoked, failure_reason, team_id, role, capability_type
-      FROM request_log
-      WHERE created_at >= ?
-      ORDER BY created_at DESC
-      LIMIT ?
-    `);
-    return stmt2.all(cutoff, limit);
-  }
-  const stmt = db.prepare(`
-    SELECT id, card_id, card_name, requester, status, latency_ms, credits_charged, created_at, skill_id, action_type, tier_invoked, failure_reason, team_id, role
-    FROM request_log
-    ORDER BY created_at DESC
-    LIMIT ?
-  `);
-  return stmt.all(limit);
-}
-
 // src/registry/store.ts
 import Database from "better-sqlite3";
 
@@ -822,10 +695,6 @@ function getCardsBySkillCapability(db, capabilityType) {
 }
 
 export {
-  insertRequestLog,
-  getSkillRequestCount,
-  getActivityFeed,
-  getRequestLog,
   insertFeedback,
   getFeedbackForSkill,
   getFeedbackForProvider,

package/dist/{chunk-DYJ7YGBM.js → chunk-WOVESOQ7.js}

@@ -1,165 +1,267 @@
+import {
+  loadCoreConfig
+} from "./chunk-QXRNW4OJ.js";
+
 // src/relay/websocket-client.ts
 import WebSocket from "ws";
 import { randomUUID } from "crypto";
 
 // src/relay/types.ts
+import { z as z2 } from "zod";
+
+// src/session/session-types.ts
 import { z } from "zod";
-var RegisterMessageSchema = z.object({
-  type: z.literal("register"),
-  owner: z.string().min(1),
+var DEFAULT_SESSION_CONFIG = {
+  pricing: {
+    default_model: "per_message",
+    per_message_base_rate: 2,
+    per_minute_base_rate: 1,
+    per_session_flat_rate: 10,
+    max_messages_per_session: 50,
+    max_minutes_per_session: 30
+  },
+  timeouts: {
+    idle_timeout_ms: 12e4,
+    max_session_duration_ms: 18e5,
+    message_timeout_ms: 9e4
+  },
+  abuse: {
+    max_concurrent_sessions_per_agent: 5,
+    max_sessions_per_hour: 20,
+    min_message_interval_ms: 1e3
+  },
+  quality: {
+    min_provider_reputation_for_session: 0.5,
+    auto_refund_on_timeout: true,
+    partial_refund_ratio: 0.5
+  }
+};
+function loadSessionConfig() {
+  const core = loadCoreConfig("session");
+  if (!core) return DEFAULT_SESSION_CONFIG;
+  return {
+    pricing: { ...DEFAULT_SESSION_CONFIG.pricing, ...core.pricing },
+    timeouts: { ...DEFAULT_SESSION_CONFIG.timeouts, ...core.timeouts },
+    abuse: { ...DEFAULT_SESSION_CONFIG.abuse, ...core.abuse },
+    quality: { ...DEFAULT_SESSION_CONFIG.quality, ...core.quality }
+  };
+}
+var SessionPricingModelSchema = z.enum(["per_message", "per_minute", "per_session"]);
+var SessionOpenMessageSchema = z.object({
+  type: z.literal("session_open"),
+  session_id: z.string().uuid(),
+  requester_id: z.string().min(1),
+  provider_id: z.string().min(1),
+  card_id: z.string().min(1),
+  skill_id: z.string().min(1),
+  budget: z.number().positive(),
+  pricing_model: SessionPricingModelSchema.default("per_message"),
+  initial_message: z.string().min(1),
+  ucan_token: z.string().optional()
+});
+var SessionAckMessageSchema = z.object({
+  type: z.literal("session_ack"),
+  session_id: z.string(),
+  escrow_id: z.string(),
+  status: z.literal("open")
+});
+var SessionMessageMessageSchema = z.object({
+  type: z.literal("session_message"),
+  session_id: z.string().uuid(),
+  sender: z.enum(["requester", "provider"]),
+  content: z.string().min(1),
+  metadata: z.object({
+    model: z.string().optional(),
+    latency_ms: z.number().optional(),
+    tokens_used: z.number().optional()
+  }).optional()
+});
+var SessionEndMessageSchema = z.object({
+  type: z.literal("session_end"),
+  session_id: z.string().uuid(),
+  reason: z.enum(["completed", "timeout", "budget_exhausted", "error", "cancelled"]).default("completed"),
+  summary: z.string().optional()
+});
+var SessionSettledMessageSchema = z.object({
+  type: z.literal("session_settled"),
+  session_id: z.string(),
+  total_cost: z.number(),
+  messages_count: z.number(),
+  duration_seconds: z.number(),
+  refunded: z.number()
+});
+var SessionErrorMessageSchema = z.object({
+  type: z.literal("session_error"),
+  session_id: z.string(),
+  code: z.string(),
+  message: z.string()
+});
+var SESSION_MESSAGE_TYPES = /* @__PURE__ */ new Set([
+  "session_open",
+  "session_ack",
+  "session_message",
+  "session_end",
+  "session_settled",
+  "session_error"
+]);
+
+// src/relay/types.ts
+var RegisterMessageSchema = z2.object({
+  type: z2.literal("register"),
+  owner: z2.string().min(1),
   /** V8: Cryptographic agent identity. When present, used as the canonical key. */
-  agent_id: z.string().optional(),
+  agent_id: z2.string().optional(),
   /** V8 Phase 3: Server identifier for multi-agent delegation. */
-  server_id: z.string().optional(),
-  token: z.string().min(1),
-  card: z.record(z.unknown()),
+  server_id: z2.string().optional(),
+  token: z2.string().min(1),
+  card: z2.record(z2.unknown()),
   // CapabilityCard (validated separately)
-  cards: z.array(z.record(z.unknown())).optional(),
+  cards: z2.array(z2.record(z2.unknown())).optional(),
   // Additional cards (e.g., conductor card)
   /** V8 Phase 3: Additional agents served by this server (multi-agent registration). */
-  agents: z.array(z.object({
-    agent_id: z.string().min(1),
-    display_name: z.string().min(1),
-    cards: z.array(z.record(z.unknown())),
-    delegation_token: z.record(z.unknown()).optional()
+  agents: z2.array(z2.object({
+    agent_id: z2.string().min(1),
+    display_name: z2.string().min(1),
+    cards: z2.array(z2.record(z2.unknown())),
+    delegation_token: z2.record(z2.unknown()).optional()
   })).optional()
 });
-var RegisteredMessageSchema = z.object({
-  type: z.literal("registered"),
-  agent_id: z.string()
+var RegisteredMessageSchema = z2.object({
+  type: z2.literal("registered"),
+  agent_id: z2.string()
 });
-var RelayRequestMessageSchema = z.object({
-  type: z.literal("relay_request"),
-  id: z.string().uuid(),
-  target_owner: z.string().min(1),
+var RelayRequestMessageSchema = z2.object({
+  type: z2.literal("relay_request"),
+  id: z2.string().uuid(),
+  target_owner: z2.string().min(1),
   /** V8: Target agent's cryptographic identity. Preferred over target_owner. */
-  target_agent_id: z.string().optional(),
-  card_id: z.string(),
-  skill_id: z.string().optional(),
-  params: z.record(z.unknown()).default({}),
-  requester: z.string().optional(),
-  escrow_receipt: z.record(z.unknown()).optional(),
+  target_agent_id: z2.string().optional(),
+  card_id: z2.string(),
+  skill_id: z2.string().optional(),
+  params: z2.record(z2.unknown()).default({}),
+  requester: z2.string().optional(),
+  escrow_receipt: z2.record(z2.unknown()).optional(),
   /** Optional UCAN token for capability delegation. */
-  ucan_token: z.string().optional()
+  ucan_token: z2.string().optional()
 });
-var IncomingRequestMessageSchema = z.object({
-  type: z.literal("incoming_request"),
-  id: z.string().uuid(),
-  from_owner: z.string().min(1),
-  card_id: z.string(),
-  skill_id: z.string().optional(),
-  params: z.record(z.unknown()).default({}),
-  requester: z.string().optional(),
-  escrow_receipt: z.record(z.unknown()).optional(),
+var IncomingRequestMessageSchema = z2.object({
+  type: z2.literal("incoming_request"),
+  id: z2.string().uuid(),
+  from_owner: z2.string().min(1),
+  card_id: z2.string(),
+  skill_id: z2.string().optional(),
+  params: z2.record(z2.unknown()).default({}),
+  requester: z2.string().optional(),
+  escrow_receipt: z2.record(z2.unknown()).optional(),
   /** Optional UCAN token for capability delegation. */
-  ucan_token: z.string().optional()
+  ucan_token: z2.string().optional()
 });
-var RelayResponseMessageSchema = z.object({
-  type: z.literal("relay_response"),
-  id: z.string().uuid(),
-  result: z.unknown().optional(),
-  error: z.object({
-    code: z.number(),
-    message: z.string()
+var RelayResponseMessageSchema = z2.object({
+  type: z2.literal("relay_response"),
+  id: z2.string().uuid(),
+  result: z2.unknown().optional(),
+  error: z2.object({
+    code: z2.number(),
+    message: z2.string()
   }).optional()
 });
-var ResponseMessageSchema = z.object({
-  type: z.literal("response"),
-  id: z.string().uuid(),
-  result: z.unknown().optional(),
-  error: z.object({
-    code: z.number(),
-    message: z.string()
+var ResponseMessageSchema = z2.object({
+  type: z2.literal("response"),
+  id: z2.string().uuid(),
+  result: z2.unknown().optional(),
+  error: z2.object({
+    code: z2.number(),
+    message: z2.string()
   }).optional()
 });
-var ErrorMessageSchema = z.object({
-  type: z.literal("error"),
-  code: z.string(),
-  message: z.string(),
-  request_id: z.string().optional()
+var ErrorMessageSchema = z2.object({
+  type: z2.literal("error"),
+  code: z2.string(),
+  message: z2.string(),
+  request_id: z2.string().optional()
 });
-var RelayProgressMessageSchema = z.object({
-  type: z.literal("relay_progress"),
-  id: z.string().uuid(),
+var RelayProgressMessageSchema = z2.object({
+  type: z2.literal("relay_progress"),
+  id: z2.string().uuid(),
   // request ID this progress relates to
-  progress: z.number().min(0).max(100).optional(),
+  progress: z2.number().min(0).max(100).optional(),
   // optional percentage
-  message: z.string().optional()
+  message: z2.string().optional()
   // optional status message
 });
-var RelayStartedMessageSchema = z.object({
-  type: z.literal("relay_started"),
-  id: z.string().uuid(),
-  message: z.string().optional()
+var RelayStartedMessageSchema = z2.object({
+  type: z2.literal("relay_started"),
+  id: z2.string().uuid(),
+  message: z2.string().optional()
 });
-var HeartbeatMessageSchema = z.object({
-  type: z.literal("heartbeat"),
-  owner: z.string().min(1),
-  capacity: z.object({
-    current_load: z.number(),
-    max_concurrent: z.number(),
-    queue_depth: z.number()
+var HeartbeatMessageSchema = z2.object({
+  type: z2.literal("heartbeat"),
+  owner: z2.string().min(1),
+  capacity: z2.object({
+    current_load: z2.number(),
+    max_concurrent: z2.number(),
+    queue_depth: z2.number()
   }),
-  self_summary: z.object({
-    capabilities: z.array(z.string()),
-    success_rate: z.number(),
-    credit_balance: z.number(),
-    total_completed: z.number(),
-    provider_number: z.number(),
-    reliability: z.object({
-      current_streak: z.number(),
-      repeat_hire_rate: z.number(),
-      avg_feedback: z.number()
+  self_summary: z2.object({
+    capabilities: z2.array(z2.string()),
+    success_rate: z2.number(),
+    credit_balance: z2.number(),
+    total_completed: z2.number(),
+    provider_number: z2.number(),
+    reliability: z2.object({
+      current_streak: z2.number(),
+      repeat_hire_rate: z2.number(),
+      avg_feedback: z2.number()
     })
   })
 });
-var EscrowHoldMessageSchema = z.object({
-  type: z.literal("escrow_hold"),
-  consumer_agent_id: z.string().min(1),
-  provider_agent_id: z.string().min(1),
-  skill_id: z.string().min(1),
-  amount: z.number().positive(),
-  request_id: z.string().uuid(),
-  signature: z.string().optional(),
-  public_key: z.string().optional()
+var EscrowHoldMessageSchema = z2.object({
+  type: z2.literal("escrow_hold"),
+  consumer_agent_id: z2.string().min(1),
+  provider_agent_id: z2.string().min(1),
+  skill_id: z2.string().min(1),
+  amount: z2.number().positive(),
+  request_id: z2.string().uuid(),
+  signature: z2.string().optional(),
+  public_key: z2.string().optional()
 });
-var EscrowHoldConfirmedMessageSchema = z.object({
-  type: z.literal("escrow_hold_confirmed"),
-  request_id: z.string(),
-  escrow_id: z.string(),
-  hold_amount: z.number(),
-  consumer_remaining: z.number()
+var EscrowHoldConfirmedMessageSchema = z2.object({
+  type: z2.literal("escrow_hold_confirmed"),
+  request_id: z2.string(),
+  escrow_id: z2.string(),
+  hold_amount: z2.number(),
+  consumer_remaining: z2.number()
 });
-var EscrowSettleMessageSchema = z.object({
-  type: z.literal("escrow_settle"),
-  escrow_id: z.string().min(1),
-  request_id: z.string().uuid(),
-  success: z.boolean(),
-  failure_reason: z.enum(["bad_execution", "overload", "timeout", "auth_error", "not_found"]).optional(),
-  result_hash: z.string().optional(),
-  signature: z.string().optional(),
-  public_key: z.string().optional(),
-  consumer_agent_id: z.string().optional()
+var EscrowSettleMessageSchema = z2.object({
+  type: z2.literal("escrow_settle"),
+  escrow_id: z2.string().min(1),
+  request_id: z2.string().uuid(),
+  success: z2.boolean(),
+  failure_reason: z2.enum(["bad_execution", "overload", "timeout", "auth_error", "not_found"]).optional(),
+  result_hash: z2.string().optional(),
+  signature: z2.string().optional(),
+  public_key: z2.string().optional(),
+  consumer_agent_id: z2.string().optional()
 });
-var EscrowSettledMessageSchema = z.object({
-  type: z.literal("escrow_settled"),
-  escrow_id: z.string(),
-  request_id: z.string(),
-  provider_earned: z.number(),
-  network_fee: z.number(),
-  consumer_remaining: z.number(),
-  provider_balance: z.number()
+var EscrowSettledMessageSchema = z2.object({
+  type: z2.literal("escrow_settled"),
+  escrow_id: z2.string(),
+  request_id: z2.string(),
+  provider_earned: z2.number(),
+  network_fee: z2.number(),
+  consumer_remaining: z2.number(),
+  provider_balance: z2.number()
 });
-var BalanceSyncMessageSchema = z.object({
-  type: z.literal("balance_sync"),
-  agent_id: z.string().min(1)
+var BalanceSyncMessageSchema = z2.object({
+  type: z2.literal("balance_sync"),
+  agent_id: z2.string().min(1)
 });
-var BalanceSyncResponseMessageSchema = z.object({
-  type: z.literal("balance_sync_response"),
-  agent_id: z.string(),
-  balance: z.number()
+var BalanceSyncResponseMessageSchema = z2.object({
+  type: z2.literal("balance_sync_response"),
+  agent_id: z2.string(),
+  balance: z2.number()
 });
-var RelayMessageSchema = z.discriminatedUnion("type", [
+var RelayMessageSchema = z2.discriminatedUnion("type", [
   RegisterMessageSchema,
   RegisteredMessageSchema,
   RelayRequestMessageSchema,
@@ -175,7 +277,13 @@ var RelayMessageSchema = z.discriminatedUnion("type", [
   EscrowSettleMessageSchema,
   EscrowSettledMessageSchema,
   BalanceSyncMessageSchema,
-  BalanceSyncResponseMessageSchema
+  BalanceSyncResponseMessageSchema,
+  SessionOpenMessageSchema,
+  SessionAckMessageSchema,
+  SessionMessageMessageSchema,
+  SessionEndMessageSchema,
+  SessionSettledMessageSchema,
+  SessionErrorMessageSchema
 ]);
 
 // src/relay/websocket-client.ts
@@ -496,6 +604,11 @@ var RelayClient = class {
 };
 
 export {
+  loadSessionConfig,
+  SessionOpenMessageSchema,
+  SessionMessageMessageSchema,
+  SessionEndMessageSchema,
+  SESSION_MESSAGE_TYPES,
   RelayMessageSchema,
   RelayClient
 };