@qduc/term2 0.1.0

package/dist/lib/openai-agent-client.js

@@ -0,0 +1,653 @@
+import { Agent, run, tool as createTool, webSearchTool, applyPatchTool, } from '@openai/agents';
+import { APIConnectionError, APIConnectionTimeoutError, InternalServerError, RateLimitError, } from 'openai';
+import { OpenRouterError } from '../providers/openrouter.js';
+import { OpenAICompatibleError } from '../providers/openai-compatible/api.js';
+import { getProvider } from '../providers/index.js';
+import { randomUUID } from 'node:crypto';
+import { getAgentDefinition } from '../agent.js';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { normalizeToolInput, wrapToolInvoke } from './tool-invoke.js';
+import { createEditorImpl } from './editor-impl.js';
+import { ConversationStore } from '../services/conversation-store.js';
+/**
+ * Minimal adapter that isolates usage of @openai/agents.
+ * Swap this module to change the underlying agent provider without touching the UI.
+ */
+export class OpenAIAgentClient {
+    #agent;
+    #model;
+    // Accept 'default' here to denote 'do not pass this param; use API default'
+    #reasoningEffort;
+    #temperature;
+    #provider;
+    #maxTurns;
+    #retryAttempts;
+    #currentAbortController = null;
+    #currentCorrelationId = null;
+    #retryCallback = null;
+    #runner = null;
+    #toolInterceptors = [];
+    #logger;
+    #settings;
+    #executionContext;
+    #editor;
+    #mentorAgent = null;
+    #mentorStore = null;
+    #mentorPreviousResponseId = null;
+    constructor({ model, reasoningEffort, maxTurns, retryAttempts, deps, }) {
+        this.#logger = deps.logger;
+        this.#settings = deps.settings;
+        this.#executionContext = deps.executionContext;
+        this.#editor = createEditorImpl({
+            loggingService: this.#logger,
+            settingsService: this.#settings,
+            executionContext: this.#executionContext,
+        });
+        this.#reasoningEffort = reasoningEffort;
+        this.#temperature = this.#settings.get('agent.temperature');
+        this.#provider =
+            this.#settings.get('agent.provider') || 'openai';
+        this.#maxTurns = maxTurns ?? 20;
+        this.#retryAttempts = retryAttempts ?? 2;
+        this.#agent = this.#createAgent({ model, reasoningEffort });
+        this.#runner = this.#createRunner();
+        this.#logger.info('OpenAI Agent Client initialized', {
+            model: model || this.#settings.get('agent.model'),
+            reasoningEffort: reasoningEffort ?? 'default',
+            temperature: this.#temperature,
+            maxTurns: this.#maxTurns,
+            retryAttempts: this.#retryAttempts,
+        });
+    }
+    setModel(model) {
+        this.#agent = this.#createAgent({
+            model,
+            reasoningEffort: this.#reasoningEffort,
+        });
+    }
+    setReasoningEffort(effort) {
+        this.#reasoningEffort = effort;
+        this.#agent = this.#createAgent({
+            model: this.#model,
+            reasoningEffort: effort,
+        });
+    }
+    setTemperature(temperature) {
+        this.#temperature = temperature;
+        this.#agent = this.#createAgent({
+            model: this.#model,
+            reasoningEffort: this.#reasoningEffort,
+            temperature,
+        });
+    }
+    setProvider(provider) {
+        this.#provider = provider;
+        this.#settings.set('agent.provider', provider);
+        this.#agent = this.#createAgent({
+            model: this.#model,
+            reasoningEffort: this.#reasoningEffort,
+        });
+        this.#runner = this.#createRunner();
+    }
+    getProvider() {
+        return this.#provider;
+    }
+    addToolInterceptor(interceptor) {
+        this.#toolInterceptors.push(interceptor);
+        return () => {
+            this.#toolInterceptors = this.#toolInterceptors.filter(i => i !== interceptor);
+        };
+    }
+    async #checkToolInterceptors(name, params, toolCallId) {
+        for (const interceptor of this.#toolInterceptors) {
+            try {
+                const result = await interceptor(name, params, toolCallId);
+                if (result !== null) {
+                    return result;
+                }
+            }
+            catch (error) {
+                this.#logger.error('Tool interceptor threw an error', {
+                    name,
+                    params,
+                    toolCallId,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                return `Tool execution intercepted but failed: ${error instanceof Error ? error.message : String(error)}`;
+            }
+        }
+        return null;
+    }
+    #createRunner() {
+        const providerDef = getProvider(this.#provider);
+        if (!providerDef?.createRunner) {
+            return null;
+        }
+        return providerDef.createRunner({
+            settingsService: this.#settings,
+            loggingService: this.#logger,
+        });
+    }
+    setRetryCallback(callback) {
+        this.#retryCallback = callback;
+    }
+    /**
+     * Abort the current running stream/operation
+     */
+    abort() {
+        if (this.#currentAbortController) {
+            this.#currentAbortController.abort();
+            this.#currentAbortController = null;
+        }
+        if (this.#currentCorrelationId) {
+            this.#logger.clearCorrelationId();
+            this.#currentCorrelationId = null;
+        }
+        this.#logger.debug('Agent operation aborted');
+    }
+    clearConversations() {
+        const providerDef = getProvider(this.#provider);
+        if (providerDef?.clearConversations) {
+            providerDef.clearConversations();
+        }
+        // Also clear mentor conversation
+        if (this.#mentorStore) {
+            this.#mentorStore.clear();
+        }
+        this.#mentorPreviousResponseId = null;
+        this.#mentorAgent = null;
+        this.#mentorStore = null;
+    }
+    async startStream(userInput, { previousResponseId } = {}) {
+        // Abort any previous operation
+        this.abort();
+        // Create correlation ID for this stream
+        this.#currentCorrelationId = randomUUID();
+        this.#logger.setCorrelationId(this.#currentCorrelationId);
+        this.#currentAbortController = new AbortController();
+        const signal = this.#currentAbortController.signal;
+        this.#logger.info('Agent stream started', {
+            inputType: Array.isArray(userInput) ? 'array' : typeof userInput,
+            inputLength: typeof userInput === 'string' ? userInput.length : undefined,
+            inputItems: Array.isArray(userInput) ? userInput.length : undefined,
+            hasPreviousResponseId: !!previousResponseId,
+        });
+        try {
+            const options = {
+                stream: true,
+                maxTurns: this.#maxTurns,
+                signal,
+            };
+            // Only pass previousResponseId for OpenAI provider (server-managed conversation chaining)
+            if (this.#provider === 'openai' && previousResponseId) {
+                options.previousResponseId = previousResponseId;
+            }
+            const result = await this.#executeWithRetry(() => this.#runAgent(this.#agent, userInput, options));
+            return result;
+        }
+        catch (error) {
+            this.#logger.error('Agent stream failed', {
+                error: error instanceof Error ? error.message : String(error),
+                inputType: Array.isArray(userInput)
+                    ? 'array'
+                    : typeof userInput,
+                inputLength: typeof userInput === 'string'
+                    ? userInput.length
+                    : undefined,
+                inputItems: Array.isArray(userInput)
+                    ? userInput.length
+                    : undefined,
+            });
+            throw error;
+        }
+    }
+    async continueRun(state, { previousResponseId } = {}) {
+        this.abort();
+        this.#currentAbortController = new AbortController();
+        const signal = this.#currentAbortController.signal;
+        const options = {
+            signal,
+        };
+        // Only pass previousResponseId for OpenAI provider (server-managed conversation chaining)
+        if (this.#provider === 'openai' && previousResponseId) {
+            options.previousResponseId = previousResponseId;
+        }
+        return this.#executeWithRetry(() => this.#runAgent(this.#agent, state, options));
+    }
+    async continueRunStream(state, { previousResponseId } = {}) {
+        this.abort();
+        this.#currentAbortController = new AbortController();
+        const signal = this.#currentAbortController.signal;
+        const options = {
+            stream: true,
+            maxTurns: this.#maxTurns,
+            signal,
+        };
+        // Only pass previousResponseId for OpenAI provider (server-managed conversation chaining)
+        if (this.#provider === 'openai' && previousResponseId) {
+            options.previousResponseId = previousResponseId;
+        }
+        return this.#executeWithRetry(() => this.#runAgent(this.#agent, state, options));
+    }
+    #runAgent(agent, input, options) {
+        // The Agents SDK enables tracing by default and exports spans to OpenAI.
+        // When using non-OpenAI providers (e.g., OpenRouter), this export can fail noisily
+        // (e.g., 503 errors). Disable tracing per-run for any non-OpenAI provider.
+        const effectiveOptions = options ? { ...options } : {};
+        if (this.#provider !== 'openai') {
+            effectiveOptions.tracingDisabled = true;
+        }
+        // Check if provider is configured but runner failed to initialize
+        if (!this.#runner && this.#provider !== 'openai') {
+            const providerDef = getProvider(this.#provider);
+            const providerLabel = providerDef?.label || this.#provider;
+            throw new Error(`${providerLabel} is configured but could not be initialized. ` +
+                `Please check that all required credentials are set. ` +
+                `For OpenRouter, set OPENROUTER_API_KEY environment variable. ` +
+                `Get your API key from: https://openrouter.ai/keys`);
+        }
+        // Use runner if available (custom provider), otherwise use run() directly (OpenAI)
+        if (this.#runner) {
+            return this.#runner.run(agent, input, effectiveOptions);
+        }
+        return run(agent, input, effectiveOptions);
+    }
+    async #executeWithRetry(operation, retries = this.#retryAttempts) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            // Determine if the error is retryable
+            // UserError and ModelBehaviorError are NOT retried (logic errors, not transient)
+            const isTransientError = error instanceof APIConnectionError ||
+                error instanceof APIConnectionTimeoutError ||
+                error instanceof InternalServerError ||
+                error instanceof RateLimitError;
+            // Check if it's an OpenRouter error with retryable status
+            const isOpenRouterRetryable = error instanceof OpenRouterError &&
+                (error.status === 429 || error.status >= 500);
+            const isOpenAICompatibleRetryable = error instanceof OpenAICompatibleError &&
+                (error.status === 429 || error.status >= 500);
+            const isRetryable = retries > 0 &&
+                (isTransientError ||
+                    isOpenRouterRetryable ||
+                    isOpenAICompatibleRetryable);
+            if (isRetryable) {
+                const attemptIndex = this.#retryAttempts - retries;
+                let delay;
+                // Check for Retry-After header (both OpenAI and OpenRouter)
+                const retryAfterHeader = (error instanceof RateLimitError &&
+                    error.headers?.['retry-after']) ||
+                    (error instanceof OpenRouterError &&
+                        error.headers['retry-after']) ||
+                    (error instanceof OpenAICompatibleError &&
+                        error.headers['retry-after']);
+                if (retryAfterHeader) {
+                    // Respect the Retry-After header
+                    delay = parseInt(retryAfterHeader, 10) * 1000;
+                }
+                else {
+                    // Exponential backoff with full jitter
+                    // Base delay: 500-1000ms
+                    // Multiplier: 2^attemptIndex
+                    // Max cap: 30 seconds
+                    const baseDelay = 500 + Math.random() * 500; // 500-1000ms
+                    const exponentialDelay = baseDelay * Math.pow(2, attemptIndex);
+                    const maxDelay = 30000; // 30 seconds
+                    const cappedDelay = Math.min(exponentialDelay, maxDelay);
+                    // Apply full jitter: random value between 0 and cappedDelay
+                    delay = Math.random() * cappedDelay;
+                }
+                await new Promise(resolve => setTimeout(resolve, delay));
+                this.#logger.warn('Agent operation retry', {
+                    errorType: error.constructor.name,
+                    retriesRemaining: retries - 1,
+                    delayMs: Math.round(delay),
+                    attemptIndex,
+                    errorMessage: error instanceof Error ? error.message : String(error),
+                    ...(error instanceof OpenRouterError && {
+                        status: error.status,
+                    }),
+                    ...(error instanceof OpenAICompatibleError && {
+                        status: error.status,
+                    }),
+                });
+                this.#retryCallback?.();
+                return this.#executeWithRetry(operation, retries - 1);
+            }
+            throw error;
+        }
+    }
+    async chat(message, options = {}) {
+        this.#logger.debug('Agent chat request', {
+            messageLength: message.length,
+            model: options.model || this.#model,
+        });
+        try {
+            // Create a temporary agent for this specific chat request if params differ
+            let agentForChat = this.#agent;
+            if (options.model || options.reasoningEffort) {
+                const tempModel = options.model || this.#model;
+                const tempEffort = options.reasoningEffort || this.#reasoningEffort;
+                const modelSettings = {};
+                if (tempEffort && tempEffort !== 'default') {
+                    modelSettings.reasoning = {
+                        effort: tempEffort,
+                        summary: 'auto',
+                    };
+                }
+                // For simple chat, we generally don't need tools, but we keep the system instructions
+                // Actually, for mentor mode, we might want a simpler agent without tools
+                agentForChat = new Agent({
+                    name: 'Mentor',
+                    model: tempModel,
+                    ...(Object.keys(modelSettings).length > 0
+                        ? { modelSettings }
+                        : {}),
+                    instructions: options.instructions || 'You are a helpful mentor assistant.',
+                });
+                // Ensure runner is compatible or use run()
+                if (!this.#runner && this.#provider !== 'openai') {
+                    // Logic to ensure runner exists... same as #runAgent
+                    const providerDef = getProvider(this.#provider);
+                    if (!providerDef)
+                        throw new Error(`Provider ${this.#provider} not found`);
+                    if (providerDef.createRunner) {
+                        // We can't easily reuse the main runner if it's bound to the main agent
+                        // But creating a new runner for every chat might be expensive?
+                        // For now, let's assume we can just use `run` if no tools are needed,
+                        // but some providers NEED a runner.
+                        // Actually, most providers' runners are stateless or lightweight wrappers.
+                    }
+                }
+            }
+            // We use a simplified run flow for chat
+            const result = await this.#runAgent(agentForChat, message, {
+                stream: false,
+                maxTurns: 1, // Chat is usually single turn
+            });
+            if (result.finalOutput) {
+                return result.finalOutput;
+            }
+            // Fallback: extract from messages if finalOutput is missing
+            if (result.messages && Array.isArray(result.messages)) {
+                const lastMessage = result.messages[result.messages.length - 1];
+                if (lastMessage && lastMessage.content) {
+                    if (typeof lastMessage.content === 'string') {
+                        return lastMessage.content;
+                    }
+                    if (Array.isArray(lastMessage.content)) {
+                        return lastMessage.content
+                            .map((part) => part.text || part.value || '')
+                            .join('');
+                    }
+                }
+            }
+            return '';
+        }
+        catch (error) {
+            this.#logger.error('Agent chat failed', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error; // Propagate error
+        }
+    }
+    #getAgentsInstructions() {
+        const agentsPath = path.join(process.cwd(), 'AGENTS.md');
+        if (!fs.existsSync(agentsPath))
+            return '';
+        try {
+            const contents = fs.readFileSync(agentsPath, 'utf-8').trim();
+            return `\n\nAGENTS.md contents:\n${contents}`;
+        }
+        catch (e) {
+            return `\n\nFailed to read AGENTS.md: ${e.message}`;
+        }
+    }
+    #getEnvInfo() {
+        return `OS: ${os.type()} ${os.release()} (${os.platform()}); shell: ${this.#settings.get('app.shellPath') || 'unknown'}; cwd: ${process.cwd()}`;
+    }
+    #createMentor = async (question) => {
+        const mentorModel = this.#settings.get('agent.mentorModel');
+        if (!mentorModel) {
+            throw new Error('Mentor model is not configured');
+        }
+        const mentorMode = this.#settings.get('app.mentorMode');
+        // Different instructions based on mode
+        let baseInstructions = mentorMode
+            ? 'You are a senior architect acting as a peer reviewer. You have no codebase access—you rely on what the user reports.\n\n' +
+                'Your role is adversarial review, not rubber-stamping:\n' +
+                '- Challenge assumptions, even when reasoning sounds solid\n' +
+                '- Probe for gaps: what did they not check? What could go wrong?\n' +
+                '- Suggest alternatives they may have dismissed too quickly\n' +
+                '- Ask for evidence when confidence seems misplaced\n\n' +
+                'When satisfied, give clear approval with specific next steps. When not, say exactly what needs more investigation.\n\n' +
+                'Be concise. Push back hard, but don\'t block unnecessarily.'
+            : 'You are a helpful mentor assistant. Provide advice and guidance on technical problems. Be concise and actionable.';
+        // Add environment info and AGENTS.md context
+        const instructions = `${baseInstructions}\n\nEnvironment: ${this.#getEnvInfo()}${this.#getAgentsInstructions()}`;
+        // Initialize mentor agent and conversation store if needed
+        if (!this.#mentorAgent) {
+            const reasoningEffort = this.#settings.get('agent.mentorReasoningEffort');
+            const modelSettings = {};
+            if (reasoningEffort && reasoningEffort !== 'default') {
+                modelSettings.reasoning = {
+                    effort: reasoningEffort,
+                    summary: 'auto',
+                };
+            }
+            this.#mentorAgent = new Agent({
+                name: 'Mentor',
+                model: mentorModel,
+                ...(Object.keys(modelSettings).length > 0
+                    ? { modelSettings }
+                    : {}),
+                instructions,
+            });
+            this.#mentorStore = new ConversationStore();
+        }
+        try {
+            // Add user message to conversation history
+            this.#mentorStore.addUserMessage(question);
+            // Determine input based on provider
+            // OpenAI uses previousResponseId for server-side history
+            // Others need full conversation history from store
+            const input = this.#provider !== 'openai'
+                ? this.#mentorStore.getHistory()
+                : question;
+            const result = await this.#runAgent(this.#mentorAgent, input, {
+                stream: false,
+                maxTurns: 1,
+                ...(this.#provider === 'openai' && this.#mentorPreviousResponseId
+                    ? { previousResponseId: this.#mentorPreviousResponseId }
+                    : {}),
+            });
+            // Update conversation store with result
+            this.#mentorStore.updateFromResult(result);
+            // Track previousResponseId for OpenAI
+            if (result.responseId) {
+                this.#mentorPreviousResponseId = result.responseId;
+            }
+            // Extract response
+            let response = '';
+            if (result.finalOutput) {
+                response = result.finalOutput;
+            }
+            else if (result.messages && Array.isArray(result.messages)) {
+                const lastMessage = result.messages[result.messages.length - 1];
+                if (lastMessage && lastMessage.content) {
+                    if (typeof lastMessage.content === 'string') {
+                        response = lastMessage.content;
+                    }
+                    else if (Array.isArray(lastMessage.content)) {
+                        response = lastMessage.content
+                            .map((part) => part.text || part.value || '')
+                            .join('');
+                    }
+                }
+            }
+            return response;
+        }
+        catch (error) {
+            this.#logger.error('Mentor consultation failed', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    };
+    #createAgent({ model, reasoningEffort, temperature, } = {}) {
+        const resolvedModel = model?.trim() || this.#settings.get('agent.model');
+        this.#model = resolvedModel;
+        const resolvedTemperature = temperature ??
+            this.#settings.get('agent.temperature');
+        const { name, instructions, tools: toolDefinitions, } = getAgentDefinition({
+            settingsService: this.#settings,
+            loggingService: this.#logger,
+            executionContext: this.#executionContext,
+            // @ts-ignore - Definition update coming next
+            askMentor: this.#createMentor,
+        }, resolvedModel);
+        // Determine if we should use the native applyPatchTool
+        const shouldUseNativePatchTool = this.#provider === 'openai' && resolvedModel.startsWith('gpt-5.1');
+        const tools = toolDefinitions
+            .filter(definition => {
+            // Exclude custom apply_patch if we're using native one
+            if (shouldUseNativePatchTool &&
+                definition.name === 'apply_patch') {
+                return false;
+            }
+            return true;
+        })
+            .map(definition => wrapToolInvoke(createTool({
+            name: definition.name,
+            description: definition.description,
+            parameters: definition.parameters,
+            needsApproval: async (context, params) => definition.needsApproval(params, context),
+            execute: async (params, _context, details) => {
+                // Extract tool call ID from details if available
+                const toolCallId = details?.toolCall?.callId;
+                // Check if this execution should be intercepted
+                const rejectionMessage = await this.#checkToolInterceptors(definition.name, params, toolCallId);
+                if (rejectionMessage) {
+                    this.#logger.info('Tool execution intercepted', {
+                        tool: definition.name,
+                        params: JSON.stringify(params).substring(0, 100),
+                    });
+                    // Return a failure response that all tools should understand
+                    return JSON.stringify({
+                        output: [
+                            {
+                                success: false,
+                                error: rejectionMessage,
+                            },
+                        ],
+                    });
+                }
+                // Normal execution
+                return definition.execute(params, _context);
+            },
+        })));
+        // Add native applyPatchTool for gpt-5.1 on OpenAI provider
+        if (shouldUseNativePatchTool) {
+            const nativePatchTool = applyPatchTool({
+                editor: this.#editor,
+                needsApproval: false, // Default to auto-approve for now
+            }); // Type assertion needed as invoke is not in public API
+            // Wrap the native tool's invoke function to apply interceptor check
+            const originalInvoke = nativePatchTool.invoke;
+            if (originalInvoke) {
+                nativePatchTool.invoke = async (runContext, input, details) => {
+                    // Extract tool call ID from details if available
+                    const toolCallId = details?.toolCall?.callId;
+                    // Parse input to get params for logging
+                    const normalizedInput = normalizeToolInput(input);
+                    let params;
+                    try {
+                        params =
+                            typeof input === 'string'
+                                ? JSON.parse(input)
+                                : input;
+                    }
+                    catch {
+                        params = input;
+                    }
+                    const rejectionMessage = await this.#checkToolInterceptors('apply_patch', params, toolCallId);
+                    if (rejectionMessage) {
+                        this.#logger.info('Native tool execution intercepted', {
+                            tool: 'apply_patch',
+                            toolCallId,
+                            params: JSON.stringify(params).substring(0, 100),
+                        });
+                        return JSON.stringify({
+                            output: [
+                                {
+                                    success: false,
+                                    error: rejectionMessage,
+                                },
+                            ],
+                        });
+                    }
+                    return originalInvoke.call(nativePatchTool, runContext, normalizedInput, details);
+                };
+            }
+            tools.push(nativePatchTool);
+            this.#logger.info('Using native applyPatchTool from SDK', {
+                model: resolvedModel,
+                provider: this.#provider,
+            });
+        }
+        else {
+            this.#logger.info('Using custom apply_patch implementation', {
+                model: resolvedModel,
+                provider: this.#provider,
+            });
+        }
+        // Add web search tool. If the user explicitly selected 'minimal' we
+        // disable it; if they selected 'default', we don't influence the
+        // decision and leave the web tool enabled.
+        if (reasoningEffort !== 'minimal') {
+            const webTool = webSearchTool();
+            // Note: webSearchTool is a HostedTool that runs server-side and cannot be intercepted
+            // the same way as FunctionTools. Interception for hosted tools would need to be
+            // handled differently, likely through approval mechanisms.
+            tools.push(webTool);
+        }
+        // Build modelSettings only if an explicit effort value (other than
+        // 'default') was provided. 'default' means we should not pass the
+        // effort param and allow the underlying API to choose the default.
+        const modelSettings = {};
+        if (reasoningEffort && reasoningEffort !== 'default') {
+            modelSettings.reasoning = {
+                effort: reasoningEffort,
+                summary: 'auto',
+            };
+        }
+        // Temperature: only pass when explicitly set (number). Undefined means
+        // provider/model default.
+        if (typeof resolvedTemperature === 'number' &&
+            Number.isFinite(resolvedTemperature)) {
+            modelSettings.temperature = resolvedTemperature;
+        }
+        const agent = new Agent({
+            name,
+            model: resolvedModel,
+            ...(Object.keys(modelSettings).length > 0 ? { modelSettings } : {}),
+            instructions,
+            tools,
+        });
+        // Only add defaultRunOptions if an explicit effort is set (not
+        // 'default'). This ensures the API receives the param only when
+        // intended.
+        if (reasoningEffort && reasoningEffort !== 'default') {
+            agent.defaultRunOptions = {
+                ...(agent.defaultRunOptions || {}),
+                // Pass through to underlying client for models that support it
+                reasoning: { effort: reasoningEffort },
+            };
+        }
+        return agent;
+    }
+}
+//# sourceMappingURL=openai-agent-client.js.map