@qduc/term2 0.1.8 → 0.3.0

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

@@ -1,7 +1,4 @@
-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 { Agent, run, tool as createTool, webSearchTool, applyPatchTool, } from '@openai/agents';
 import { getProvider } from '../providers/index.js';
 import { randomUUID } from 'node:crypto';
 import { getAgentDefinition, getEnvInfo, getAgentsInstructions } from '../agent.js';
@@ -10,6 +7,80 @@ import { createEditorImpl } from './editor-impl.js';
 import { ConversationStore } from '../services/conversation-store.js';
 import { trimToolOutput } from '../utils/trim-tool-output.js';
 import { toOpenAIStrictToolSchema } from './openai-strict-tool-schema.js';
+import { executeWithRetry } from './retry-executor.js';
+import { shouldUseNativePatchTool, shouldUseStrictToolSchema } from './tool-selection-policy.js';
+class MentorSession {
+    #provider = null;
+    #runner = null;
+    #agent = null;
+    #store = null;
+    #previousResponseId = null;
+    get provider() {
+        return this.#provider;
+    }
+    get runner() {
+        return this.#runner;
+    }
+    get agent() {
+        return this.#agent;
+    }
+    get previousResponseId() {
+        return this.#previousResponseId;
+    }
+    reset() {
+        if (this.#store) {
+            this.#store.clear();
+        }
+        this.#previousResponseId = null;
+        this.#store = null;
+        this.#runner = null;
+        this.#provider = null;
+        this.#agent = null;
+    }
+    switchProvider(provider) {
+        if (this.#provider !== provider) {
+            this.#agent = null;
+            this.#store = null;
+            this.#previousResponseId = null;
+            this.#runner = null;
+            this.#provider = provider;
+        }
+    }
+    ensureRunner(provider, createRunner) {
+        if (!this.#runner && provider !== 'openai') {
+            this.#runner = createRunner(provider);
+        }
+        return this.#runner;
+    }
+    ensureAgent(createAgent) {
+        if (!this.#agent) {
+            this.#agent = createAgent();
+            this.#store = new ConversationStore();
+        }
+        return this.#agent;
+    }
+    addUserMessage(message) {
+        this.#store.addUserMessage(message);
+    }
+    getInput(question, supportsConversationChaining) {
+        return supportsConversationChaining ? question : this.#store.getHistory();
+    }
+    getRunOptions(supportsConversationChaining) {
+        return {
+            stream: false,
+            maxTurns: 1,
+            ...(supportsConversationChaining && this.#previousResponseId
+                ? { previousResponseId: this.#previousResponseId }
+                : {}),
+        };
+    }
+    updateFromResult(result) {
+        this.#store.updateFromResult(result);
+        if (result.responseId) {
+            this.#previousResponseId = result.responseId;
+        }
+    }
+}
 /**
  * Minimal adapter that isolates usage of @openai/agents.
  * Swap this module to change the underlying agent provider without touching the UI.
@@ -21,8 +92,6 @@ export class OpenAIAgentClient {
     #reasoningEffort;
     #temperature;
     #provider;
-    #mentorProvider = null;
-    #mentorRunner = null;
     #maxTurns;
     #retryAttempts;
     #currentAbortController = null;
@@ -34,23 +103,15 @@ export class OpenAIAgentClient {
     #settings;
     #executionContext;
     #editor;
-    #mentorAgent = null;
-    #mentorStore = null;
-    #mentorPreviousResponseId = null;
+    #mentorSession;
     #resetMentorState() {
-        if (this.#mentorStore) {
-            this.#mentorStore.clear();
-        }
-        this.#mentorPreviousResponseId = null;
-        this.#mentorStore = null;
-        this.#mentorRunner = null;
-        this.#mentorProvider = null;
-        this.#mentorAgent = null;
+        this.#mentorSession.reset();
     }
     constructor({ model, reasoningEffort, maxTurns, retryAttempts, deps, }) {
         this.#logger = deps.logger;
         this.#settings = deps.settings;
         this.#executionContext = deps.executionContext;
+        this.#mentorSession = new MentorSession();
         this.#editor = createEditorImpl({
             loggingService: this.#logger,
             settingsService: this.#settings,
@@ -63,7 +124,7 @@ export class OpenAIAgentClient {
         this.#retryAttempts = retryAttempts ?? 2;
         this.#agent = this.#createAgent({ model, reasoningEffort });
         this.#runner = this.#createRunner(this.#provider);
-        this.#logger.info('OpenAI Agent Client initialized', {
+        this.#logger.debug('OpenAI Agent Client initialized', {
             model: model || this.#settings.get('agent.model'),
             reasoningEffort: reasoningEffort ?? 'default',
             temperature: this.#temperature,
@@ -137,6 +198,8 @@ export class OpenAIAgentClient {
         return {
             supportsConversationChaining: providerDef?.capabilities?.supportsConversationChaining ?? false,
             supportsTracingControl: providerDef?.capabilities?.supportsTracingControl ?? false,
+            usesStrictToolSchema: providerDef?.capabilities?.usesStrictToolSchema,
+            nativePatchModelPrefixes: providerDef?.capabilities?.nativePatchModelPrefixes,
         };
     }
     #createRunner(providerId) {
@@ -187,7 +250,7 @@ export class OpenAIAgentClient {
             providerDef.clearConversations();
         }
         this.#refreshAgent();
-        this.#logger.info('Conversation and agent refreshed');
+        this.#logger.debug('Conversation and agent refreshed');
     }
     async startStream(userInput, { previousResponseId } = {}) {
         // Abort any previous operation
@@ -203,7 +266,7 @@ export class OpenAIAgentClient {
         this.#logger.setCorrelationId(this.#currentCorrelationId);
         this.#currentAbortController = new AbortController();
         const signal = this.#currentAbortController.signal;
-        this.#logger.info('Agent stream started', {
+        this.#logger.debug('Agent stream started', {
             eventType: 'provider.request.started',
             category: 'provider',
             phase: 'request_start',
@@ -213,6 +276,7 @@ export class OpenAIAgentClient {
             inputType: Array.isArray(userInput) ? 'array' : typeof userInput,
             inputLength: typeof userInput === 'string' ? userInput.length : undefined,
             inputItems: Array.isArray(userInput) ? userInput.length : undefined,
+            messages: Array.isArray(userInput) ? userInput : undefined,
             hasPreviousResponseId: !!previousResponseId,
         });
         try {
@@ -286,9 +350,7 @@ export class OpenAIAgentClient {
             const providerDef = getProvider(providerId);
             const providerLabel = providerDef?.label || providerId;
             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`);
+                `Please check that all required credentials and provider settings are set.`);
         }
         // Use runner if available (custom provider), otherwise use run() directly (OpenAI)
         if (runner) {
@@ -300,82 +362,29 @@ export class OpenAIAgentClient {
         return this.#runAgentWithProvider(this.#provider, this.#runner, agent, input, options);
     }
     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', {
-                    eventType: 'retry.upstream',
-                    category: 'retry',
-                    phase: 'retry',
-                    traceId: this.#currentCorrelationId,
-                    provider: this.#provider,
-                    model: this.#model,
-                    retryType: 'upstream',
-                    retryAttempt: attemptIndex + 1,
-                    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;
-        }
+        return executeWithRetry({
+            operation,
+            retryAttempts: retries,
+            provider: this.#provider,
+            model: this.#model,
+            traceId: this.#currentCorrelationId,
+            logger: this.#logger,
+            onRetry: this.#retryCallback ?? undefined,
+        });
     }
     async chat(message, options = {}) {
+        const tempProvider = options.provider || this.#provider;
         this.#logger.debug('Agent chat request', {
             messageLength: message.length,
             model: options.model || this.#model,
+            provider: tempProvider,
         });
         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 tempModel = options.model || this.#model;
+            const tempEffort = options.reasoningEffort || this.#reasoningEffort;
+            if (options.model || options.reasoningEffort || options.instructions || options.provider) {
                 const modelSettings = {};
                 if (tempEffort && tempEffort !== 'default') {
                     modelSettings.reasoning = {
@@ -384,49 +393,24 @@ export class OpenAIAgentClient {
                     };
                 }
                 // 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',
+                    name: 'Chat',
                     model: tempModel,
                     ...(Object.keys(modelSettings).length > 0 ? { modelSettings } : {}),
-                    instructions: options.instructions || 'You are a helpful mentor assistant.',
+                    instructions: options.instructions || 'You are a helpful 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.
-                    }
-                }
+            }
+            // If provider is different from main provider, we need a separate runner
+            let runnerForChat = this.#runner;
+            if (tempProvider !== this.#provider) {
+                runnerForChat = this.#createRunner(tempProvider);
             }
             // We use a simplified run flow for chat
-            const result = await this.#runAgent(agentForChat, message, {
+            const result = await this.#runAgentWithProvider(tempProvider, runnerForChat, 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 '';
+            return this.#extractResponse(result);
         }
         catch (error) {
             this.#logger.error('Agent chat failed', {
@@ -435,6 +419,24 @@ export class OpenAIAgentClient {
             throw error; // Propagate error
         }
     }
+    #extractResponse(result) {
+        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 '';
+    }
     #createMentor = async (question) => {
         const mentorModel = this.#settings.get('agent.mentorModel');
         if (!mentorModel) {
@@ -459,18 +461,9 @@ export class OpenAIAgentClient {
         const agentsInstructions = this.#executionContext?.isRemote() ? '' : getAgentsInstructions(cwd);
         const instructions = `${baseInstructions}\n\nEnvironment: ${envInfo}${agentsInstructions}`;
         // If mentor provider changed, reset mentor state to avoid mixing stores/prev ids across providers
-        if (this.#mentorProvider !== mentorProvider) {
-            this.#mentorAgent = null;
-            this.#mentorStore = null;
-            this.#mentorPreviousResponseId = null;
-            this.#mentorRunner = null;
-            this.#mentorProvider = mentorProvider;
-        }
-        // Initialize mentor runner/agent and conversation store if needed
-        if (!this.#mentorRunner && mentorProvider !== 'openai') {
-            this.#mentorRunner = this.#createRunner(mentorProvider);
-        }
-        if (!this.#mentorAgent) {
+        this.#mentorSession.switchProvider(mentorProvider);
+        const mentorRunner = this.#mentorSession.ensureRunner(mentorProvider, (providerId) => this.#createRunner(providerId));
+        const mentorAgent = this.#mentorSession.ensureAgent(() => {
             const reasoningEffort = this.#settings.get('agent.mentorReasoningEffort');
             const modelSettings = {};
             if (reasoningEffort && reasoningEffort !== 'default') {
@@ -479,52 +472,25 @@ export class OpenAIAgentClient {
                     summary: 'auto',
                 };
             }
-            this.#mentorAgent = new Agent({
+            return 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);
+            this.#mentorSession.addUserMessage(question);
             // Determine input based on provider
             // OpenAI uses previousResponseId for server-side history
             // Others need full conversation history from store
             const { supportsConversationChaining } = this.#getProviderCapabilities(mentorProvider);
-            const input = supportsConversationChaining ? question : this.#mentorStore.getHistory();
-            const result = await this.#runAgentWithProvider(mentorProvider, this.#mentorRunner, this.#mentorAgent, input, {
-                stream: false,
-                maxTurns: 1,
-                ...(supportsConversationChaining && this.#mentorPreviousResponseId
-                    ? { previousResponseId: this.#mentorPreviousResponseId }
-                    : {}),
-            });
+            const input = this.#mentorSession.getInput(question, supportsConversationChaining);
+            const result = await this.#runAgentWithProvider(mentorProvider, mentorRunner, mentorAgent, input, this.#mentorSession.getRunOptions(supportsConversationChaining));
             // Update conversation store with result
-            this.#mentorStore.updateFromResult(result);
-            // Track previousResponseId when provided by the provider.
-            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;
+            this.#mentorSession.updateFromResult(result);
+            return this.#extractResponse(result);
         }
         catch (error) {
             this.#logger.error('Mentor consultation failed', {
@@ -544,8 +510,47 @@ export class OpenAIAgentClient {
             // @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 providerCapabilities = this.#getProviderCapabilities(this.#provider);
+        const shouldUseNativePatchToolForModel = shouldUseNativePatchTool({
+            providerId: this.#provider,
+            model: resolvedModel,
+            capabilities: providerCapabilities,
+        });
+        const tools = this.#buildAgentTools({
+            toolDefinitions,
+            resolvedModel,
+            reasoningEffort,
+            shouldUseNativePatchTool: shouldUseNativePatchToolForModel,
+        });
+        const modelSettings = this.#buildModelSettings({
+            reasoningEffort,
+            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;
+    }
+    #buildAgentTools({ toolDefinitions, resolvedModel, reasoningEffort, shouldUseNativePatchTool, }) {
+        const providerCapabilities = this.#getProviderCapabilities(this.#provider);
+        const useStrictToolSchema = shouldUseStrictToolSchema({
+            providerId: this.#provider,
+            capabilities: providerCapabilities,
+        });
         const tools = toolDefinitions
             .filter((definition) => {
             // Exclude custom apply_patch if we're using native one
@@ -557,7 +562,7 @@ export class OpenAIAgentClient {
             .map((definition) => wrapToolInvoke(createTool({
             name: definition.name,
             description: definition.description,
-            parameters: this.#provider === 'openai' ? toOpenAIStrictToolSchema(definition.parameters) : definition.parameters,
+            parameters: useStrictToolSchema ? toOpenAIStrictToolSchema(definition.parameters) : definition.parameters,
             needsApproval: async (context, params) => definition.needsApproval(params, context),
             execute: async (params, _context, details) => {
                 const maxOutputLengthValue = this.#settings.get('shell.maxOutputChars');
@@ -566,7 +571,7 @@ export class OpenAIAgentClient {
                 // Check if this execution should be intercepted
                 const rejectionMessage = await this.#checkToolInterceptors(definition.name, params, toolCallId);
                 if (rejectionMessage) {
-                    this.#logger.info('Tool execution intercepted', {
+                    this.#logger.debug('Tool execution intercepted', {
                         tool: definition.name,
                         params: JSON.stringify(params).substring(0, 100),
                     });
@@ -609,7 +614,7 @@ export class OpenAIAgentClient {
                     }
                     const rejectionMessage = await this.#checkToolInterceptors('apply_patch', params, toolCallId);
                     if (rejectionMessage) {
-                        this.#logger.info('Native tool execution intercepted', {
+                        this.#logger.debug('Native tool execution intercepted', {
                             tool: 'apply_patch',
                             toolCallId,
                             params: JSON.stringify(params).substring(0, 100),
@@ -631,13 +636,13 @@ export class OpenAIAgentClient {
                 };
             }
             tools.push(nativePatchTool);
-            this.#logger.info('Using native applyPatchTool from SDK', {
+            this.#logger.debug('Using native applyPatchTool from SDK', {
                 model: resolvedModel,
                 provider: this.#provider,
             });
         }
         else {
-            this.#logger.info('Using custom apply_patch implementation', {
+            this.#logger.debug('Using custom apply_patch implementation', {
                 model: resolvedModel,
                 provider: this.#provider,
             });
@@ -652,6 +657,9 @@ export class OpenAIAgentClient {
             // handled differently, likely through approval mechanisms.
             tools.push(webTool);
         }
+        return tools;
+    }
+    #buildModelSettings({ reasoningEffort, resolvedTemperature, }) {
         // 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.
@@ -677,24 +685,10 @@ export class OpenAIAgentClient {
                 service_tier: 'flex',
             };
         }
-        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;
+        return modelSettings;
+    }
+    getSettings() {
+        return this.#settings;
     }
 }
 //# sourceMappingURL=openai-agent-client.js.map