agentbnb 9.0.3 → 9.1.0

package/dist/session-5AIRM7YF.js

@@ -0,0 +1,144 @@
+import "./chunk-3RG5ZIWI.js";
+
+// src/mcp/tools/session.ts
+import { z } from "zod";
+var sessionOpenInputSchema = {
+  provider_id: z.string().describe("Provider agent ID or owner to connect to"),
+  card_id: z.string().describe("Capability card ID of the provider"),
+  skill_id: z.string().describe("Skill ID to use for the session"),
+  budget: z.number().positive().describe("Maximum credits for this session"),
+  message: z.string().describe("Initial message to send to the provider"),
+  pricing_model: z.enum(["per_message", "per_minute", "per_session"]).optional().describe("Pricing model (default: per_message)")
+};
+async function handleSessionOpen(args, ctx) {
+  if (!ctx.relayClient) {
+    return { content: [{ type: "text", text: JSON.stringify({ error: "Not connected to relay. Run agentbnb serve first." }) }] };
+  }
+  try {
+    const sessionId = crypto.randomUUID();
+    const ws = ctx.relayClient.ws;
+    if (!ws) {
+      return { content: [{ type: "text", text: JSON.stringify({ error: "WebSocket not available on relay client." }) }] };
+    }
+    ws.send(JSON.stringify({
+      type: "session_open",
+      session_id: sessionId,
+      requester_id: ctx.identity.agent_id ?? ctx.identity.owner,
+      provider_id: args.provider_id,
+      card_id: args.card_id,
+      skill_id: args.skill_id,
+      budget: args.budget,
+      pricing_model: args.pricing_model ?? "per_message",
+      initial_message: args.message
+    }));
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          session_id: sessionId,
+          status: "opening",
+          provider_id: args.provider_id,
+          skill_id: args.skill_id,
+          budget: args.budget,
+          message: "Session open request sent. Listen for session_ack and session_message responses."
+        })
+      }]
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { content: [{ type: "text", text: JSON.stringify({ error: message }) }] };
+  }
+}
+function registerSessionOpenTool(server, ctx) {
+  server.registerTool("agentbnb_session_open", {
+    description: "Open an interactive session with a provider agent for multi-turn conversation. Returns a session_id to use with session_send and session_end.",
+    inputSchema: sessionOpenInputSchema
+  }, async (args) => handleSessionOpen(args, ctx));
+}
+var sessionSendInputSchema = {
+  session_id: z.string().describe("Session ID from session_open"),
+  message: z.string().describe("Message to send to the provider")
+};
+async function handleSessionSend(args, ctx) {
+  if (!ctx.relayClient) {
+    return { content: [{ type: "text", text: JSON.stringify({ error: "Not connected to relay." }) }] };
+  }
+  try {
+    const ws = ctx.relayClient.ws;
+    if (!ws) {
+      return { content: [{ type: "text", text: JSON.stringify({ error: "WebSocket not available." }) }] };
+    }
+    ws.send(JSON.stringify({
+      type: "session_message",
+      session_id: args.session_id,
+      sender: "requester",
+      content: args.message
+    }));
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          session_id: args.session_id,
+          status: "sent",
+          message: "Message sent. Listen for session_message response from provider."
+        })
+      }]
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { content: [{ type: "text", text: JSON.stringify({ error: message }) }] };
+  }
+}
+function registerSessionSendTool(server, ctx) {
+  server.registerTool("agentbnb_session_send", {
+    description: "Send a message within an active session. The provider will respond asynchronously.",
+    inputSchema: sessionSendInputSchema
+  }, async (args) => handleSessionSend(args, ctx));
+}
+var sessionEndInputSchema = {
+  session_id: z.string().describe("Session ID to end"),
+  reason: z.enum(["completed", "cancelled"]).optional().describe("Reason for ending (default: completed)")
+};
+async function handleSessionEnd(args, ctx) {
+  if (!ctx.relayClient) {
+    return { content: [{ type: "text", text: JSON.stringify({ error: "Not connected to relay." }) }] };
+  }
+  try {
+    const ws = ctx.relayClient.ws;
+    if (!ws) {
+      return { content: [{ type: "text", text: JSON.stringify({ error: "WebSocket not available." }) }] };
+    }
+    ws.send(JSON.stringify({
+      type: "session_end",
+      session_id: args.session_id,
+      reason: args.reason ?? "completed"
+    }));
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          session_id: args.session_id,
+          status: "ending",
+          message: "Session end request sent. Listen for session_settled response."
+        })
+      }]
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { content: [{ type: "text", text: JSON.stringify({ error: message }) }] };
+  }
+}
+function registerSessionEndTool(server, ctx) {
+  server.registerTool("agentbnb_session_end", {
+    description: "End an active session. Credits will be settled and any unused budget refunded.",
+    inputSchema: sessionEndInputSchema
+  }, async (args) => handleSessionEnd(args, ctx));
+}
+export {
+  handleSessionEnd,
+  handleSessionOpen,
+  handleSessionSend,
+  registerSessionEndTool,
+  registerSessionOpenTool,
+  registerSessionSendTool
+};

package/dist/session-action-67J57636.js

@@ -0,0 +1,131 @@
+import {
+  ensureIdentity
+} from "./chunk-5CC6O6SO.js";
+import "./chunk-YNBZLXYS.js";
+import {
+  getConfigDir,
+  loadConfig
+} from "./chunk-3XPBFF6H.js";
+import "./chunk-UVCNMRPS.js";
+import "./chunk-3RG5ZIWI.js";
+
+// src/cli/session-action.ts
+import { randomUUID } from "crypto";
+import { createInterface } from "readline";
+async function sessionOpen(cardId, opts) {
+  const config = loadConfig();
+  if (!config || !config.registry) {
+    console.error("Error: No registry configured. Run `agentbnb init` first.");
+    process.exit(1);
+  }
+  const configDir = getConfigDir();
+  const identity = ensureIdentity(configDir, config.owner);
+  const agentId = identity.agent_id ?? identity.owner;
+  const relayUrl = config.registry.replace(/^http/, "ws") + "/ws";
+  const WebSocket = (await import("ws")).default;
+  const ws = new WebSocket(relayUrl);
+  await new Promise((resolve, reject) => {
+    ws.on("open", () => {
+      ws.send(JSON.stringify({
+        type: "register",
+        owner: identity.owner,
+        agent_id: agentId,
+        token: config.token ?? "session-client",
+        card: { id: `session-client-${randomUUID()}`, owner: identity.owner, name: "session-client" }
+      }));
+      resolve();
+    });
+    ws.on("error", reject);
+  });
+  const sessionId = randomUUID();
+  ws.send(JSON.stringify({
+    type: "session_open",
+    session_id: sessionId,
+    requester_id: agentId,
+    provider_id: opts.skill,
+    // Provider resolved via card
+    card_id: cardId,
+    skill_id: opts.skill,
+    budget: opts.budget,
+    pricing_model: opts.pricing,
+    initial_message: opts.message
+  }));
+  console.log(`Session opened: ${sessionId}`);
+  console.log(`Skill: ${opts.skill} | Budget: ${opts.budget} credits | Pricing: ${opts.pricing}`);
+  console.log("---");
+  console.log(`You: ${opts.message}`);
+  let totalSpent = 0;
+  ws.on("message", (data) => {
+    try {
+      const msg = JSON.parse(data.toString());
+      if (msg.session_id !== sessionId) return;
+      switch (msg.type) {
+        case "session_message":
+          if (msg.sender === "provider") {
+            console.log(`Agent: ${msg.content}`);
+            totalSpent += 2;
+            console.log(`  [~${totalSpent}/${opts.budget} cr]`);
+          }
+          break;
+        case "session_settled":
+          console.log(`
+Session ended. Total: ${msg.total_cost} credits (${msg.messages_count} messages)`);
+          console.log(`Refunded: ${msg.refunded} credits`);
+          ws.close();
+          break;
+        case "session_error":
+          console.error(`Session error: [${msg.code}] ${msg.message}`);
+          ws.close();
+          break;
+        case "session_ack":
+          break;
+      }
+    } catch {
+    }
+  });
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const prompt = () => {
+    rl.question("You: ", (input) => {
+      if (!input || input === "/end" || input === "/quit") {
+        ws.send(JSON.stringify({
+          type: "session_end",
+          session_id: sessionId,
+          reason: "completed"
+        }));
+        rl.close();
+        return;
+      }
+      ws.send(JSON.stringify({
+        type: "session_message",
+        session_id: sessionId,
+        sender: "requester",
+        content: input
+      }));
+      setTimeout(prompt, 100);
+    });
+  };
+  setTimeout(prompt, 2e3);
+}
+async function sessionSend(sessionId, message) {
+  console.log(`Sending to session ${sessionId}: ${message}`);
+  console.log("Note: For interactive sessions, use `agentbnb session open` instead.");
+  console.log("Non-interactive send requires a running relay connection.");
+}
+async function sessionEnd(sessionId, reason) {
+  console.log(`Ending session ${sessionId} (reason: ${reason})`);
+  console.log("Note: Use /end within an interactive session, or send session_end via relay.");
+}
+async function sessionList() {
+  console.log("Active sessions are tracked on the relay server.");
+  console.log("Use the MCP tool agentbnb_session_open to manage sessions programmatically.");
+}
+async function sessionStatus(sessionId) {
+  console.log(`Session ${sessionId} status is tracked on the relay server.`);
+}
+export {
+  sessionEnd,
+  sessionList,
+  sessionOpen,
+  sessionSend,
+  sessionStatus
+};

package/dist/{skill-config-5O2VR546.js → skill-config-VYNF7BCY.js}

@@ -9,6 +9,7 @@ import {
   expandEnvVars,
   parseSkillsFile
 } from "./chunk-WX3GZVFG.js";
+import "./chunk-3RG5ZIWI.js";
 export {
   ApiSkillConfigSchema,
   CommandSkillConfigSchema,

package/dist/{skill-wrap-YLCJMFEJ.js → skill-wrap-IAZHOYM4.js}

@@ -1,6 +1,7 @@
 import {
   getConfigDir
 } from "./chunk-3XPBFF6H.js";
+import "./chunk-3RG5ZIWI.js";
 
 // src/cli/skill-wrap.ts
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";