@ductape/sdk 0.1.7 → 0.1.8

package/dist/agents/agent-executor.js

@@ -1,715 +0,0 @@
-"use strict";
-/**
- * Agent Executor
- *
- * Implements the core agent loop: Observe -> Think -> Act -> Evaluate
- * Handles LLM integration, tool execution, and termination conditions.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentExecutor = exports.OpenAIProvider = exports.AnthropicProvider = exports.StubLLMProvider = void 0;
-exports.createLLMProvider = createLLMProvider;
-const crypto_1 = require("crypto");
-const memory_manager_1 = require("./memory-manager");
-const agent_context_1 = require("./agent-context");
-/**
- * Stub LLM Provider (for testing until real providers are connected)
- */
-class StubLLMProvider {
-    async generate(options) {
-        // Return a stub response indicating LLM is not configured
-        return {
-            content: 'LLM provider not configured. Please configure an LLM provider to use agent features.',
-            toolCalls: undefined,
-            stopReason: 'end_turn',
-            usage: {
-                inputTokens: 0,
-                outputTokens: 0,
-                totalTokens: 0,
-            },
-        };
-    }
-}
-exports.StubLLMProvider = StubLLMProvider;
-/**
- * Anthropic Claude LLM Provider
- */
-class AnthropicProvider {
-    constructor(config) {
-        this.apiKey = config.apiKey || process.env.ANTHROPIC_API_KEY || '';
-        this.baseUrl = config.baseUrl || 'https://api.anthropic.com';
-        this.model = config.model;
-        this.timeout = config.timeout || 60000;
-        if (!this.apiKey) {
-            console.warn('Anthropic API key not provided. LLM calls will fail.');
-        }
-    }
-    async generate(options) {
-        var _a, _b, _c, _d, _e, _f;
-        if (!this.apiKey) {
-            throw new Error('Anthropic API key not configured');
-        }
-        // Convert messages to Anthropic format
-        const anthropicMessages = options.messages
-            .filter((m) => m.role !== 'system')
-            .map((m) => {
-            var _a;
-            if (m.role === 'tool') {
-                return {
-                    role: 'user',
-                    content: [
-                        {
-                            type: 'tool_result',
-                            tool_use_id: ((_a = m.toolCall) === null || _a === void 0 ? void 0 : _a.id) || '',
-                            content: typeof m.toolResult === 'string'
-                                ? m.toolResult
-                                : JSON.stringify(m.toolResult),
-                        },
-                    ],
-                };
-            }
-            return {
-                role: m.role,
-                content: m.content,
-            };
-        });
-        const requestBody = {
-            model: this.model,
-            max_tokens: options.maxTokens || 4096,
-            system: options.systemPrompt,
-            messages: anthropicMessages,
-        };
-        if (options.temperature !== undefined) {
-            requestBody.temperature = options.temperature;
-        }
-        if (options.tools && options.tools.length > 0) {
-            requestBody.tools = options.tools;
-        }
-        if (options.stopSequences && options.stopSequences.length > 0) {
-            requestBody.stop_sequences = options.stopSequences;
-        }
-        const response = await fetch(`${this.baseUrl}/v1/messages`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'x-api-key': this.apiKey,
-                'anthropic-version': '2023-06-01',
-            },
-            body: JSON.stringify(requestBody),
-            signal: AbortSignal.timeout(this.timeout),
-        });
-        if (!response.ok) {
-            const error = await response.text();
-            throw new Error(`Anthropic API error: ${response.status} - ${error}`);
-        }
-        const data = await response.json();
-        // Parse response
-        let content = '';
-        const toolCalls = [];
-        for (const block of data.content || []) {
-            if (block.type === 'text') {
-                content += block.text;
-            }
-            else if (block.type === 'tool_use') {
-                toolCalls.push({
-                    id: block.id,
-                    name: block.name,
-                    input: block.input,
-                });
-            }
-        }
-        return {
-            content,
-            toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
-            stopReason: data.stop_reason === 'tool_use' ? 'tool_use' : 'end_turn',
-            usage: {
-                inputTokens: ((_a = data.usage) === null || _a === void 0 ? void 0 : _a.input_tokens) || 0,
-                outputTokens: ((_b = data.usage) === null || _b === void 0 ? void 0 : _b.output_tokens) || 0,
-                totalTokens: (((_c = data.usage) === null || _c === void 0 ? void 0 : _c.input_tokens) || 0) + (((_d = data.usage) === null || _d === void 0 ? void 0 : _d.output_tokens) || 0),
-                cacheReadTokens: (_e = data.usage) === null || _e === void 0 ? void 0 : _e.cache_read_input_tokens,
-                cacheWriteTokens: (_f = data.usage) === null || _f === void 0 ? void 0 : _f.cache_creation_input_tokens,
-            },
-        };
-    }
-}
-exports.AnthropicProvider = AnthropicProvider;
-/**
- * OpenAI LLM Provider
- */
-class OpenAIProvider {
-    constructor(config) {
-        this.apiKey = config.apiKey || process.env.OPENAI_API_KEY || '';
-        this.baseUrl = config.baseUrl || 'https://api.openai.com';
-        this.model = config.model;
-        this.timeout = config.timeout || 60000;
-    }
-    async generate(options) {
-        var _a, _b, _c, _d, _e;
-        if (!this.apiKey) {
-            throw new Error('OpenAI API key not configured');
-        }
-        // Convert messages to OpenAI format
-        const openaiMessages = [
-            { role: 'system', content: options.systemPrompt },
-            ...options.messages.map((m) => {
-                var _a;
-                if (m.role === 'tool') {
-                    return {
-                        role: 'tool',
-                        tool_call_id: ((_a = m.toolCall) === null || _a === void 0 ? void 0 : _a.id) || '',
-                        content: typeof m.toolResult === 'string'
-                            ? m.toolResult
-                            : JSON.stringify(m.toolResult),
-                    };
-                }
-                return {
-                    role: m.role,
-                    content: m.content,
-                };
-            }),
-        ];
-        const requestBody = {
-            model: this.model,
-            messages: openaiMessages,
-            max_tokens: options.maxTokens || 4096,
-        };
-        if (options.temperature !== undefined) {
-            requestBody.temperature = options.temperature;
-        }
-        if (options.tools && options.tools.length > 0) {
-            // Convert to OpenAI tool format
-            requestBody.tools = options.tools.map((t) => ({
-                type: 'function',
-                function: {
-                    name: t.name,
-                    description: t.description,
-                    parameters: t.input_schema,
-                },
-            }));
-        }
-        if (options.stopSequences && options.stopSequences.length > 0) {
-            requestBody.stop = options.stopSequences;
-        }
-        const response = await fetch(`${this.baseUrl}/v1/chat/completions`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${this.apiKey}`,
-            },
-            body: JSON.stringify(requestBody),
-            signal: AbortSignal.timeout(this.timeout),
-        });
-        if (!response.ok) {
-            const error = await response.text();
-            throw new Error(`OpenAI API error: ${response.status} - ${error}`);
-        }
-        const data = await response.json();
-        const message = (_b = (_a = data.choices) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.message;
-        const toolCalls = [];
-        if (message === null || message === void 0 ? void 0 : message.tool_calls) {
-            for (const tc of message.tool_calls) {
-                toolCalls.push({
-                    id: tc.id,
-                    name: tc.function.name,
-                    input: JSON.parse(tc.function.arguments || '{}'),
-                });
-            }
-        }
-        return {
-            content: (message === null || message === void 0 ? void 0 : message.content) || '',
-            toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
-            stopReason: (message === null || message === void 0 ? void 0 : message.tool_calls) ? 'tool_use' : 'end_turn',
-            usage: {
-                inputTokens: ((_c = data.usage) === null || _c === void 0 ? void 0 : _c.prompt_tokens) || 0,
-                outputTokens: ((_d = data.usage) === null || _d === void 0 ? void 0 : _d.completion_tokens) || 0,
-                totalTokens: ((_e = data.usage) === null || _e === void 0 ? void 0 : _e.total_tokens) || 0,
-            },
-        };
-    }
-}
-exports.OpenAIProvider = OpenAIProvider;
-/**
- * Create LLM provider based on config
- */
-function createLLMProvider(config) {
-    switch (config.provider) {
-        case 'anthropic':
-            return new AnthropicProvider(config);
-        case 'openai':
-            return new OpenAIProvider(config);
-        default:
-            console.warn(`Unknown LLM provider: ${config.provider}. Using stub provider.`);
-            return new StubLLMProvider();
-    }
-}
-/**
- * Parse duration string to milliseconds
- */
-function parseDuration(duration) {
-    if (typeof duration === 'number') {
-        return duration;
-    }
-    const match = duration.match(/^(\d+)(ms|s|m|h|d)$/);
-    if (!match) {
-        return parseInt(duration, 10) || 60000;
-    }
-    const value = parseInt(match[1], 10);
-    const unit = match[2];
-    switch (unit) {
-        case 'ms':
-            return value;
-        case 's':
-            return value * 1000;
-        case 'm':
-            return value * 60 * 1000;
-        case 'h':
-            return value * 60 * 60 * 1000;
-        case 'd':
-            return value * 24 * 60 * 60 * 1000;
-        default:
-            return value;
-    }
-}
-/**
- * Agent Executor
- *
- * Orchestrates the agent loop execution
- */
-class AgentExecutor {
-    constructor(agent, toolRegistry, services, options, llmProvider, llmConfig) {
-        this.startTime = 0;
-        // Approval handling
-        this.pendingApproval = null;
-        this.approvalResolver = null;
-        this.agent = agent;
-        this.toolRegistry = toolRegistry;
-        this.services = services;
-        this.options = options;
-        // LLM provider and config must be provided - model tags are resolved by AgentsService.run()
-        this.llmProvider = llmProvider;
-        this.llmConfig = llmConfig;
-        // Initialize termination config with overrides
-        this.terminationConfig = Object.assign(Object.assign({}, agent.termination), options.termination);
-        this.hooks = agent.hooks || [];
-        this.humanInLoop = agent.humanInLoop;
-        this.streamCallback = options.onStream;
-        // Initialize state
-        const executionId = (0, crypto_1.randomUUID)();
-        this.state = {
-            execution_id: executionId,
-            agent_tag: agent.tag,
-            status: 'pending',
-            input: options.input,
-            iteration: 0,
-            conversation: options.conversationContext || [],
-            toolCalls: [],
-            data: {},
-            usage: {
-                inputTokens: 0,
-                outputTokens: 0,
-                totalTokens: 0,
-            },
-            startedAt: Date.now(),
-            updatedAt: Date.now(),
-        };
-        // Initialize memory manager
-        this.memoryManager = new memory_manager_1.MemoryManager(agent.memory || {}, executionId, agent.tag);
-        // Import initial conversation if provided
-        if (options.conversationContext) {
-            this.memoryManager.importConversation(options.conversationContext);
-        }
-        // Initialize context
-        this.context = new agent_context_1.AgentContext(this.state, Object.assign(Object.assign({}, services), { config: Object.assign(Object.assign({}, services.config), { product: options.product, env: options.env }) }), undefined, options.session);
-    }
-    /**
-     * Execute the agent
-     */
-    async execute() {
-        this.startTime = Date.now();
-        this.state.status = 'running';
-        this.state.startedAt = this.startTime;
-        this.emit('iteration_start', { iteration: 0 });
-        try {
-            // Add user input as first message if not in conversation
-            if (!this.state.conversation.some((m) => m.role === 'user')) {
-                const userMessage = {
-                    role: 'user',
-                    content: JSON.stringify(this.state.input),
-                    timestamp: Date.now(),
-                };
-                this.memoryManager.addMessage(userMessage);
-                this.state.conversation.push(userMessage);
-            }
-            // Main agent loop
-            while (!this.shouldTerminate()) {
-                this.state.iteration++;
-                this.state.updatedAt = Date.now();
-                this.emit('iteration_start', { iteration: this.state.iteration });
-                // Run before-iteration hooks
-                const continueIteration = await this.runHooks('before', 'iteration');
-                if (!continueIteration) {
-                    break;
-                }
-                // THINK: Call LLM
-                this.emit('thinking_start', { iteration: this.state.iteration });
-                const llmResponse = await this.think();
-                this.emit('thinking_end', { iteration: this.state.iteration, response: llmResponse });
-                // Update usage
-                this.state.usage.inputTokens += llmResponse.usage.inputTokens;
-                this.state.usage.outputTokens += llmResponse.usage.outputTokens;
-                this.state.usage.totalTokens += llmResponse.usage.totalTokens;
-                // Add assistant message
-                if (llmResponse.content) {
-                    const assistantMessage = {
-                        role: 'assistant',
-                        content: llmResponse.content,
-                        timestamp: Date.now(),
-                    };
-                    this.memoryManager.addMessage(assistantMessage);
-                    this.state.conversation.push(assistantMessage);
-                    this.emit('message_delta', { content: llmResponse.content });
-                }
-                // ACT: Execute tool calls if any
-                if (llmResponse.toolCalls && llmResponse.toolCalls.length > 0) {
-                    for (const toolCall of llmResponse.toolCalls) {
-                        // Check human-in-the-loop
-                        if (this.requiresApproval(toolCall.name)) {
-                            this.state.status = 'waiting_approval';
-                            const approved = await this.requestApproval(toolCall);
-                            if (!approved) {
-                                // Tool was rejected
-                                const rejectMessage = {
-                                    role: 'tool',
-                                    content: '',
-                                    toolCall: { id: toolCall.id, name: toolCall.name, input: toolCall.input },
-                                    toolResult: { error: 'Tool call was rejected by user' },
-                                    timestamp: Date.now(),
-                                };
-                                this.memoryManager.addMessage(rejectMessage);
-                                this.state.conversation.push(rejectMessage);
-                                continue;
-                            }
-                            this.state.status = 'running';
-                        }
-                        // Execute tool
-                        this.emit('tool_start', { tool: toolCall.name, input: toolCall.input });
-                        const result = await this.act(toolCall);
-                        this.emit('tool_end', { tool: toolCall.name, result });
-                        this.state.toolCalls.push(result);
-                        // Add tool result to conversation
-                        const toolMessage = {
-                            role: 'tool',
-                            content: '',
-                            toolCall: { id: toolCall.id, name: toolCall.name, input: toolCall.input },
-                            toolResult: result.success ? result.output : { error: result.error },
-                            timestamp: Date.now(),
-                        };
-                        this.memoryManager.addMessage(toolMessage);
-                        this.state.conversation.push(toolMessage);
-                        // Check stop conditions
-                        if (this.checkStopConditions(toolCall.name, result)) {
-                            this.state.status = 'completed';
-                            break;
-                        }
-                    }
-                }
-                // Run after-iteration hooks
-                await this.runHooks('after', 'iteration');
-                this.emit('iteration_end', { iteration: this.state.iteration });
-                // If LLM didn't request tools and gave final answer
-                if (llmResponse.stopReason === 'end_turn' && !llmResponse.toolCalls) {
-                    this.state.status = 'completed';
-                    break;
-                }
-            }
-            // Determine final status
-            if (this.state.status === 'running') {
-                // Terminated due to limits
-                if (this.state.iteration >= (this.terminationConfig.maxIterations || 100)) {
-                    this.state.status = 'completed';
-                    this.state.error = 'Max iterations reached';
-                }
-                else if (this.state.usage.totalTokens >= (this.terminationConfig.maxTokens || 100000)) {
-                    this.state.status = 'completed';
-                    this.state.error = 'Max tokens reached';
-                }
-                else if (Date.now() - this.startTime >= parseDuration(this.terminationConfig.timeout || '10m')) {
-                    this.state.status = 'timeout';
-                    this.state.error = 'Execution timeout';
-                }
-            }
-            this.emit('agent_complete', { status: this.state.status });
-            return this.buildResult();
-        }
-        catch (error) {
-            this.state.status = 'failed';
-            this.state.error = error.message;
-            this.emit('error', { error: error.message });
-            return this.buildResult();
-        }
-    }
-    /**
-     * THINK: Call LLM to decide next action
-     */
-    async think() {
-        // Build context with memories
-        const { conversation, memories } = await this.memoryManager.buildContext(JSON.stringify(this.state.input));
-        // Build system prompt with memories
-        let systemPrompt = this.agent.systemPrompt;
-        if (memories.length > 0) {
-            systemPrompt += this.memoryManager.formatMemoriesForPrompt(memories);
-        }
-        // Get tool definitions in LLM format
-        const tools = this.toolRegistry.toClaudeFormat();
-        // Call LLM
-        return this.llmProvider.generate({
-            messages: conversation,
-            systemPrompt,
-            tools: tools.length > 0 ? tools : undefined,
-            maxTokens: this.llmConfig.maxTokens,
-            temperature: this.llmConfig.temperature,
-            stopSequences: this.llmConfig.stopSequences,
-        });
-    }
-    /**
-     * ACT: Execute a tool call
-     */
-    async act(toolCall) {
-        // Update context state
-        this.context.updateState(this.state);
-        // Execute tool
-        return this.toolRegistry.execute(toolCall.name, toolCall.input, this.context);
-    }
-    /**
-     * Check if execution should terminate
-     */
-    shouldTerminate() {
-        // Check max iterations
-        if (this.state.iteration >= (this.terminationConfig.maxIterations || 100)) {
-            return true;
-        }
-        // Check max tokens
-        if (this.state.usage.totalTokens >= (this.terminationConfig.maxTokens || 100000)) {
-            return true;
-        }
-        // Check timeout
-        const timeout = parseDuration(this.terminationConfig.timeout || '10m');
-        if (Date.now() - this.startTime >= timeout) {
-            return true;
-        }
-        // Check status
-        if (['completed', 'failed', 'cancelled', 'timeout'].includes(this.state.status)) {
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Check stop conditions against tool result
-     */
-    checkStopConditions(toolName, result) {
-        const stopConditions = this.terminationConfig.stopConditions || [];
-        for (const condition of stopConditions) {
-            // Tool-based stop condition
-            if ('tool' in condition && condition.tool === toolName) {
-                if (!condition.outputMatch) {
-                    return true;
-                }
-                // Check output match
-                if (result.success && this.matchesOutput(result.output, condition.outputMatch)) {
-                    return true;
-                }
-            }
-            // Output-based stop condition
-            if ('output' in condition && result.success) {
-                if (this.matchesOutput(result.output, condition.output)) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-    /**
-     * Check if output matches expected values
-     */
-    matchesOutput(output, expected) {
-        if (typeof output !== 'object' || output === null) {
-            return false;
-        }
-        for (const [key, value] of Object.entries(expected)) {
-            if (output[key] !== value) {
-                return false;
-            }
-        }
-        return true;
-    }
-    /**
-     * Run hooks for a specific event
-     */
-    async runHooks(timing, event) {
-        const relevantHooks = this.hooks.filter((h) => h.timing === timing && h.event === event);
-        for (const hook of relevantHooks) {
-            let shouldAbort = false;
-            const hookContext = {
-                state: this.state,
-                event: { type: event, data: {} },
-                abort: (reason) => {
-                    shouldAbort = true;
-                    this.state.error = reason;
-                },
-                modify: (changes) => {
-                    Object.assign(this.state.data, changes);
-                },
-            };
-            try {
-                const result = await hook.handler(hookContext);
-                if (result === false || shouldAbort) {
-                    return false;
-                }
-            }
-            catch (error) {
-                console.error(`Hook ${hook.name} failed:`, error.message);
-            }
-        }
-        return true;
-    }
-    /**
-     * Check if tool requires approval
-     */
-    requiresApproval(toolName) {
-        var _a, _b;
-        if (!((_a = this.humanInLoop) === null || _a === void 0 ? void 0 : _a.enabled)) {
-            return false;
-        }
-        // Check tool's own setting
-        if (this.toolRegistry.requiresConfirmation(toolName)) {
-            return true;
-        }
-        // Check always-require list
-        if ((_b = this.humanInLoop.alwaysRequireApproval) === null || _b === void 0 ? void 0 : _b.includes(toolName)) {
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Request human approval for tool call
-     */
-    async requestApproval(toolCall) {
-        var _a;
-        const request = {
-            id: toolCall.id,
-            tool: toolCall.name,
-            params: toolCall.input,
-            reason: `Agent wants to call tool: ${toolCall.name}`,
-            timeout: parseDuration(((_a = this.humanInLoop) === null || _a === void 0 ? void 0 : _a.approvalTimeout) || '5m'),
-        };
-        this.pendingApproval = request;
-        this.emit('tool_start', { tool: toolCall.name, input: toolCall.input, awaiting_approval: true });
-        // Wait for approval (this would be resolved by external signal)
-        return new Promise((resolve) => {
-            this.approvalResolver = (approved) => resolve(approved);
-            // Set timeout
-            setTimeout(() => {
-                if (this.approvalResolver) {
-                    this.approvalResolver(false);
-                    this.approvalResolver = null;
-                }
-            }, request.timeout);
-        });
-    }
-    /**
-     * Handle external approval signal
-     */
-    handleApproval(approved, modifiedParams) {
-        if (this.approvalResolver) {
-            this.approvalResolver(approved, modifiedParams);
-            this.approvalResolver = null;
-            this.pendingApproval = null;
-        }
-    }
-    /**
-     * Handle external stop signal
-     */
-    handleStop() {
-        this.state.status = 'cancelled';
-        this.state.error = 'Stopped by user';
-    }
-    /**
-     * Handle external pause signal
-     */
-    handlePause() {
-        this.state.status = 'paused';
-    }
-    /**
-     * Handle external resume signal
-     */
-    handleResume() {
-        if (this.state.status === 'paused') {
-            this.state.status = 'running';
-        }
-    }
-    /**
-     * Emit stream event
-     */
-    emit(type, data) {
-        if (this.streamCallback) {
-            this.streamCallback({
-                type,
-                timestamp: Date.now(),
-                data,
-                iteration: this.state.iteration,
-            });
-        }
-    }
-    /**
-     * Build execution result
-     */
-    buildResult() {
-        const lastAssistantMessage = [...this.state.conversation]
-            .reverse()
-            .find((m) => m.role === 'assistant');
-        // Extract output from last tool calls or assistant message
-        let output = undefined;
-        if (this.state.toolCalls.length > 0) {
-            const lastSuccessfulTool = [...this.state.toolCalls]
-                .reverse()
-                .find((t) => t.success);
-            output = lastSuccessfulTool === null || lastSuccessfulTool === void 0 ? void 0 : lastSuccessfulTool.output;
-        }
-        let terminationReason;
-        if (this.state.iteration >= (this.terminationConfig.maxIterations || 100)) {
-            terminationReason = 'max_iterations';
-        }
-        else if (this.state.usage.totalTokens >= (this.terminationConfig.maxTokens || 100000)) {
-            terminationReason = 'max_tokens';
-        }
-        else if (this.state.status === 'timeout') {
-            terminationReason = 'timeout';
-        }
-        else if (this.state.status === 'cancelled') {
-            terminationReason = 'cancelled';
-        }
-        else if (this.state.status === 'completed') {
-            terminationReason = 'completed';
-        }
-        return {
-            execution_id: this.state.execution_id,
-            status: this.state.status,
-            output,
-            finalMessage: lastAssistantMessage === null || lastAssistantMessage === void 0 ? void 0 : lastAssistantMessage.content,
-            error: this.state.error,
-            iterations: this.state.iteration,
-            toolCalls: this.state.toolCalls,
-            usage: this.state.usage,
-            executionTime: Date.now() - this.startTime,
-            terminationReason,
-        };
-    }
-    /**
-     * Get current state (for status queries)
-     */
-    getState() {
-        return Object.assign({}, this.state);
-    }
-}
-exports.AgentExecutor = AgentExecutor;
-exports.default = AgentExecutor;
-//# sourceMappingURL=agent-executor.js.map