@nuvin/nuvin-core 0.1.0 → 1.0.1

package/dist/VERSION

@@ -1,4 +1,4 @@
 {
-  "version": "0.1.0",
-  "commit": "699bbe3"
+  "version": "1.0.1",
+  "commit": "d5c55a1"
 }

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> {
@@ -789,7 +799,7 @@ declare class SystemClock implements Clock {
 }
 
 declare class SimpleCost implements CostCalculator {
-    estimate(_model: string, _usage?: UsageData): number | undefined;
+    estimate(_model: string, usage?: UsageData): number | undefined;
 }
 
 declare class NoopReminders implements RemindersPort {
@@ -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;
@@ -1117,42 +1151,6 @@ declare class GithubAuthTransport implements HttpTransport {
     postStream(url: string, body: unknown, headers?: HttpHeaders, signal?: AbortSignal): Promise<Response>;
 }
 
-declare class OpenRouterAuthTransport implements HttpTransport {
-    private readonly inner;
-    private readonly apiKey?;
-    private readonly baseUrl;
-    constructor(inner: FetchTransport, apiKey?: string, baseUrl?: string);
-    private buildFullUrl;
-    private makeAuthHeaders;
-    get(url: string, headers?: HttpHeaders, signal?: AbortSignal): Promise<TransportResponse>;
-    postJson(url: string, body: unknown, headers?: HttpHeaders, signal?: AbortSignal): Promise<TransportResponse>;
-    postStream(url: string, body: unknown, headers?: HttpHeaders, signal?: AbortSignal): Promise<Response>;
-}
-
-declare class DeepInfraAuthTransport implements HttpTransport {
-    private readonly inner;
-    private readonly apiKey?;
-    private readonly baseUrl;
-    constructor(inner: FetchTransport, apiKey?: string, baseUrl?: string);
-    private buildFullUrl;
-    private makeAuthHeaders;
-    get(url: string, headers?: HttpHeaders, signal?: AbortSignal): Promise<TransportResponse>;
-    postJson(url: string, body: unknown, headers?: HttpHeaders, signal?: AbortSignal): Promise<TransportResponse>;
-    postStream(url: string, body: unknown, headers?: HttpHeaders, signal?: AbortSignal): Promise<Response>;
-}
-
-declare class ZAIAuthTransport implements HttpTransport {
-    private readonly inner;
-    private readonly apiKey?;
-    private readonly baseUrl;
-    constructor(inner: FetchTransport, apiKey?: string, baseUrl?: string);
-    private buildFullUrl;
-    private makeAuthHeaders;
-    get(url: string, headers?: HttpHeaders, signal?: AbortSignal): Promise<TransportResponse>;
-    postJson(url: string, body: unknown, headers?: HttpHeaders, signal?: AbortSignal): Promise<TransportResponse>;
-    postStream(url: string, body: unknown, headers?: HttpHeaders, signal?: AbortSignal): Promise<Response>;
-}
-
 declare class LLMError extends Error {
     readonly statusCode?: number;
     readonly isRetryable: boolean;
@@ -1188,138 +1186,6 @@ declare class GithubLLM extends BaseLLM implements LLMPort {
     protected createTransport(): GithubAuthTransport;
 }
 
-type OpenRouterOptions = {
-    apiKey?: string;
-    apiUrl?: string;
-    httpLogFile?: string;
-    enablePromptCaching?: boolean;
-    includeUsage?: boolean;
-};
-type OpenRouterModel = {
-    id: string;
-    canonical_slug: string;
-    hugging_face_id: string;
-    name: string;
-    created: number;
-    description: string;
-    context_length: number;
-    architecture: {
-        modality: string;
-        input_modalities: string[];
-        output_modalities: string[];
-        tokenizer: string;
-        instruct_type: string | null;
-    };
-    pricing: {
-        prompt: string;
-        completion: string;
-        request: string;
-        image: string;
-        web_search: string;
-        internal_reasoning: string;
-        input_cache_read: string;
-    };
-    top_provider: {
-        context_length: number;
-        max_completion_tokens: number | null;
-        is_moderated: boolean;
-    };
-    per_request_limits: {
-        prompt_tokens: string;
-        completion_tokens: string;
-    } | null;
-    supported_parameters: string[];
-    default_parameters: {
-        temperature: number | null;
-        top_p: number | null;
-        frequency_penalty: number | null;
-    };
-};
-declare class OpenRouterLLM extends BaseLLM implements LLMPort {
-    private readonly includeUsage;
-    constructor(opts?: OpenRouterOptions);
-    private readonly opts;
-    protected createTransport(): OpenRouterAuthTransport;
-    generateCompletion(params: CompletionParams, signal?: AbortSignal): Promise<CompletionResult>;
-    streamCompletion(params: CompletionParams, handlers?: {
-        onChunk?: (delta: string, usage?: UsageData) => void;
-        onToolCallDelta?: (tc: ToolCall) => void;
-        onStreamFinish?: (finishReason?: string, usage?: UsageData) => void;
-    }, signal?: AbortSignal): Promise<CompletionResult>;
-    getModels(signal?: AbortSignal): Promise<OpenRouterModel[]>;
-}
-
-type DeepInfraOptions = {
-    apiKey?: string;
-    apiUrl?: string;
-    httpLogFile?: string;
-};
-type DeepInfraModel = {
-    id: string;
-    object: string;
-    created: number;
-    owned_by: string;
-    root: string;
-    parent: string | null;
-    metadata: {
-        description: string;
-        context_length: number;
-        max_tokens: number;
-        pricing: {
-            input_tokens: number;
-            output_tokens: number;
-            cache_read_tokens?: number;
-        };
-        tags: string[];
-    };
-};
-declare class DeepInfraLLM extends BaseLLM implements LLMPort {
-    private readonly opts;
-    constructor(opts?: DeepInfraOptions);
-    protected createTransport(): DeepInfraAuthTransport;
-    getModels(signal?: AbortSignal): Promise<DeepInfraModel[]>;
-}
-
-type ZaiOptions = {
-    apiKey?: string;
-    apiUrl?: string;
-    httpLogFile?: string;
-};
-declare class ZaiLLM extends BaseLLM implements LLMPort {
-    private readonly opts;
-    constructor(opts?: ZaiOptions);
-    protected createTransport(): ZAIAuthTransport;
-}
-
-type AnthropicOptions = {
-    apiKey?: string;
-    oauth?: {
-        type: 'oauth';
-        access: string;
-        refresh: string;
-        expires: number;
-    };
-    apiUrl?: string;
-    httpLogFile?: string;
-};
-declare class AnthropicLLM {
-    private transport;
-    private readonly opts;
-    private readonly apiUrl;
-    constructor(opts?: AnthropicOptions);
-    private getTransport;
-    private transformToAnthropicMessages;
-    private transformTools;
-    private transformToolChoice;
-    private transformResponse;
-    generateCompletion(params: CompletionParams, signal?: AbortSignal): Promise<CompletionResult>;
-    streamCompletion(params: CompletionParams, handlers?: {
-        onChunk?: (delta: string, usage?: UsageData) => void;
-        onToolCallDelta?: (tc: ToolCall) => void;
-        onStreamFinish?: (finishReason?: string, usage?: UsageData) => void;
-    }, signal?: AbortSignal): Promise<CompletionResult>;
-}
-
 type AnthropicAISDKOptions = {
     apiKey?: string;
     oauth?: {
@@ -1360,6 +1226,17 @@ declare class AnthropicAISDKLLM {
     }, signal?: AbortSignal): Promise<CompletionResult>;
 }
 
+interface LLMOptions {
+    apiKey?: string;
+    apiUrl?: string;
+    httpLogFile?: string;
+    enablePromptCaching?: boolean;
+    includeUsage?: boolean;
+}
+declare function createLLM(providerName: string, options?: LLMOptions): LLMPort;
+declare function getAvailableProviders(): string[];
+declare function supportsGetModels(providerName: string): boolean;
+
 type MCPHttpOptions = {
     type: 'http';
     url: string;
@@ -1449,4 +1326,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, type AssignParams, BashTool, CompositeToolPort, type Conversation, ConversationContext, type ConversationMetadata, type ConversationSnapshot, ConversationStore, CoreMCPClient, DefaultDelegationPolicy, DefaultDelegationResultFormatter, DefaultDelegationService, DefaultSpecialistAgentFactory, type DelegationService, type DelegationServiceConfig, DelegationServiceFactory, EchoLLM, type FolderTreeOptions, GithubLLM, InMemoryMemory, InMemoryMetadata, JsonFileMemoryPersistence, type LLMConfig, LLMError, type LLMFactory, type LLMOptions, type LLMPort, LLMResolver, type MCPConfig, type MCPServerConfig, MCPToolPort, type MemoryPort, MemoryPortMetadataAdapter, type Message, type MessageContent, type MessageContentPart, type MetadataPort, NoopReminders, 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, buildAgentCreationPrompt, buildInjectedSystem, canonicalizeTerminalPaste, createLLM, generateFolderTree, getAvailableProviders, loadMCPConfig, normalizeNewlines, renderTemplate, resolveBackspaces, resolveCarriageReturns, stripAnsiAndControls, supportsGetModels };