@lleverage-ai/agent-sdk 0.0.6 → 0.0.7

package/dist/agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../src/agent.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AA2DH,OAAO,KAAK,EACV,KAAK,EACL,YAAY,EAyBb,MAAM,YAAY,CAAC;AA6pBpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,KAAK,CAytFxD"}
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../src/agent.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AA4DH,OAAO,KAAK,EACV,KAAK,EACL,YAAY,EAwBb,MAAM,YAAY,CAAC;AA6pBpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,KAAK,CAmrFxD"}

package/dist/agent.js

@@ -15,9 +15,10 @@ import { MCPManager } from "./mcp/manager.js";
 import { applyMiddleware, mergeHooks, setupMiddleware } from "./middleware/index.js";
 import { createDefaultPromptBuilder } from "./prompt-builder/components.js";
 import { ACCEPT_EDITS_BLOCKED_PATTERNS } from "./security/index.js";
+import { createSubagent } from "./subagents.js";
 import { TaskManager } from "./task-manager.js";
+import { createCallToolTool } from "./tools/call-tool.js";
 import { coreToolsToToolSet, createCoreTools, createSearchToolsTool, createTaskOutputTool, createTaskTool, } from "./tools/factory.js";
-import { createUseToolsTool, ToolRegistry } from "./tools/tool-registry.js";
 let agentIdCounter = 0;
 /**
  * Internal signal for interrupt flow control.
@@ -630,43 +631,7 @@ export function createAgent(options) {
             return `[Background task failed: ${task.id}]\nCommand: ${command}\nError: ${task.error ?? "Unknown error"}`;
         });
     // Determine plugin loading mode
-    // Track whether it was explicitly set to distinguish from default
-    const explicitPluginLoading = options.pluginLoading !== undefined;
     const pluginLoadingMode = options.pluginLoading ?? "eager";
-    const preloadPlugins = new Set(options.preloadPlugins ?? []);
-    // Initialize tool registry for lazy/explicit loading modes
-    const toolRegistry = pluginLoadingMode !== "eager"
-        ? new ToolRegistry({
-            onToolRegistered: async (input) => {
-                const hooks = effectiveHooks?.ToolRegistered ?? [];
-                if (hooks.length === 0)
-                    return;
-                const hookInput = {
-                    hook_event_name: "ToolRegistered",
-                    session_id: "default",
-                    cwd: process.cwd(),
-                    tool_name: input.tool_name,
-                    description: input.description,
-                    source: input.source,
-                };
-                await invokeHooksWithTimeout(hooks, hookInput, null, agent);
-            },
-            onToolLoadError: async (input) => {
-                const hooks = effectiveHooks?.ToolLoadError ?? [];
-                if (hooks.length === 0)
-                    return;
-                const hookInput = {
-                    hook_event_name: "ToolLoadError",
-                    session_id: "default",
-                    cwd: process.cwd(),
-                    tool_name: input.tool_name,
-                    error: input.error,
-                    source: input.source,
-                };
-                await invokeHooksWithTimeout(hooks, hookInput, null, agent);
-            },
-        })
-        : undefined;
     // Collect skills from options and plugins
     const skills = [...(options.skills ?? [])];
     // Initialize MCP manager for unified plugin tool handling
@@ -728,6 +693,10 @@ export function createAgent(options) {
     const toolSearchMaxResults = toolSearchConfig.maxResults ?? 10;
     // Track whether deferred loading is active
     let deferredLoadingActive = false;
+    // Track whether any deferred or proxy plugins exist (for call_tool creation)
+    let hasProxiedTools = false;
+    // Auto-created subagent definitions from delegated plugins
+    const autoSubagents = [];
     // Count total plugin tools for threshold calculation and collect plugin skills.
     // Note: Function-based (streaming) tools are not counted since we don't know
     // their count until they're invoked with a streaming context.
@@ -746,7 +715,7 @@ export function createAgent(options) {
     // Determine if we should use deferred loading based on tool search settings
     // Note: Only activate deferred loading if explicitly requested, not based on auto threshold
     // The auto threshold should only affect whether search_tools is created, not loading behavior
-    if (toolSearchEnabled === "always") {
+    if (toolSearchEnabled === "always" || pluginLoadingMode === "proxy") {
         deferredLoadingActive = true;
     }
     // Removed: auto threshold no longer forces deferred loading
@@ -767,7 +736,7 @@ export function createAgent(options) {
         ...coreToolsToToolSet(autoCreatedCoreTools),
         ...(options.tools ?? {}),
     };
-    // Process plugins based on loading mode and deferred loading
+    // Process plugins based on loading mode, deferred, and delegation settings
     // Note: Plugin skills are collected earlier (before createCoreTools) so
     // the skill tool can include them in progressive disclosure.
     for (const plugin of options.plugins ?? []) {
@@ -775,36 +744,18 @@ export function createAgent(options) {
         // Note: Function-based (streaming) tools are handled separately in
         // getActiveToolSetWithStreaming() and are not registered here
         if (plugin.tools && typeof plugin.tools !== "function") {
-            const shouldPreload = preloadPlugins.has(plugin.name);
-            // Priority order:
-            // 1. Explicit mode - don't register
-            // 2. Preload - always load immediately
-            // 3. Explicit eager - always load immediately
-            // 4. Lazy mode - register with tool registry
-            // 5. Deferred loading - register but don't load
-            // 6. Default eager - load immediately
-            if (pluginLoadingMode === "explicit") {
-                // Explicit mode: don't auto-register, user must do it manually
-                // Skip registration entirely
-            }
-            else if (shouldPreload) {
-                // Preloaded plugins: always load immediately, regardless of other settings
-                mcpManager.registerPluginTools(plugin.name, plugin.tools, {
-                    autoLoad: true,
-                });
-            }
-            else if (explicitPluginLoading && pluginLoadingMode === "eager") {
-                // Explicit eager mode: always load immediately, regardless of toolSearch settings
+            // Check if this plugin is deferred (proxy mode or per-plugin opt-in)
+            const isDeferred = plugin.deferred === true || (pluginLoadingMode === "proxy" && plugin.deferred !== false);
+            if (isDeferred) {
+                // Deferred plugin: register in MCP for discovery via search_tools + call_tool
                 mcpManager.registerPluginTools(plugin.name, plugin.tools, {
-                    autoLoad: true,
+                    autoLoad: false,
                 });
+                hasProxiedTools = true;
             }
-            else if (pluginLoadingMode === "lazy" && toolRegistry) {
-                // Lazy mode: register with registry for on-demand loading
-                toolRegistry.registerPlugin(plugin.name, plugin.tools);
-            }
-            else if (deferredLoadingActive) {
+            else if (deferredLoadingActive && plugin.deferred !== false) {
                 // Deferred loading (auto threshold or always enabled): register tools but don't load them initially
+                // Respect explicit deferred: false opt-out
                 mcpManager.registerPluginTools(plugin.name, plugin.tools, {
                     autoLoad: false,
                 });
@@ -817,33 +768,61 @@ export function createAgent(options) {
             }
         }
     }
+    // Create subagent definitions from plugins with subagent config
+    for (const plugin of options.plugins ?? []) {
+        if (plugin.subagent) {
+            autoSubagents.push({
+                type: `plugin-${plugin.name}`,
+                description: plugin.subagent.description,
+                model: plugin.subagent.model ?? "inherit",
+                create: (_ctx) => createSubagent(agent, {
+                    name: `plugin-${plugin.name}`,
+                    description: plugin.subagent.description,
+                    model: _ctx.model,
+                    tools: plugin.subagent.tools,
+                    systemPrompt: plugin.subagent.prompt ??
+                        `You are a ${plugin.name} specialist. Complete the requested task using available tools and return a clear summary.`,
+                }),
+            });
+        }
+    }
+    // Merge auto-created subagents with user-provided ones
+    const allSubagents = [...(options.subagents ?? []), ...autoSubagents];
+    const hasSubagents = allSubagents.length > 0;
+    // In proxy mode, create call_tool and configure search_tools with schema disclosure
+    const isProxyMode = pluginLoadingMode === "proxy" || hasProxiedTools;
+    if (isProxyMode && !options.disabledCoreTools?.includes("call_tool")) {
+        coreTools.call_tool = createCallToolTool({
+            mcpManager,
+        });
+    }
     // Create search_tools for MCP tool discovery and/or plugin loading
     // New behavior:
     // - Create when auto threshold is exceeded (for lazy discovery)
     // - Create when deferred loading is active (explicitly requested)
+    // - Create when proxy mode is active (for call_tool discovery)
     // - Create when external MCP servers exist (for MCP tool search)
-    // - Always auto-load tools when found (no manual load step)
+    // - Always auto-load tools when found (no manual load step) — unless proxy mode
     const shouldCreateSearchToolsForAutoThreshold = toolSearchEnabled === "auto" && totalPluginToolCount > toolSearchThreshold;
     const shouldCreateSearchTools = !options.disabledCoreTools?.includes("search_tools") &&
         (deferredLoadingActive ||
+            isProxyMode ||
             shouldCreateSearchToolsForAutoThreshold ||
             (mcpManager.hasExternalServers() && toolSearchEnabled !== "never"));
     if (shouldCreateSearchTools) {
         coreTools.search_tools = createSearchToolsTool({
             manager: mcpManager,
             maxResults: toolSearchMaxResults,
-            enableLoad: true, // Always enable auto-loading
-            autoLoad: true, // NEW: Auto-load tools after searching
+            // In proxy mode: don't auto-load, include schema for call_tool usage
+            enableLoad: !isProxyMode,
+            autoLoad: !isProxyMode,
+            includeSchema: isProxyMode,
             onToolsLoaded: (toolNames) => {
                 // Tools are now loaded in MCPManager and will be included in getActiveToolSet()
                 // This callback can be used for logging/notifications
             },
         });
     }
-    // Add use_tools meta-tool in lazy mode
-    if (pluginLoadingMode === "lazy" && toolRegistry) {
-        coreTools.use_tools = createUseToolsTool({ registry: toolRegistry });
-    }
     /**
      * Filter a tool set by the allowedTools and disallowedTools restrictions.
      * If neither is set, returns all tools.
@@ -887,9 +866,6 @@ export function createAgent(options) {
             const allTools = { ...coreTools };
             Object.assign(allTools, runtimeTools);
             Object.assign(allTools, mcpManager.getToolSet());
-            if (toolRegistry) {
-                Object.assign(allTools, toolRegistry.getLoadedTools());
-            }
             return allTools;
         })());
         // Extract tool metadata for context
@@ -926,6 +902,10 @@ export function createAgent(options) {
             permissionMode,
             currentMessages: messages,
             threadId,
+            custom: {
+                hasSubagents,
+                delegationInstructions: options.delegationInstructions,
+            },
         };
     };
     // Helper to get system prompt (either static or built from context)
@@ -947,10 +927,6 @@ export function createAgent(options) {
         // Add MCP tools from plugin registrations
         const mcpTools = mcpManager.getToolSet();
         Object.assign(allTools, mcpTools);
-        // Add dynamically loaded tools from registry (lazy mode)
-        if (toolRegistry) {
-            Object.assign(allTools, toolRegistry.getLoadedTools());
-        }
         // Apply allowedTools filtering
         const filtered = filterToolsByAllowed(allTools);
         // Apply permission mode wrapping with canUseTool callback and approval state
@@ -991,10 +967,6 @@ export function createAgent(options) {
         // Add MCP tools from plugin registrations
         const mcpTools = mcpManager.getToolSet();
         Object.assign(allTools, mcpTools);
-        // Add dynamically loaded tools from registry (lazy mode)
-        if (toolRegistry) {
-            Object.assign(allTools, toolRegistry.getLoadedTools());
-        }
         // Apply allowedTools filtering
         const filtered = filterToolsByAllowed(allTools);
         // Apply permission mode wrapping with canUseTool callback and approval state
@@ -1047,7 +1019,7 @@ export function createAgent(options) {
         const result = {
             ...tools,
             task: createTaskTool({
-                subagents: options.subagents ?? [],
+                subagents: allSubagents,
                 defaultModel: options.model,
                 parentAgent: agent,
                 // Always include general-purpose subagent so agents can delegate tasks
@@ -2526,17 +2498,6 @@ export function createAgent(options) {
                 delete runtimeTools[name];
             }
         },
-        loadTools(toolNames) {
-            if (!toolRegistry) {
-                // No registry in eager mode - all tools already loaded
-                return { loaded: [], notFound: toolNames };
-            }
-            const result = toolRegistry.load(toolNames);
-            return {
-                loaded: result.loaded,
-                notFound: result.notFound,
-            };
-        },
         setPermissionMode(mode) {
             permissionMode = mode;
         },