@ductape/sdk 0.0.4-v6 → 0.0.4-v61

package/dist/agents/agent-executor.js

@@ -0,0 +1,715 @@
+"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