@nuvin/nuvin-core 0.1.0 → 1.0.0

package/dist/VERSION

@@ -1,4 +1,4 @@
 {
-  "version": "0.1.0",
-  "commit": "699bbe3"
+  "version": "1.0.0",
+  "commit": "63191c8"
 }

package/dist/index.d.ts

@@ -12,7 +12,6 @@ type AgentTemplate = {
     tools?: string[];
     provider?: string;
     model?: string;
-    apiKey?: string;
     temperature?: number;
     maxTokens?: number;
     topP?: number;
@@ -331,6 +330,13 @@ interface LLMPort {
         onStreamFinish?: (finishReason?: string, usage?: UsageData) => void;
     }, signal?: AbortSignal): Promise<CompletionResult>;
 }
+type LLMConfig = {
+    provider?: string;
+    model?: string;
+};
+interface LLMFactory {
+    createLLM(config: LLMConfig): LLMPort;
+}
 type ToolDefinition = {
     type: 'function';
     function: {
@@ -356,9 +362,13 @@ type ToolExecutionResult = {
 interface ToolPort {
     getToolDefinitions(enabledTools: string[]): ToolDefinition[];
     executeToolCalls(calls: ToolInvocation[], context?: Record<string, unknown>, maxConcurrent?: number, signal?: AbortSignal): Promise<ToolExecutionResult[]>;
-    setEnabledAgents?(enabledAgents: Record<string, boolean>): void;
-    getAgentRegistry?(): AgentRegistry | undefined;
-    setOrchestrator?(config: AgentConfig, llm: LLMPort, tools: ToolPort): void;
+}
+interface AgentAwareToolPort {
+    setEnabledAgents(enabledAgents: Record<string, boolean>): void;
+    getAgentRegistry(): AgentRegistry | undefined;
+}
+interface OrchestratorAwareToolPort {
+    setOrchestrator(config: AgentConfig, tools: ToolPort, llmFactory?: LLMFactory, configResolver?: () => Partial<AgentConfig>): void;
 }
 type MemorySnapshot<T = unknown> = Record<string, T[]>;
 interface MemoryPersistence<T = unknown> {
@@ -810,45 +820,6 @@ type TodoItem = {
     updatedAt?: string;
 };
 
-declare class ToolRegistry implements ToolPort {
-    private tools;
-    private toolsMemory?;
-    private agentRegistry;
-    private assignTool?;
-    private enabledAgentsConfig;
-    constructor(opts?: {
-        todoMemory?: MemoryPort<TodoItem>;
-        toolsMemory?: MemoryPort<string>;
-        agentRegistry?: AgentRegistry;
-    });
-    private persistToolNames;
-    listRegisteredTools(): Promise<string[]>;
-    getToolDefinitions(enabledTools: string[]): ToolDefinition[];
-    /**
-     * Initialize AssignTool with orchestrator dependencies (lazy initialization)
-     */
-    setOrchestrator(config: AgentConfig, llm: LLMPort, tools: ToolPort): void;
-    /**
-     * Get the agent registry
-     */
-    getAgentRegistry(): AgentRegistry;
-    /**
-     * Update the enabled agents configuration for AssignTool
-     */
-    setEnabledAgents(enabledAgents: Record<string, boolean>): void;
-    executeToolCalls(calls: ToolInvocation[], context?: Record<string, unknown>, maxConcurrent?: number, signal?: AbortSignal): Promise<ToolExecutionResult[]>;
-}
-
-declare class CompositeToolPort implements ToolPort {
-    private ports;
-    constructor(ports: ToolPort[]);
-    getToolDefinitions(enabledTools: string[]): ToolDefinition[];
-    executeToolCalls(calls: ToolInvocation[], context?: Record<string, unknown>, maxConcurrent?: number, signal?: AbortSignal): Promise<ToolExecutionResult[]>;
-    setEnabledAgents(enabledAgents: Record<string, boolean>): void;
-    getAgentRegistry(): AgentRegistry | undefined;
-    listRegisteredTools(): Promise<string[]>;
-}
-
 type ExecResult = Omit<ToolExecutionResult, 'id' | 'name'>;
 type ToolExecutionContext = {
     conversationId?: string;
@@ -867,81 +838,6 @@ interface FunctionTool<P = Record<string, unknown>, C = ToolExecutionContext> {
     execute(params: P, context?: C): Promise<ExecResult> | ExecResult;
 }
 
-type BashParams = {
-    cmd: string;
-    cwd?: string;
-    timeoutMs?: number;
-};
-declare class BashTool implements FunctionTool<BashParams, ToolExecutionContext> {
-    name: "bash_tool";
-    parameters: {
-        readonly type: "object";
-        readonly properties: {
-            readonly description: {
-                readonly type: "string";
-                readonly description: "Explanation of what this command will do (e.g., \"Get git commit log\")";
-            };
-            readonly cmd: {
-                readonly type: "string";
-                readonly description: "Shell command to run.";
-            };
-            readonly cwd: {
-                readonly type: "string";
-                readonly description: "Working directory.";
-            };
-            readonly timeoutMs: {
-                readonly type: "integer";
-                readonly minimum: 1;
-                readonly description: "Timeout in ms. Default: 30000.";
-            };
-        };
-        readonly required: readonly ["cmd"];
-    };
-    definition(): ToolDefinition['function'];
-    execute(p: BashParams, ctx?: ToolExecutionContext): Promise<ExecResult>;
-    private execOnce;
-    private defaultShell;
-    private shellExists;
-    private shellArgs;
-}
-
-/**
- * AgentManager - coordinates specialist agent execution for task delegation
- */
-declare class AgentManager {
-    private delegatingConfig;
-    private delegatingLLM;
-    private delegatingTools;
-    private eventCallback?;
-    private activeAgents;
-    private eventCollectors;
-    constructor(delegatingConfig: AgentConfig, delegatingLLM: LLMPort, delegatingTools: ToolPort, eventCallback?: (event: AgentEvent) => void);
-    /**
-     * Create and execute a specialist agent for a specific task
-     */
-    executeTask(config: SpecialistAgentConfig, signal?: AbortSignal): Promise<SpecialistAgentResult>;
-    /**
-     * Resolve which LLM to use (reuse delegating LLM or create new one)
-     */
-    private resolveLLM;
-    /**
-     * Execute agent task with timeout
-     */
-    private executeWithTimeout;
-    /**
-     * Get active specialist agent count
-     */
-    getActiveAgentCount(): number;
-    /**
-     * Get events for a specific specialist agent
-     */
-    getAgentEvents(agentId: string): AgentEvent[] | undefined;
-    /**
-     * Cleanup all active agents (emergency stop)
-     */
-    cleanup(): void;
-}
-
 interface AgentCatalog {
     list(): AgentTemplate[];
     get(agentId: string): AgentTemplate | undefined;
@@ -1019,11 +915,51 @@ declare class DefaultSpecialistAgentFactory implements SpecialistAgentFactory {
     create(input: SpecialistAgentFactoryInput): SpecialistAgentConfig;
 }
 
+/**
+ * AgentManager - coordinates specialist agent execution for task delegation
+ */
+declare class AgentManager {
+    private delegatingConfig;
+    private delegatingTools;
+    private llmFactory?;
+    private eventCallback?;
+    private configResolver?;
+    private llmResolver;
+    private activeAgents;
+    private eventCollectors;
+    constructor(delegatingConfig: AgentConfig, delegatingTools: ToolPort, llmFactory?: LLMFactory, eventCallback?: (event: AgentEvent) => void, configResolver?: () => Partial<AgentConfig>);
+    /**
+     * Create and execute a specialist agent for a specific task
+     */
+    executeTask(config: SpecialistAgentConfig, signal?: AbortSignal): Promise<SpecialistAgentResult>;
+    /**
+     * Resolve which LLM to use - creates fresh LLM instance via factory
+     */
+    private resolveLLM;
+    /**
+     * Execute agent task with timeout
+     */
+    private executeWithTimeout;
+    /**
+     * Get active specialist agent count
+     */
+    getActiveAgentCount(): number;
+    /**
+     * Get events for a specific specialist agent
+     */
+    getAgentEvents(agentId: string): AgentEvent[] | undefined;
+    /**
+     * Cleanup all active agents (emergency stop)
+     */
+    cleanup(): void;
+}
+
 declare class AgentManagerCommandRunner implements AgentCommandRunner {
     private readonly delegatingConfig;
-    private readonly delegatingLLM;
     private readonly delegatingTools;
-    constructor(delegatingConfig: AgentConfig, delegatingLLM: LLMPort, delegatingTools: ToolPort);
+    private readonly llmFactory?;
+    private readonly configResolver?;
+    constructor(delegatingConfig: AgentConfig, delegatingTools: ToolPort, llmFactory?: LLMFactory, configResolver?: () => Partial<AgentConfig>);
     run(config: Parameters<AgentManager['executeTask']>[0], context?: ToolExecutionContext): Promise<SpecialistAgentResult>;
 }
 
@@ -1054,6 +990,104 @@ declare class DefaultDelegationResultFormatter implements DelegationResultFormat
     formatError(error: unknown): string;
 }
 
+interface DelegationServiceConfig {
+    agentRegistry: AgentCatalog;
+    commandRunner: AgentCommandRunner;
+    agentListProvider?: () => Array<{
+        id: string;
+        name: string;
+        description: string;
+    }>;
+}
+declare class DelegationServiceFactory {
+    create(config: DelegationServiceConfig): DelegationService;
+}
+
+declare class LLMResolver {
+    private factory;
+    constructor(factory: LLMFactory);
+    resolve(config: SpecialistAgentConfig): LLMPort;
+}
+
+declare class ToolRegistry implements ToolPort, AgentAwareToolPort, OrchestratorAwareToolPort {
+    private tools;
+    private toolsMemory?;
+    private agentRegistry;
+    private delegationServiceFactory?;
+    private assignTool?;
+    private enabledAgentsConfig;
+    constructor(opts?: {
+        todoMemory?: MemoryPort<TodoItem>;
+        toolsMemory?: MemoryPort<string>;
+        agentRegistry?: AgentRegistry;
+        delegationServiceFactory?: DelegationServiceFactory;
+    });
+    private persistToolNames;
+    listRegisteredTools(): Promise<string[]>;
+    getToolDefinitions(enabledTools: string[]): ToolDefinition[];
+    /**
+     * Initialize AssignTool with orchestrator dependencies (lazy initialization)
+     */
+    setOrchestrator(config: AgentConfig, tools: ToolPort, llmFactory?: LLMFactory, configResolver?: () => Partial<AgentConfig>): void;
+    /**
+     * Get the agent registry
+     */
+    getAgentRegistry(): AgentRegistry;
+    /**
+     * Update the enabled agents configuration for AssignTool
+     */
+    setEnabledAgents(enabledAgents: Record<string, boolean>): void;
+    executeToolCalls(calls: ToolInvocation[], context?: Record<string, unknown>, maxConcurrent?: number, signal?: AbortSignal): Promise<ToolExecutionResult[]>;
+}
+
+declare class CompositeToolPort implements ToolPort {
+    private ports;
+    constructor(ports: ToolPort[]);
+    getToolDefinitions(enabledTools: string[]): ToolDefinition[];
+    executeToolCalls(calls: ToolInvocation[], context?: Record<string, unknown>, maxConcurrent?: number, signal?: AbortSignal): Promise<ToolExecutionResult[]>;
+    setEnabledAgents(enabledAgents: Record<string, boolean>): void;
+    getAgentRegistry(): AgentRegistry | undefined;
+    listRegisteredTools(): Promise<string[]>;
+}
+
+type BashParams = {
+    cmd: string;
+    cwd?: string;
+    timeoutMs?: number;
+};
+declare class BashTool implements FunctionTool<BashParams, ToolExecutionContext> {
+    name: "bash_tool";
+    parameters: {
+        readonly type: "object";
+        readonly properties: {
+            readonly description: {
+                readonly type: "string";
+                readonly description: "Explanation of what this command will do (e.g., \"Get git commit log\")";
+            };
+            readonly cmd: {
+                readonly type: "string";
+                readonly description: "Shell command to run.";
+            };
+            readonly cwd: {
+                readonly type: "string";
+                readonly description: "Working directory.";
+            };
+            readonly timeoutMs: {
+                readonly type: "integer";
+                readonly minimum: 1;
+                readonly description: "Timeout in ms. Default: 30000.";
+            };
+        };
+        readonly required: readonly ["cmd"];
+    };
+    definition(): ToolDefinition['function'];
+    execute(p: BashParams, ctx?: ToolExecutionContext): Promise<ExecResult>;
+    private execOnce;
+    private defaultShell;
+    private shellExists;
+    private shellArgs;
+}
+
 declare class EchoLLM implements LLMPort {
     generateCompletion(params: CompletionParams): Promise<CompletionResult>;
     private hasTool;
@@ -1449,4 +1483,4 @@ declare function resolveBackspaces(s: string): string;
 declare function stripAnsiAndControls(s: string): string;
 declare function canonicalizeTerminalPaste(raw: string): string;
 
-export { AGENT_CREATOR_SYSTEM_PROMPT, type AgentCatalog, type AgentConfig, type AgentEvent, AgentEventTypes, AgentFilePersistence, AgentManager, AgentManagerCommandRunner, AgentOrchestrator, AgentRegistry, type AgentTemplate, AnthropicAISDKLLM, AnthropicLLM, type AssignParams, BashTool, CompositeToolPort, type Conversation, ConversationContext, type ConversationMetadata, type ConversationSnapshot, ConversationStore, CoreMCPClient, DeepInfraLLM, type DeepInfraModel, DefaultDelegationPolicy, DefaultDelegationResultFormatter, DefaultDelegationService, DefaultSpecialistAgentFactory, type DelegationService, EchoLLM, type FolderTreeOptions, GithubLLM, InMemoryMemory, InMemoryMetadata, JsonFileMemoryPersistence, LLMError, type LLMPort, type MCPConfig, type MCPServerConfig, MCPToolPort, type MemoryPort, MemoryPortMetadataAdapter, type Message, type MessageContent, type MessageContentPart, type MetadataPort, NoopReminders, OpenRouterLLM, type OpenRouterModel, PersistedMemory, PersistingConsoleEventPort, RuntimeEnv, type SendMessageOptions, SimpleContextBuilder, SimpleCost, SimpleId, type SpecialistAgentConfig, type SpecialistAgentResult, SystemClock, type ToolApprovalDecision, type ToolCall, type ToolExecutionResult, type ToolPort, ToolRegistry, type UserAttachment, type UserMessagePayload, ZaiLLM, buildAgentCreationPrompt, buildInjectedSystem, canonicalizeTerminalPaste, generateFolderTree, loadMCPConfig, normalizeNewlines, renderTemplate, resolveBackspaces, resolveCarriageReturns, stripAnsiAndControls };
+export { AGENT_CREATOR_SYSTEM_PROMPT, type AgentAwareToolPort, type AgentCatalog, type AgentConfig, type AgentEvent, AgentEventTypes, AgentFilePersistence, AgentManager, AgentManagerCommandRunner, AgentOrchestrator, AgentRegistry, type AgentTemplate, AnthropicAISDKLLM, AnthropicLLM, type AssignParams, BashTool, CompositeToolPort, type Conversation, ConversationContext, type ConversationMetadata, type ConversationSnapshot, ConversationStore, CoreMCPClient, DeepInfraLLM, type DeepInfraModel, DefaultDelegationPolicy, DefaultDelegationResultFormatter, DefaultDelegationService, DefaultSpecialistAgentFactory, type DelegationService, type DelegationServiceConfig, DelegationServiceFactory, EchoLLM, type FolderTreeOptions, GithubLLM, InMemoryMemory, InMemoryMetadata, JsonFileMemoryPersistence, type LLMConfig, LLMError, type LLMFactory, type LLMPort, LLMResolver, type MCPConfig, type MCPServerConfig, MCPToolPort, type MemoryPort, MemoryPortMetadataAdapter, type Message, type MessageContent, type MessageContentPart, type MetadataPort, NoopReminders, OpenRouterLLM, type OpenRouterModel, type OrchestratorAwareToolPort, PersistedMemory, PersistingConsoleEventPort, RuntimeEnv, type SendMessageOptions, SimpleContextBuilder, SimpleCost, SimpleId, type SpecialistAgentConfig, type SpecialistAgentResult, SystemClock, type ToolApprovalDecision, type ToolCall, type ToolExecutionResult, type ToolPort, ToolRegistry, type UserAttachment, type UserMessagePayload, ZaiLLM, buildAgentCreationPrompt, buildInjectedSystem, canonicalizeTerminalPaste, generateFolderTree, loadMCPConfig, normalizeNewlines, renderTemplate, resolveBackspaces, resolveCarriageReturns, stripAnsiAndControls };

package/dist/index.js

@@ -2620,7 +2620,6 @@ var AgentRegistry = class {
       maxTokens: partial.maxTokens ?? 4e3,
       provider: partial.provider,
       model: partial.model,
-      apiKey: partial.apiKey,
       topP: partial.topP,
       timeoutMs: partial.timeoutMs,
       shareContext: partial.shareContext,
@@ -2911,16 +2910,34 @@ var DefaultSpecialistAgentFactory = class {
   }
 };
 
+// delegation/LLMResolver.ts
+var LLMResolver = class {
+  constructor(factory) {
+    this.factory = factory;
+  }
+  resolve(config) {
+    return this.factory.createLLM({
+      provider: config.provider,
+      model: config.model
+    });
+  }
+};
+
 // agent-manager.ts
 var DEFAULT_TIMEOUT_MS = 3e5;
 var MAX_DELEGATION_DEPTH = 3;
 var AgentManager = class {
-  constructor(delegatingConfig, delegatingLLM, delegatingTools, eventCallback) {
+  constructor(delegatingConfig, delegatingTools, llmFactory, eventCallback, configResolver) {
     this.delegatingConfig = delegatingConfig;
-    this.delegatingLLM = delegatingLLM;
     this.delegatingTools = delegatingTools;
+    this.llmFactory = llmFactory;
     this.eventCallback = eventCallback;
+    this.configResolver = configResolver;
+    if (llmFactory) {
+      this.llmResolver = new LLMResolver(llmFactory);
+    }
   }
+  llmResolver = null;
   activeAgents = /* @__PURE__ */ new Map();
   eventCollectors = /* @__PURE__ */ new Map();
   /**
@@ -2997,18 +3014,19 @@ var AgentManager = class {
         }
       }
     };
+    const freshConfig = this.configResolver?.() ?? {};
     const specialistConfig = {
       id: agentId,
       systemPrompt: config.systemPrompt,
       temperature: config.temperature ?? this.delegatingConfig.temperature,
       topP: config.topP ?? this.delegatingConfig.topP,
-      model: config.model ?? this.delegatingConfig.model,
+      model: config.model ?? freshConfig.model ?? this.delegatingConfig.model,
       maxTokens: config.maxTokens ?? this.delegatingConfig.maxTokens,
       enabledTools: config.tools,
       maxToolConcurrency: this.delegatingConfig.maxToolConcurrency,
       requireToolApproval: false,
       // Specialists run autonomously
-      reasoningEffort: this.delegatingConfig.reasoningEffort
+      reasoningEffort: freshConfig.reasoningEffort ?? this.delegatingConfig.reasoningEffort
     };
     const llm = this.resolveLLM(config);
     const specialistOrchestrator = new AgentOrchestrator(specialistConfig, {
@@ -3090,13 +3108,13 @@ var AgentManager = class {
     }
   }
   /**
-   * Resolve which LLM to use (reuse delegating LLM or create new one)
+   * Resolve which LLM to use - creates fresh LLM instance via factory
    */
   resolveLLM(config) {
-    if (!config.provider && !config.model) {
-      return this.delegatingLLM;
+    if (!this.llmResolver) {
+      throw new Error("AgentManager requires LLMFactory to create sub-agents. Please provide llmFactory in constructor.");
     }
-    return this.delegatingLLM;
+    return this.llmResolver.resolve(config);
   }
   /**
    * Execute agent task with timeout
@@ -3145,19 +3163,21 @@ var AgentManager = class {
 
 // delegation/AgentManagerCommandRunner.ts
 var AgentManagerCommandRunner = class {
-  constructor(delegatingConfig, delegatingLLM, delegatingTools) {
+  constructor(delegatingConfig, delegatingTools, llmFactory, configResolver) {
     this.delegatingConfig = delegatingConfig;
-    this.delegatingLLM = delegatingLLM;
     this.delegatingTools = delegatingTools;
+    this.llmFactory = llmFactory;
+    this.configResolver = configResolver;
   }
   async run(config, context) {
     const eventPort = context?.eventPort;
     const signal = context?.signal;
     const agentManager = new AgentManager(
       this.delegatingConfig,
-      this.delegatingLLM,
       this.delegatingTools,
-      eventPort ? (event) => eventPort.emit(event) : void 0
+      this.llmFactory,
+      eventPort ? (event) => eventPort.emit(event) : void 0,
+      this.configResolver
     );
     return agentManager.executeTask(config, signal);
   }
@@ -3253,16 +3273,34 @@ var DefaultDelegationResultFormatter = class {
   }
 };
 
+// delegation/DelegationServiceFactory.ts
+var DelegationServiceFactory = class {
+  create(config) {
+    const specialistFactory = new DefaultSpecialistAgentFactory({
+      agentListProvider: config.agentListProvider
+    });
+    return new DefaultDelegationService(
+      config.agentRegistry,
+      new DefaultDelegationPolicy(),
+      specialistFactory,
+      config.commandRunner,
+      new DefaultDelegationResultFormatter()
+    );
+  }
+};
+
 // tools.ts
 var ToolRegistry = class {
   tools = /* @__PURE__ */ new Map();
   toolsMemory;
   agentRegistry;
+  delegationServiceFactory;
   assignTool;
   enabledAgentsConfig = {};
   constructor(opts) {
     this.toolsMemory = opts?.toolsMemory || new InMemoryMemory();
     this.agentRegistry = opts?.agentRegistry || new AgentRegistry();
+    this.delegationServiceFactory = opts?.delegationServiceFactory;
     const todoStore = new TodoStore(opts?.todoMemory || new InMemoryMemory());
     const toolInstances = [
       new TodoWriteTool(todoStore),
@@ -3301,22 +3339,20 @@ var ToolRegistry = class {
   /**
    * Initialize AssignTool with orchestrator dependencies (lazy initialization)
    */
-  setOrchestrator(config, llm, tools) {
-    const delegationService = new DefaultDelegationService(
-      this.agentRegistry,
-      new DefaultDelegationPolicy(),
-      new DefaultSpecialistAgentFactory({
-        agentListProvider: () => this.agentRegistry.list().filter(
-          (agent) => typeof agent.id === "string" && typeof agent.name === "string" && typeof agent.description === "string"
-        ).map((agent) => ({
-          id: agent.id,
-          name: agent.name,
-          description: agent.description
-        }))
-      }),
-      new AgentManagerCommandRunner(config, llm, tools),
-      new DefaultDelegationResultFormatter()
-    );
+  setOrchestrator(config, tools, llmFactory, configResolver) {
+    const commandRunner = new AgentManagerCommandRunner(config, tools, llmFactory, configResolver);
+    const factory = this.delegationServiceFactory ?? new DelegationServiceFactory();
+    const delegationService = factory.create({
+      agentRegistry: this.agentRegistry,
+      commandRunner,
+      agentListProvider: () => this.agentRegistry.list().filter(
+        (agent) => typeof agent.id === "string" && typeof agent.name === "string" && typeof agent.description === "string"
+      ).map((agent) => ({
+        id: agent.id,
+        name: agent.name,
+        description: agent.description
+      }))
+    });
     delegationService.setEnabledAgents(this.enabledAgentsConfig);
     this.assignTool = new AssignTool(delegationService);
     this.tools.set("assign_task", this.assignTool);
@@ -5790,12 +5826,14 @@ export {
   DefaultDelegationResultFormatter,
   DefaultDelegationService,
   DefaultSpecialistAgentFactory,
+  DelegationServiceFactory,
   EchoLLM,
   GithubLLM,
   InMemoryMemory,
   InMemoryMetadata,
   JsonFileMemoryPersistence,
   LLMError,
+  LLMResolver,
   MCPToolPort,
   MemoryPortMetadataAdapter,
   NoopReminders,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuvin/nuvin-core",
-  "version": "0.1.0",
+  "version": "1.0.0",
   "description": "",
   "private": false,
   "main": "dist/index.js",