agents-library 0.1.0

package/dist/worker-agent-factory.d.ts

@@ -0,0 +1,688 @@
+/**
+ * Worker Agent Factory
+ * =====================
+ *
+ * Factory for creating worker agents (artist, designer, programmer) with
+ * configuration-driven instantiation and shared infrastructure.
+ *
+ * Architecture Pattern: **Composition over Inheritance**
+ * - BaseWorkerAgent COMPOSES with BaseBot (does NOT extend)
+ * - Uses delegation pattern to access BaseBot's circuit breaker and retry logic
+ * - This avoids tight coupling and allows flexible behavior customization
+ *
+ * Design Principles:
+ * - Factory pattern for consistent agent creation
+ * - Composition over inheritance for flexibility
+ * - Strategy pattern for role-specific customization via WorkerBehaviors
+ * - Template method pattern for lifecycle management (start/stop)
+ *
+ * Tool-Calling Agent Loop (Task 3.15):
+ * - executeTask sends task + available tools to LLM via ProviderManager
+ * - LLM calls tools iteratively (file ops, git ops via MCP)
+ * - Loop continues until LLM returns final text response
+ * - Git operations use client.invokeRemote() MCP tools, NOT child_process
+ *
+ * @module worker-agent-factory
+ */
+import { KadiClient } from '@kadi.build/core';
+import type { WorkerAgentConfig, AgentRole } from './types/agent-config.js';
+import type { ProviderManager } from './providers/provider-manager.js';
+import type { ToolDefinition } from './providers/types.js';
+import { TaskAssignedEvent } from './types/event-schemas.js';
+/**
+ * Base class for worker agents (artist, designer, programmer)
+ *
+ * **COMPOSITION PATTERN**: This class COMPOSES with BaseBot instead of extending it.
+ * - Maintains a private `baseBot` instance for circuit breaker and retry logic
+ * - Delegates tool invocation to `baseBot.invokeToolWithRetry()`
+ * - Keeps agent-specific logic separate from bot resilience patterns
+ *
+ * Why Composition over Inheritance?
+ * 1. **Flexibility**: Can compose multiple utilities (BaseBot, etc.)
+ * 2. **Decoupling**: Changes to BaseBot don't force changes to worker agent interface
+ * 3. **Single Responsibility**: BaseBot handles resilience, BaseWorkerAgent handles workflow
+ * 4. **Testability**: Can mock BaseBot behavior independently
+ *
+ * Lifecycle:
+ * 1. Constructor: Initialize configuration and compose utilities
+ * 2. start(): Connect to broker, subscribe to task events, initialize protocol
+ * 3. [Task execution happens asynchronously via event handlers]
+ * 4. stop(): Cleanup subscriptions, disconnect from broker
+ *
+ * @example
+ * ```typescript
+ * const config: WorkerAgentConfig = {
+ *   role: 'artist',
+ *   worktreePath: 'C:/p4/Personal/SD/agent-playground-artist',
+ *   brokerUrl: 'ws://localhost:8080/kadi',
+ *   networks: ['kadi'],
+ *   anthropicApiKey: process.env.ANTHROPIC_API_KEY!,
+ *   claudeModel: 'claude-sonnet-4-20250514'
+ * };
+ *
+ * const agent = new BaseWorkerAgent(config);
+ * await agent.start();
+ * // Agent now listens for {role}.task.assigned events and executes tasks
+ * ```
+ */
+export declare class BaseWorkerAgent {
+    /**
+     * KĀDI client for broker communication
+     *
+     * Used for:
+     * - Subscribing to events
+     * - Publishing completion/failure events
+     * - Invoking remote MCP tools (git, file management)
+     */
+    protected client: KadiClient;
+    /**
+     * LLM provider manager for model selection and chat
+     *
+     * Replaces direct Anthropic SDK usage. Provides:
+     * - Model-based routing (claude→Anthropic, gpt→Model Manager)
+     * - Automatic fallback on provider failure
+     * - Tool-calling via ChatOptions.tools
+     *
+     * Optional — if null, agent cannot execute tasks requiring LLM.
+     */
+    protected providerManager: ProviderManager | null;
+    /**
+     * Agent role (artist, designer, programmer)
+     *
+     * Used for:
+     * - Event topic filtering (generic task.assigned, role in payload)
+     * - Default file extensions
+     * - Commit message prefixes
+     */
+    protected role: AgentRole;
+    /**
+     * Absolute path to git worktree for this agent
+     *
+     * Agent creates files and commits in this directory.
+     * Must be a valid git worktree with initialized repository.
+     *
+     * @example 'C:/GitHub/agent-playground-artist'
+     */
+    protected worktreePath: string;
+    /**
+     * Network(s) this agent belongs to
+     *
+     * Used for network-based event routing in KĀDI broker.
+     * Agent only receives events published to these networks.
+     *
+     * @example ['kadi']
+     * @example ['production', 'team-alpha']
+     */
+    protected networks: string[];
+    /**
+     * Claude model to use for task execution (from role config or WorkerAgentConfig)
+     *
+     * @default 'claude-sonnet-4-20250514'
+     */
+    protected claudeModel: string;
+    /**
+     * Temperature for LLM requests (from role config)
+     *
+     * @default undefined (uses provider default)
+     */
+    protected temperature?: number;
+    /**
+     * Max tokens for LLM responses (from role config)
+     *
+     * @default undefined (uses provider default)
+     */
+    protected maxTokens?: number;
+    /**
+     * Commit message format template from role config
+     *
+     * Supports `{taskId}` placeholder. Used in the system prompt to guide
+     * the LLM on commit message formatting.
+     *
+     * @default 'feat({role}): <description> [{taskId}]'
+     */
+    protected commitFormat?: string;
+    /**
+     * Agent capabilities for task validation
+     *
+     * Used to validate incoming tasks before execution.
+     * If a task description doesn't match any capabilities, the agent rejects the task.
+     */
+    protected capabilities: string[];
+    /**
+     * MCP tool prefixes this agent is allowed to invoke (from role config)
+     *
+     * Controls which remote tools the agent can call via client.invokeRemote().
+     * Examples: ['git_git_', 'ability_file_']
+     *
+     * If empty, no remote tools are available to the agent.
+     */
+    protected toolPrefixes: string[];
+    /**
+     * Maximum iterations for the tool-calling loop.
+     * Prevents infinite loops if Claude keeps calling tools.
+     */
+    protected static readonly MAX_TOOL_LOOP_ITERATIONS = 25;
+    /**
+     * BaseBot instance for circuit breaker and retry logic (COMPOSITION)
+     *
+     * Used for resilient tool invocation with exponential backoff.
+     * Created lazily when anthropicApiKey is available.
+     */
+    private baseBot;
+    /**
+     * Full agent configuration
+     *
+     * Stored for reference and potential reconfiguration.
+     */
+    private config;
+    /**
+     * Set of task IDs that have been processed or are currently in-flight.
+     * Prevents duplicate execution when the same task.assigned event arrives
+     * multiple times (e.g., retry re-publish while first execution is still running).
+     */
+    private processedTaskIds;
+    /**
+     * Create a new BaseWorkerAgent instance
+     *
+     * Initializes all configuration properties and composes utility classes
+     * (BaseBot). Does NOT connect to broker yet - call start()
+     * to establish connection.
+     *
+     * @param config - Worker agent configuration with all required fields
+     *
+     * @example
+     * ```typescript
+     * const agent = new BaseWorkerAgent({
+     *   role: 'artist',
+     *   worktreePath: 'C:/p4/Personal/SD/agent-playground-artist',
+     *   brokerUrl: 'ws://localhost:8080/kadi',
+     *   networks: ['kadi'],
+     *   anthropicApiKey: process.env.ANTHROPIC_API_KEY!,
+     *   claudeModel: 'claude-sonnet-4-20250514',
+     *   customBehaviors: {
+     *     determineFilename: (taskId) => `artwork-${taskId}.png`
+     *   }
+     * });
+     * ```
+     */
+    constructor(config: WorkerAgentConfig);
+    /**
+     * Initialize KĀDI client and connect to broker
+     *
+     * Performs connection sequence with retry logic:
+     * 1. Connect KĀDI client to broker (client.serve blocks, so we use setTimeout)
+     * 2. Wait for connection to establish (1 second delay)
+     * 3. Initialize broker protocol for tool invocation
+     * 4. Connect event publisher with retry logic
+     *
+     * Connection is performed with exponential backoff retry logic inherited from
+     * Uses client.publish() for event publishing. If broker is unavailable, events will be queued.
+     *
+     * @throws {Error} If broker connection fails after all retries
+     *
+     * @example
+     * ```typescript
+     * await this.initializeClient();
+     * // Client is now connected, protocol is initialized, publisher is ready
+     * ```
+     */
+    protected initializeClient(): Promise<void>;
+    /**
+     * Subscribe to task assignment events
+     *
+     * Subscribes to {role}.task.assigned topic pattern to receive task assignments
+     * from agent-producer. Topic is constructed dynamically from config.role to avoid
+     * hardcoding and ensure flexibility.
+     *
+     * Event Flow:
+     * 1. agent-producer publishes {role}.task.assigned event
+     * 2. Broker routes event to this agent based on network membership
+     * 3. handleTaskAssignment callback is invoked with event data
+     * 4. Event is validated with Zod schema
+     * 5. If valid, task execution begins
+     * 6. If invalid, error is logged and event is rejected
+     *
+     * @throws {Error} If subscription fails (e.g., client not connected)
+     *
+     * @example
+     * ```typescript
+     * await this.subscribeToTaskAssignments();
+     * // Agent now listens for task assignments on {role}.task.assigned
+     * ```
+     */
+    protected subscribeToTaskAssignments(): Promise<void>;
+    /**
+     * Handle task assignment event
+     *
+     * Callback invoked when {role}.task.assigned event is received.
+     * Performs validation and delegates to task execution.
+     *
+     * Validation Strategy:
+     * - Uses Zod schema for runtime validation (TaskAssignedEventSchema)
+     * - Rejects invalid events gracefully without crashing
+     * - Logs detailed validation errors for debugging
+     * - Maintains backward compatibility with existing event format
+     *
+     * Error Handling:
+     * - Invalid events: Log error, reject event, continue processing
+     * - Execution errors: Logged by executeTask method (implemented in next task)
+     *
+     * @param event - Raw event data from KĀDI broker (may include envelope wrapper)
+     *
+     * @example
+     * ```typescript
+     * // Event structure from broker:
+     * {
+     *   data: {
+     *     taskId: 'task-123',
+     *     role: 'artist',
+     *     description: 'Create hero banner',
+     *     requirements: 'Size: 1920x1080',
+     *     timestamp: '2025-12-04T10:30:00.000Z'
+     *   }
+     * }
+     * ```
+     */
+    protected handleTaskAssignment(event: unknown): Promise<void>;
+    /**
+     * Execute task using tool-calling agent loop
+     *
+     * Replaces the old linear pipeline (generate content → write file → git commit)
+     * with an iterative tool-calling loop where the LLM decides what tools to use.
+     *
+     * Flow:
+     * 1. Fetch full task details from quest (if questId provided)
+     * 2. Set git working directory to worktree via MCP
+     * 3. Build system prompt with task context and available tools
+     * 4. Enter tool-calling loop:
+     *    a. Send messages + tools to ProviderManager.chat()
+     *    b. If response contains __TOOL_CALLS__, execute each tool via invokeRemote
+     *    c. Feed tool results back as messages
+     *    d. Repeat until LLM returns plain text (done) or max iterations reached
+     * 5. Extract files created/modified and commit SHA from tool call history
+     * 6. Publish task.completed event
+     *
+     * @param task - Validated task assignment event
+     */
+    protected executeTask(task: TaskAssignedEvent): Promise<void>;
+    /**
+     * Build the system prompt for the tool-calling agent loop
+     *
+     * Includes task context, role identity, worktree path, and instructions
+     * for using available tools (git, file operations).
+     */
+    protected buildTaskSystemPrompt(task: TaskAssignedEvent, implementationGuide: string, verificationCriteria: string): string;
+    /**
+     * Build tool definitions: local tools + dynamic discovery from KĀDI broker
+     *
+     * 1. Always includes local tools (write_file, read_file)
+     * 2. Discovers network tools from broker via kadi.ability.list
+     * 3. Filters network tools by toolPrefixes from role config
+     * 4. Converts to OpenAI-compatible ToolDefinition format
+     */
+    protected buildToolDefinitionsAsync(): Promise<ToolDefinition[]>;
+    /**
+     * Fallback: append hardcoded git tool definitions when broker discovery fails
+     */
+    private appendHardcodedGitTools;
+    /**
+     * @deprecated Use buildToolDefinitionsAsync() instead. Kept for backward compatibility.
+     */
+    protected buildToolDefinitions(): ToolDefinition[];
+    /**
+     * Execute a remote MCP tool or local file operation via KĀDI broker
+     *
+     * Routes tool calls to either local file operations (write_file, read_file)
+     * or remote MCP tools via client.invokeRemote().
+     *
+     * @param toolName - Tool name (e.g., 'git_git_add', 'write_file')
+     * @param toolArgs - Tool arguments object
+     * @returns Tool execution result
+     */
+    protected executeRemoteTool(toolName: string, toolArgs: Record<string, any>): Promise<any>;
+    /**
+     * Track file operations from tool call results
+     *
+     * Inspects tool name and arguments to determine which files were
+     * created or modified during the agent loop.
+     */
+    private trackFileOperations;
+    /**
+     * Extract commit SHA from git_commit tool result
+     */
+    private extractCommitSha;
+    /**
+     * Sanitize filename to remove unsafe characters
+     *
+     * Utility method kept for subclass use and backward compatibility.
+     *
+     * @param filename - Raw filename
+     * @returns Sanitized filename safe for filesystem
+     */
+    protected sanitizeFilename(filename: string): string;
+    /**
+     * Format commit message for git commit
+     *
+     * Utility method kept for subclass use. The tool-calling loop
+     * instructs the LLM to use this format in the system prompt.
+     *
+     * @param taskId - Task ID to include in commit message
+     * @param files - Array of file paths that were modified/created
+     * @param taskDescription - Optional task description for context
+     * @returns Formatted commit message
+     */
+    protected formatCommitMessage(taskId: string, files: string[], taskDescription?: string): string;
+    /**
+     * Publish task completion event
+     *
+     * Publishes TaskCompletedEvent to KĀDI broker with topic pattern: {role}.task.completed
+     * Event payload matches TaskCompletedEvent schema exactly for backward compatibility.
+     *
+     * Publishing failures are handled gracefully - errors are logged but do not throw.
+     * This ensures task execution completes even if event publishing fails.
+     *
+     * @param taskId - Task ID that completed
+     * @param filesCreated - Array of file paths created during task execution
+     * @param filesModified - Array of file paths modified during task execution
+     * @param commitSha - Git commit SHA of the commit containing task output
+     *
+     * @example
+     * ```typescript
+     * await this.publishCompletion(
+     *   'task-123',
+     *   ['artwork.png'],
+     *   [],
+     *   'a1b2c3d4e5f6g7h8i9j0'
+     * );
+     * // Publishes to: task.completed
+     * ```
+     */
+    protected publishCompletion(taskId: string, questId: string | undefined, filesCreated: string[], filesModified: string[], commitSha: string, contentSummary?: string): Promise<void>;
+    /**
+     * Publish task failure event
+     *
+     * Publishes TaskFailedEvent to KĀDI broker with topic pattern: {role}.task.failed
+     * Event payload matches TaskFailedEvent schema exactly for backward compatibility.
+     *
+     * Publishing failures are handled gracefully - errors are logged but do not throw.
+     * This prevents cascading failures when event publishing is unavailable.
+     *
+     * @param taskId - Task ID that failed
+     * @param error - Error that caused task failure
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   await this.executeTask(task);
+     * } catch (error) {
+     *   await this.publishFailure('task-123', error as Error);
+     *   // Publishes to: task.failed
+     * }
+     * ```
+     */
+    protected publishFailure(taskId: string, error: Error, questId?: string): Promise<void>;
+    /**
+     * Validate whether a task matches this agent's capabilities
+     *
+     * Performs keyword matching between the task description and the agent's
+     * capability list. If no overlap is found, returns a rejection reason.
+     *
+     * @param task - Task assignment event to validate
+     * @returns Rejection reason string if task doesn't match, null if it does
+     */
+    protected validateTaskCapability(task: TaskAssignedEvent): string | null;
+    /**
+     * Validate that task targets paths within this agent's worktree.
+     *
+     * Extracts absolute file paths from task description and requirements,
+     * then checks if any fall outside the agent's worktree directory.
+     *
+     * @param task - Task assignment event to validate
+     * @returns Rejection reason string if task targets out-of-scope paths, null if OK
+     */
+    protected validateTaskScope(task: TaskAssignedEvent): string | null;
+    /**
+     * Publish task rejection event
+     *
+     * Publishes TaskRejectedEvent to KĀDI broker with topic: task.rejected
+     * This notifies agent-producer that the task was rejected due to capability mismatch,
+     * allowing it to reassign or escalate to the human.
+     *
+     * @param taskId - Task ID that was rejected
+     * @param questId - Quest ID (optional)
+     * @param reason - Reason for rejection
+     */
+    protected publishRejection(taskId: string, questId: string | undefined, reason: string): Promise<void>;
+    /**
+     * Start the worker agent
+     *
+     * Performs initialization sequence:
+     * 1. Connect to KĀDI broker
+     * 2. Initialize broker protocol
+     * 3. Connect event publisher
+     * 4. Subscribe to {role}.task.assigned events
+     * 5. Enter event loop (non-blocking)
+     *
+     * After start() completes, the agent is ready to receive task assignments.
+     *
+     * @throws {Error} If broker connection fails after all retries
+     *
+     * @example
+     * ```typescript
+     * const agent = new BaseWorkerAgent(config);
+     * await agent.start();
+     * console.log('Agent is now listening for task assignments');
+     * ```
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the worker agent
+     *
+     * Performs cleanup sequence:
+     * 1. Unsubscribe from all events (TODO: next task)
+     * 2. Disconnect event publisher
+     * 3. Disconnect KĀDI client
+     * 4. Clear protocol reference
+     *
+     * After stop() completes, the agent is fully shut down and can be safely destroyed.
+     *
+     * @example
+     * ```typescript
+     * await agent.stop();
+     * console.log('Agent has been stopped');
+     * ```
+     */
+    stop(): Promise<void>;
+    /**
+     * Invoke tool with retry logic using composed BaseBot
+     *
+     * Delegates to BaseBot's invokeToolWithRetry() method for resilient tool invocation.
+     * This demonstrates the composition pattern - we use BaseBot's functionality
+     * without inheriting from it.
+     *
+     * @param params - Tool invocation parameters
+     * @returns Tool invocation result
+     *
+     * @example
+     * ```typescript
+     * const result = await this.invokeToolWithRetry({
+     *   targetAgent: 'mcp-server-git',
+     *   toolName: 'git_commit',
+     *   toolInput: { message: 'feat: create artwork', files: ['artwork.png'] },
+     *   timeout: 30000
+     * });
+     * ```
+     */
+    protected invokeToolWithRetry(params: {
+        targetAgent: string;
+        toolName: string;
+        toolInput: any;
+        timeout: number;
+    }): Promise<any>;
+    /**
+     * Check circuit breaker state using composed BaseBot
+     *
+     * @returns True if circuit is open, false if closed (or no BaseBot)
+     */
+    protected checkCircuitBreaker(): boolean;
+    /**
+     * Set the ProviderManager for LLM chat
+     *
+     * Called by the agent entry point after constructing BaseAgent
+     * (which creates the ProviderManager).
+     *
+     * @param pm - ProviderManager instance from BaseAgent
+     */
+    setProviderManager(pm: ProviderManager): void;
+    /**
+     * Configure role-specific settings from a loaded RoleConfig
+     *
+     * @param roleConfig - Parsed role configuration
+     */
+    applyRoleConfig(roleConfig: {
+        capabilities?: string[];
+        tools?: string[];
+        provider?: {
+            model?: string;
+            temperature?: number;
+            maxTokens?: number;
+        };
+        commitFormat?: string;
+    }): void;
+}
+/**
+ * Factory class for creating worker agents with validated configuration
+ *
+ * Provides static factory method for instantiating worker agents with:
+ * - Runtime configuration validation using Zod schemas
+ * - Descriptive error messages for invalid configurations
+ * - Type-safe agent creation with compile-time checks
+ * - Clean separation between validation and instantiation
+ *
+ * The factory validates all required configuration fields before creating
+ * the agent instance, ensuring early failure with clear error messages
+ * rather than runtime errors during agent execution.
+ *
+ * @example
+ * ```typescript
+ * // Minimal agent creation (10-15 lines)
+ * import { WorkerAgentFactory } from 'agents-library';
+ *
+ * const agent = WorkerAgentFactory.createAgent({
+ *   role: 'artist',
+ *   worktreePath: 'C:/p4/Personal/SD/agent-playground-artist',
+ *   brokerUrl: 'ws://localhost:8080/kadi',
+ *   networks: ['kadi'],
+ *   anthropicApiKey: process.env.ANTHROPIC_API_KEY!
+ * });
+ *
+ * await agent.start();
+ * // Agent now listens for artist.task.assigned events
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With custom behaviors (under 50 lines)
+ * import { WorkerAgentFactory } from 'agents-library';
+ *
+ * const agent = WorkerAgentFactory.createAgent({
+ *   role: 'artist',
+ *   worktreePath: 'C:/p4/Personal/SD/agent-playground-artist',
+ *   brokerUrl: 'ws://localhost:8080/kadi',
+ *   networks: ['kadi'],
+ *   anthropicApiKey: process.env.ANTHROPIC_API_KEY!,
+ *   claudeModel: 'claude-sonnet-4-20250514',
+ *   customBehaviors: {
+ *     determineFilename: (taskId, description) => {
+ *       // Custom filename logic
+ *       return `artwork-${taskId}.png`;
+ *     },
+ *     formatCommitMessage: (taskId, files) => {
+ *       // Custom commit message format
+ *       return `feat: create artwork for ${taskId}`;
+ *     }
+ *   }
+ * });
+ *
+ * await agent.start();
+ * console.log('Agent started successfully');
+ * ```
+ */
+export declare class WorkerAgentFactory {
+    /**
+     * Create a worker agent with validated configuration
+     *
+     * Static factory method that validates configuration and creates a
+     * BaseWorkerAgent instance ready for start().
+     *
+     * Validation performed:
+     * - Role must be 'artist', 'designer', or 'programmer'
+     * - Worktree path must be non-empty string
+     * - Broker URL must start with ws:// or wss://
+     * - Networks array must contain at least one network name
+     * - Anthropic API key must be provided
+     * - Custom behaviors (if provided) must match expected signatures
+     *
+     * @param config - Worker agent configuration object
+     * @returns Configured BaseWorkerAgent instance (not started)
+     *
+     * @throws {z.ZodError} If configuration validation fails with detailed error messages
+     *
+     * @example
+     * ```typescript
+     * // Basic usage
+     * const agent = WorkerAgentFactory.createAgent({
+     *   role: 'artist',
+     *   worktreePath: 'C:/p4/Personal/SD/agent-playground-artist',
+     *   brokerUrl: 'ws://localhost:8080/kadi',
+     *   networks: ['kadi'],
+     *   anthropicApiKey: process.env.ANTHROPIC_API_KEY!
+     * });
+     *
+     * // Agent is created but not started - caller must call start()
+     * await agent.start();
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Error handling
+     * try {
+     *   const agent = WorkerAgentFactory.createAgent(config);
+     *   await agent.start();
+     * } catch (error) {
+     *   if (error instanceof z.ZodError) {
+     *     console.error('Configuration validation failed:');
+     *     error.issues.forEach(issue => {
+     *       console.error(`  - ${issue.path.join('.')}: ${issue.message}`);
+     *     });
+     *   } else {
+     *     console.error('Agent startup failed:', error);
+     *   }
+     * }
+     * ```
+     */
+    static createAgent(config: WorkerAgentConfig): BaseWorkerAgent;
+}
+/**
+ * Create a worker agent with configuration
+ *
+ * Convenience function that delegates to WorkerAgentFactory.createAgent().
+ * Provides backward compatibility with existing code.
+ *
+ * @param config - Worker agent configuration
+ * @returns Configured BaseWorkerAgent instance
+ *
+ * @example
+ * ```typescript
+ * const agent = createWorkerAgent({
+ *   role: 'artist',
+ *   worktreePath: 'C:/p4/Personal/SD/agent-playground-artist',
+ *   brokerUrl: 'ws://localhost:8080/kadi',
+ *   networks: ['kadi'],
+ *   anthropicApiKey: process.env.ANTHROPIC_API_KEY!
+ * });
+ * await agent.start();
+ * ```
+ */
+export declare function createWorkerAgent(config: WorkerAgentConfig): BaseWorkerAgent;
+//# sourceMappingURL=worker-agent-factory.d.ts.map

package/dist/worker-agent-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-agent-factory.d.ts","sourceRoot":"","sources":["../src/worker-agent-factory.ts"],"names":[],"mappings":"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"}