@slashfi/agents-sdk 0.25.0 → 0.26.0

package/src/registry.ts

@@ -5,7 +5,7 @@
  */
 
 import { dirname, resolve } from "node:path";
-import type { AgentEvent, EventCallback, EventType } from "./events.js";
+import type { AgentEvent, BaseEvent, CustomEventMap, EventCallback, EventType } from "./events.js";
 import { createEventBus } from "./events.js";
 import type { SerializedAgentDefinition } from "./serialized.js";
 import type {
@@ -55,6 +55,7 @@ export interface RegistryMiddleware {
       registry: AgentRegistry;
     },
   ) => Promise<CallAgentLoadResponse>;
+
 }
 
 /**
@@ -97,6 +98,21 @@ export interface AgentRegistry {
 
   /** Emit an event to all listeners. Used by the runtime to push lifecycle events. */
   emit(event: AgentEvent): Promise<void>;
+
+  /**
+   * Trigger a custom event. Only accepts custom event types (not system events
+   * like tool/call, tool/result, etc. which are managed by the runtime).
+   *
+   * @example
+   * ```ts
+   * // After augmenting CustomEventMap:
+   * registry.trigger('callback/resolve', { type: 'callback/resolve', ... });
+   * ```
+   */
+  trigger<T extends Extract<keyof CustomEventMap, string>>(
+    eventType: T,
+    event: CustomEventMap[T] & BaseEvent,
+  ): Promise<void>;
 }
 
 // ============================================
@@ -412,7 +428,7 @@ export function createAgentRegistry(
     };
   }
 
-  const registry: AgentRegistry = {
+  const registryObj: AgentRegistry = {
     register(input: AgentDefinition | SerializedAgentDefinition): void {
       let agent: AgentDefinition;
       if (isSerialized(input)) {
@@ -473,7 +489,42 @@ export function createAgentRegistry(
       await eventBus.emit(event);
     },
 
+    async trigger<T extends Extract<keyof CustomEventMap, string>>(
+      _eventType: T,
+      event: CustomEventMap[T] & BaseEvent,
+    ): Promise<void> {
+      await eventBus.emit(event as never);
+    },
+
     async call(request: CallAgentRequest): Promise<CallAgentResponse> {
+      // Emit call event — listeners can next()/resolve() to control flow
+      let intercepted: CallAgentResponse | undefined;
+      let nextCalled = false;
+      let nextResult: CallAgentResponse | undefined;
+      await eventBus.emit({
+        type: "call",
+        agentPath: request.path,
+        timestamp: Date.now(),
+        request,
+        async next() {
+          nextCalled = true;
+          nextResult = await callInternal(request);
+          return nextResult;
+        },
+        resolve(response: CallAgentResponse) {
+          intercepted = response;
+        },
+      });
+      if (intercepted) return intercepted;
+      if (nextCalled) return nextResult!;
+      // No listener engaged — run default
+      return callInternal(request);
+    },
+  };
+
+  return registryObj;
+
+  async function callInternal(request: CallAgentRequest): Promise<CallAgentResponse> {
       const agent = agents.get(request.path);
 
       if (!agent) {
@@ -673,7 +724,7 @@ export function createAgentRegistry(
             return options.middleware.load(defaultLoad, {
               agent,
               request,
-              registry,
+              registry: registryObj,
             });
           }
           return defaultLoad(agent, request);
@@ -717,8 +768,5 @@ export function createAgentRegistry(
           } as CallAgentErrorResponse;
         }
       }
-    },
-  };
-
-  return registry;
-}
+    }
+  }

package/src/server.ts

@@ -4,7 +4,7 @@
  * Minimal JSON-RPC server implementing the MCP protocol for agent interaction.
  * Handles only core SDK concerns:
  * - MCP protocol (initialize, tools/list, tools/call)
- * - Agent registry routing (call_agent, list_agents)
+ * - Agent registry routing (call_agent, list_agents, search_agent_tools)
  * - Auth resolution (Bearer tokens, root key, JWT)
  * - OAuth2 token exchange (client_credentials)
  * - Health check
@@ -30,6 +30,7 @@ import {
   type SecretStore,
   processSecretParams,
 } from "./agent-definitions/secrets.js";
+import { type BM25Document, createBM25Index } from "./bm25.js";
 import { verifyJwt } from "./jwt.js";
 import type { SigningKey } from "./jwt.js";
 import {
@@ -442,6 +443,32 @@ function getToolDefinitions() {
         properties: {},
       },
     },
+    {
+      name: "search_agent_tools",
+      description:
+        "Search across all registered agent tools using natural language. Returns tools ranked by relevance using BM25 scoring.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description:
+              "Natural language search query (e.g. 'send a message', 'database query')",
+          },
+          agents: {
+            type: "array",
+            items: { type: "string" },
+            description:
+              "Optional list of agent paths to search within (e.g. ['@notifications', '@db']). Searches all agents if omitted.",
+          },
+          limit: {
+            type: "number",
+            description: "Maximum number of results to return (default: 10)",
+          },
+        },
+        required: ["query"],
+      },
+    },
   ];
 }
 
@@ -609,6 +636,104 @@ export function createAgentServer(
         });
       }
 
+      case "search_agent_tools": {
+        const { query, agents: agentFilter, limit: resultLimit } = args as {
+          query: string;
+          agents?: string[];
+          limit?: number;
+        };
+
+        const agents = registry.list();
+        const visible = agents.filter((agent) => {
+          if (!canSeeAgent(agent, auth)) return false;
+          if (agentFilter && agentFilter.length > 0) {
+            return agentFilter.includes(agent.path);
+          }
+          return true;
+        });
+
+        // Build search documents from all visible tools
+        const documents: (BM25Document & {
+          agentPath: string;
+          toolName: string;
+          description: string;
+          agentName?: string;
+          agentDescription?: string;
+        })[] = [];
+
+        for (const agent of visible) {
+          const visibleTools = agent.tools.filter((t) => {
+            const tv = t.visibility ?? "internal";
+            if (auth?.isRoot) return true;
+            if (tv === "public") return true;
+            if (
+              tv === "authenticated" &&
+              auth?.callerId &&
+              auth.callerId !== "anonymous"
+            )
+              return true;
+            if (tv === "internal" && auth) return true;
+            return false;
+          });
+
+          for (const tool of visibleTools) {
+            // Build searchable text from tool name, description, agent context, and schema
+            const parts = [
+              tool.name,
+              tool.description,
+              agent.config?.name ?? "",
+              agent.config?.description ?? "",
+              agent.path,
+            ];
+
+            // Include property names and descriptions from input schema
+            const schema = tool.inputSchema as any;
+            if (schema?.properties) {
+              for (const [key, prop] of Object.entries(schema.properties)) {
+                parts.push(key);
+                if ((prop as any)?.description) {
+                  parts.push((prop as any).description);
+                }
+              }
+            }
+
+            documents.push({
+              id: `${agent.path}/${tool.name}`,
+              text: parts.join(" "),
+              agentPath: agent.path,
+              toolName: tool.name,
+              description: tool.description,
+              agentName: agent.config?.name,
+              agentDescription: agent.config?.description,
+            });
+          }
+        }
+
+        const index = createBM25Index(documents);
+        const results = index.search(query, resultLimit ?? 10);
+
+        // Map results back to tool details
+        const docMap = new Map(documents.map((d) => [d.id, d]));
+        const matches = results.map((r) => {
+          const doc = docMap.get(r.id)!;
+          return {
+            agentPath: doc.agentPath,
+            tool: doc.toolName,
+            description: doc.description,
+            agentName: doc.agentName,
+            agentDescription: doc.agentDescription,
+            score: r.score,
+          };
+        });
+
+        return mcpResult({
+          success: true,
+          query,
+          results: matches,
+          total: matches.length,
+        });
+      }
+
       default:
         throw new Error(`Unknown tool: ${toolName}`);
     }