@qduc/term2 0.7.2 → 0.8.0

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

@@ -1,57 +1,12 @@
-import { Agent, run, tool as createTool, applyPatchTool, } from '@openai/agents';
+import { Agent, run, } from '@openai/agents';
+import { buildAgent } from './agent-factory.js';
 import { getProvider } from '../providers/index.js';
 import { randomUUID } from 'node:crypto';
-import { getAgentDefinition } from '../agent.js';
-import { normalizeToolInput, wrapToolInvoke } from './tool-invoke.js';
 import { createEditorImpl } from './editor-impl.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';
 import { isFlexServiceTierTimeout } from '../utils/flex-service-tier.js';
 import { SubagentManager } from '../services/subagents/subagent-manager.js';
 import { fetchModels, getModelDefaultReasoningLevel } from '../services/model-service.js';
-import { ToolExecutionLimiter } from './tool-execution-limiter.js';
-/**
- * Wraps a tool definition's needsApproval so that structurally invalid params
- * (those that fail Zod schema validation) never trigger an approval prompt.
- * The tool's execute will receive those params and return a structured error.
- *
- * Top-level null values are normalized to undefined before validation. When using
- * OpenAI strict tool schemas, toOpenAIStrictToolSchema converts optional fields to
- * nullable-with-null-default, so the API sends null for omitted optional fields.
- * The original Zod schema uses .optional() which rejects null, so without this
- * normalization valid strict-schema calls would incorrectly bypass approval.
- */
-export function wrapNeedsApproval(definition, options) {
-    return async (context, params) => {
-        if (options?.checkInterceptors) {
-            try {
-                const rejectionMessage = await options.checkInterceptors(params);
-                if (rejectionMessage) {
-                    return false;
-                }
-            }
-            catch {
-                // If the interceptor check throws, fall through to normal approval
-                // logic rather than silently skipping the prompt.
-            }
-        }
-        const normalized = params !== null && typeof params === 'object' && !Array.isArray(params)
-            ? Object.fromEntries(Object.entries(params).map(([k, v]) => [k, v === null ? undefined : v]))
-            : params;
-        if (!definition.parameters.safeParse(normalized).success) {
-            return false;
-        }
-        try {
-            return await definition.needsApproval(normalized, context);
-        }
-        catch (error) {
-            // If needsApproval throws, fail-safe to requiring approval
-            return true;
-        }
-    };
-}
+import { filterChainedModelInput } from './chained-input-filter.js';
 /**
  * Minimal adapter that isolates usage of @openai/agents.
  * Swap this module to change the underlying agent provider without touching the UI.
@@ -65,21 +20,74 @@ export class OpenAIAgentClient {
     #provider;
     #maxTurns;
     #retryAttempts;
+    #retryCallback = null;
     #currentAbortController = null;
     #currentCorrelationId = null;
-    #retryCallback = null;
     #runner = null;
-    #toolExecutionLimiter;
     #serviceTierOverrideForNextRequest = null;
     #toolInterceptors = [];
     #logger;
     #settings;
+    #sessionContextService;
     #executionContext;
     #editor;
-    #subagentManager;
+    #subagentManager = null;
+    #isTransientClient = false;
     #subagentEventSink = null;
     #activeSubagentsCount = 0;
     #pendingClearSink = false;
+    #askUserAnswers = new Map();
+    #lastChainedDeltaInputItems = null;
+    #onDowngradeCallback;
+    /**
+     * Registers a callback that will be triggered when the provider transport downgrades to HTTP.
+     * If the current runner is already downgraded, the callback is invoked immediately.
+     */
+    onDowngrade(callback) {
+        this.#onDowngradeCallback = callback;
+        if (this.#runner) {
+            this.#applyDowngradeCallbackToRunner(this.#runner);
+        }
+    }
+    #applyDowngradeCallbackToRunner(runner) {
+        if (!runner)
+            return;
+        const provider = runner.config?.modelProvider;
+        const fallbackState = provider?.fallbackState;
+        if (fallbackState) {
+            if (fallbackState.isDowngraded) {
+                this.#onDowngradeCallback?.();
+            }
+            else {
+                fallbackState.onDowngrade = () => {
+                    this.#onDowngradeCallback?.();
+                };
+            }
+        }
+    }
+    /**
+     * Returns the FallbackState from the current provider's model, if available.
+     * This allows the session to react when the WS transport degrades to HTTP.
+     */
+    getFallbackState() {
+        const runner = this.#runner;
+        if (!runner)
+            return null;
+        const provider = runner.config?.modelProvider;
+        return provider?.fallbackState ?? null;
+    }
+    /**
+     * Force the current fallback-capable provider onto HTTP transport.
+     * Returns false when the active provider has no fallback transport or is already downgraded.
+     */
+    forceTransportDowngrade(error) {
+        const fallbackState = this.getFallbackState();
+        if (!fallbackState || fallbackState.isDowngraded || typeof fallbackState.forceDowngrade !== 'function') {
+            return false;
+        }
+        fallbackState.forceDowngrade(error);
+        return fallbackState.isDowngraded;
+    }
     /**
      * Forward real-time subagent activity events to the active conversation
      * turn. The session sets this for the duration of a send and clears it
@@ -95,115 +103,154 @@ export class OpenAIAgentClient {
         }
     }
     #resetMentorState() {
-        this.#subagentManager.resetMentorSession();
+        if (this.#subagentManager) {
+            this.#subagentManager.resetMentorSession();
+        }
     }
-    constructor({ model, reasoningEffort, maxTurns, retryAttempts, deps, }) {
+    constructor({ model, reasoningEffort, maxTurns, retryAttempts, agentOverride, providerOverride, deps, }) {
         this.#logger = deps.logger;
         this.#settings = deps.settings;
+        this.#sessionContextService = deps.sessionContextService;
         this.#executionContext = deps.executionContext;
-        this.#subagentManager = new SubagentManager({
-            logger: deps.logger,
-            settings: deps.settings,
-            executionContext: deps.executionContext,
-            onEvent: (event) => this.#subagentEventSink?.(event),
-            agentClient: { chat: (message, options) => this.chat(message, options) },
-        });
         this.#editor = createEditorImpl({
             loggingService: this.#logger,
             settingsService: this.#settings,
             executionContext: this.#executionContext,
         });
-        this.#toolExecutionLimiter = new ToolExecutionLimiter(() => this.#getMaxParallelToolCalls());
         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 });
+        if (agentOverride) {
+            this.#isTransientClient = true;
+            this.#agent = agentOverride;
+            this.#model = model ?? agentOverride.model ?? '';
+            this.#maxTurns = maxTurns ?? 1;
+            this.#retryAttempts = retryAttempts ?? 2;
+        }
+        else {
+            const buildResult = buildAgent({ model, reasoningEffort }, this.#buildFactoryDeps());
+            this.#agent = buildResult.agent;
+            this.#model = buildResult.resolvedModel;
+            this.#maxTurns = maxTurns ?? 20;
+            this.#retryAttempts = retryAttempts ?? 2;
+        }
+        this.#provider = providerOverride ?? this.#settings.get('agent.provider') ?? 'openai';
         this.#runner = null;
-        // Subscribe to settings changes that affect agent definition (prompt,
-        // tools, model, provider, modes) and rebuild the agent automatically.
-        this.#settings.onChange?.((changedKey) => {
-            if (!changedKey)
-                return;
-            // Keys that require a full agent rebuild:
-            const rebuildKeys = [
-                'app.liteMode',
-                'app.orchestratorMode',
-                'app.planMode',
-                'app.mentorMode',
-                'app.searchViaShell',
-                'agent.model',
-                'agent.provider',
-                'agent.reasoningEffort',
-                'agent.temperature',
-                'agent.useFlexServiceTier',
-                'agent.mentorModel',
-                'agent.mentorProvider',
-                'agent.mentorReasoningEffort',
-                'agent.subagentExplorerModel',
-                'agent.subagentWorkerModel',
-                'agent.subagentResearcherModel',
-                'agent.subagentExplorerProvider',
-                'agent.subagentWorkerProvider',
-                'agent.subagentResearcherProvider',
-                'agent.subagentExplorerReasoningEffort',
-                'agent.subagentWorkerReasoningEffort',
-                'agent.subagentResearcherReasoningEffort',
-                'logging.logLevel',
-                'logging.suppressConsoleOutput',
-                'shell.useRtkCompression',
-            ];
-            if (rebuildKeys.includes(changedKey)) {
-                this.#refreshAgent();
-            }
-            if (changedKey === 'agent.maxParallelToolCalls') {
-                this.#toolExecutionLimiter.notifyLimitChanged();
-            }
-        });
-        this.#logger.debug('OpenAI Agent Client initialized', {
-            model: model || this.#settings.get('agent.model'),
-            reasoningEffort: reasoningEffort ?? 'default',
-            temperature: this.#temperature,
-            maxTurns: this.#maxTurns,
-            retryAttempts: this.#retryAttempts,
-        });
+        if (!agentOverride) {
+            this.#subagentManager = new SubagentManager({
+                logger: deps.logger,
+                settings: deps.settings,
+                executionContext: deps.executionContext,
+                sessionContextService: this.#sessionContextService,
+                onEvent: (event) => this.#subagentEventSink?.(event),
+                agentClient: { chat: (message, options) => this.chat(message, options) },
+                // Factory lives here (not in SubagentManager) so each subagent gets a
+                // lightweight transient client that shares logger/settings/executionContext
+                // with the parent but skips agent-rebuild and SubagentManager initialisation.
+                createClient: ({ agent, provider, maxTurns, retryAttempts, }) => new OpenAIAgentClient({
+                    model: agent.model,
+                    maxTurns,
+                    retryAttempts,
+                    deps: {
+                        logger: deps.logger,
+                        settings: deps.settings,
+                        executionContext: deps.executionContext,
+                        sessionContextService: this.#sessionContextService,
+                    },
+                    agentOverride: agent,
+                    providerOverride: provider,
+                }),
+            });
+        }
+        if (!agentOverride) {
+            // Subscribe to settings changes that affect agent definition (prompt,
+            // tools, model, provider, modes) and rebuild the agent automatically.
+            this.#settings.onChange?.((changedKey) => {
+                if (!changedKey)
+                    return;
+                // Keys that require a full agent rebuild:
+                const rebuildKeys = [
+                    'app.liteMode',
+                    'app.orchestratorMode',
+                    'app.planMode',
+                    'app.mentorMode',
+                    'app.searchViaShell',
+                    'agent.model',
+                    'agent.provider',
+                    'agent.reasoningEffort',
+                    'agent.temperature',
+                    'agent.useFlexServiceTier',
+                    'agent.mentorModel',
+                    'agent.mentorProvider',
+                    'agent.mentorReasoningEffort',
+                    'agent.subagentExplorerModel',
+                    'agent.subagentWorkerModel',
+                    'agent.subagentResearcherModel',
+                    'agent.subagentExplorerProvider',
+                    'agent.subagentWorkerProvider',
+                    'agent.subagentResearcherProvider',
+                    'agent.subagentExplorerReasoningEffort',
+                    'agent.subagentWorkerReasoningEffort',
+                    'agent.subagentResearcherReasoningEffort',
+                    'logging.logLevel',
+                    'logging.suppressConsoleOutput',
+                    'shell.useRtkCompression',
+                ];
+                if (rebuildKeys.includes(changedKey)) {
+                    this.#refreshAgent();
+                }
+            });
+            this.#logger.debug('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,
-        });
+        const buildResult = buildAgent({ model, reasoningEffort: this.#reasoningEffort }, this.#buildFactoryDeps());
+        this.#agent = buildResult.agent;
+        this.#model = buildResult.resolvedModel;
         this.#resetMentorState();
     }
     setReasoningEffort(effort) {
         this.#reasoningEffort = effort;
-        this.#agent = this.#createAgent({
-            model: this.#model,
-            reasoningEffort: effort,
-        });
+        const buildResult = buildAgent({ model: this.#model, reasoningEffort: effort }, this.#buildFactoryDeps());
+        this.#agent = buildResult.agent;
+        this.#model = buildResult.resolvedModel;
     }
     setTemperature(temperature) {
         this.#temperature = temperature;
-        this.#agent = this.#createAgent({
-            model: this.#model,
-            reasoningEffort: this.#reasoningEffort,
-            temperature,
-        });
+        const buildResult = buildAgent({ model: this.#model, reasoningEffort: this.#reasoningEffort, temperature }, this.#buildFactoryDeps());
+        this.#agent = buildResult.agent;
+        this.#model = buildResult.resolvedModel;
     }
     setProvider(provider) {
         this.#provider = provider;
         this.#settings.set('agent.provider', provider);
-        this.#agent = this.#createAgent({
-            model: this.#model,
-            reasoningEffort: this.#reasoningEffort,
-        });
+        const buildResult = buildAgent({ model: this.#model, reasoningEffort: this.#reasoningEffort }, this.#buildFactoryDeps());
+        this.#agent = buildResult.agent;
+        this.#model = buildResult.resolvedModel;
         this.#runner = null;
         this.#resetMentorState();
     }
     getProvider() {
         return this.#provider;
     }
+    getStreamMaxRetries() {
+        return this.#settings.get('agent.streamMaxRetries');
+    }
+    setAskUserAnswer(callId, answer) {
+        this.#askUserAnswers.set(callId, answer);
+    }
+    getAskUserAnswer(callId) {
+        if (!callId)
+            return undefined;
+        const answer = this.#askUserAnswers.get(callId);
+        this.#askUserAnswers.delete(callId);
+        return answer;
+    }
     addToolInterceptor(interceptor) {
         this.#toolInterceptors.push(interceptor);
         return () => {
@@ -231,6 +278,20 @@ export class OpenAIAgentClient {
         }
         return null;
     }
+    #buildFactoryDeps() {
+        return {
+            settings: this.#settings,
+            logger: this.#logger,
+            executionContext: this.#executionContext,
+            editor: this.#editor,
+            providerId: this.#provider,
+            serviceTierOverrideForNextRequest: this.#serviceTierOverrideForNextRequest,
+            createMentor: this.#createMentor,
+            runSubagent: this.#runSubagent,
+            getAskUserAnswer: (callId) => this.getAskUserAnswer(callId),
+            checkToolInterceptors: (name, params, toolCallId) => this.#checkToolInterceptors(name, params, toolCallId),
+        };
+    }
     #getMaxParallelToolCalls() {
         const rawValue = this.#settings.get('agent.maxParallelToolCalls');
         const numericValue = Number(rawValue);
@@ -239,15 +300,6 @@ export class OpenAIAgentClient {
         }
         return Math.max(1, Math.floor(numericValue));
     }
-    #getProviderCapabilities(providerId) {
-        const providerDef = getProvider(providerId);
-        return {
-            supportsConversationChaining: providerDef?.capabilities?.supportsConversationChaining ?? false,
-            supportsTracingControl: providerDef?.capabilities?.supportsTracingControl ?? false,
-            usesStrictToolSchema: providerDef?.capabilities?.usesStrictToolSchema,
-            nativePatchModelPrefixes: providerDef?.capabilities?.nativePatchModelPrefixes,
-        };
-    }
     #createRunner(providerId) {
         const providerDef = getProvider(providerId);
         if (!providerDef?.createRunner) {
@@ -256,16 +308,21 @@ export class OpenAIAgentClient {
         return providerDef.createRunner({
             settingsService: this.#settings,
             loggingService: this.#logger,
+            sessionContextService: this.#sessionContextService,
+            onRetry: () => this.#retryCallback?.(),
         });
     }
     #getOrCreateRunner(providerId) {
         if (providerId !== this.#provider) {
-            return this.#createRunner(providerId);
+            const runner = this.#createRunner(providerId);
+            this.#applyDowngradeCallbackToRunner(runner);
+            return runner;
         }
         if (this.#runner) {
             return this.#runner;
         }
         this.#runner = this.#createRunner(providerId);
+        this.#applyDowngradeCallbackToRunner(this.#runner);
         return this.#runner;
     }
     setRetryCallback(callback) {
@@ -283,11 +340,11 @@ export class OpenAIAgentClient {
         this.#refreshAgent();
     }
     #refreshAgent() {
-        this.#agent = this.#createAgent({
-            model: this.#model,
-            reasoningEffort: this.#reasoningEffort,
-            temperature: this.#temperature,
-        });
+        if (this.#isTransientClient)
+            return;
+        const buildResult = buildAgent({ model: this.#model, reasoningEffort: this.#reasoningEffort, temperature: this.#temperature }, this.#buildFactoryDeps());
+        this.#agent = buildResult.agent;
+        this.#model = buildResult.resolvedModel;
         // Refreshing core agent should not keep stale mentor state/instructions.
         this.#resetMentorState();
     }
@@ -317,9 +374,33 @@ export class OpenAIAgentClient {
             providerDef.clearConversations();
         }
         this.#refreshAgent();
+        this.#lastChainedDeltaInputItems = null;
         this.#logger.debug('Conversation and agent refreshed');
     }
-    async startStream(userInput, { previousResponseId, sessionId } = {}) {
+    #filterAndGuardChainedModelInput(modelData, options = {}) {
+        const filtered = filterChainedModelInput(modelData, options);
+        const input = filtered?.input;
+        if (!Array.isArray(input)) {
+            return filtered;
+        }
+        const previousInputItems = this.#lastChainedDeltaInputItems;
+        const inputItems = input.length;
+        if (previousInputItems !== null && inputItems - previousInputItems >= 10 && inputItems >= previousInputItems * 3) {
+            this.#logger.warn('Chained delta input item count spiked', {
+                eventType: 'provider.chained_delta_input_spike',
+                category: 'provider',
+                phase: 'request_start',
+                traceId: this.#logger.getCorrelationId(),
+                provider: this.#provider,
+                model: this.#model,
+                previousInputItems,
+                inputItems,
+            });
+        }
+        this.#lastChainedDeltaInputItems = inputItems;
+        return filtered;
+    }
+    async startStream(userInput, { previousResponseId, sessionId, toolResultCallIds } = {}) {
         // Abort any previous operation
         this.abort();
         let agentRefreshed = false;
@@ -359,17 +440,37 @@ export class OpenAIAgentClient {
             hasPreviousResponseId: !!previousResponseId,
         });
         try {
+            const userContext = {
+                turnCount: 0,
+                maxTurns: this.#maxTurns,
+            };
+            const supportsConversationChaining = getProvider(this.#provider)?.capabilities?.supportsConversationChaining ?? false;
             const options = {
                 stream: true,
                 maxTurns: this.#maxTurns,
                 signal,
+                context: userContext,
+                toolExecution: { maxFunctionToolConcurrency: this.#getMaxParallelToolCalls() },
+                callModelInputFilter: (args) => {
+                    if (args.context) {
+                        args.context.turnCount = (args.context.turnCount ?? 0) + 1;
+                    }
+                    // When WS has degraded to HTTP, server-managed chaining is unavailable;
+                    // return unfiltered input so the full history reaches the model.
+                    const currentFallback = this.getFallbackState();
+                    const chainingActive = supportsConversationChaining && previousResponseId && !currentFallback?.isDowngraded;
+                    return chainingActive
+                        ? this.#filterAndGuardChainedModelInput(args.modelData, { toolResultCallIds })
+                        : args.modelData;
+                },
             };
             const agentForRun = this.#getAgentForRun(this.#agent, { sessionId });
-            const { supportsConversationChaining } = this.#getProviderCapabilities(this.#provider);
-            if (supportsConversationChaining && previousResponseId) {
+            // Only set previousResponseId when chaining is still active (not degraded).
+            const currentFallback = this.getFallbackState();
+            if (supportsConversationChaining && previousResponseId && !currentFallback?.isDowngraded) {
                 options.previousResponseId = previousResponseId;
             }
-            const result = await this.#executeWithRetry(() => this.#runAgent(agentForRun, userInput, options));
+            const result = await this.#runAgent(agentForRun, userInput, options);
             return result;
         }
         catch (error) {
@@ -389,42 +490,102 @@ export class OpenAIAgentClient {
             throw error;
         }
     }
-    async continueRun(state, { previousResponseId, sessionId } = {}) {
+    async continueRun(state, { previousResponseId, sessionId, toolResultCallIds } = {}) {
         this.abort();
         this.#currentAbortController = new AbortController();
         const signal = this.#currentAbortController.signal;
+        let userContext;
+        if (state && state._context) {
+            userContext = state._context.context;
+            if (!userContext) {
+                userContext = {};
+                state._context.context = userContext;
+            }
+        }
+        else {
+            userContext = {
+                turnCount: 0,
+            };
+        }
+        userContext.maxTurns = this.#maxTurns;
+        if (typeof userContext.turnCount !== 'number') {
+            userContext.turnCount = 0;
+        }
+        const supportsConversationChaining = getProvider(this.#provider)?.capabilities?.supportsConversationChaining ?? false;
         const options = {
             signal,
+            context: userContext,
+            toolExecution: { maxFunctionToolConcurrency: this.#getMaxParallelToolCalls() },
+            callModelInputFilter: (args) => {
+                if (args.context) {
+                    args.context.turnCount = (args.context.turnCount ?? 0) + 1;
+                }
+                const currentFallback = this.getFallbackState();
+                const chainingActive = supportsConversationChaining && previousResponseId && !currentFallback?.isDowngraded;
+                return chainingActive
+                    ? this.#filterAndGuardChainedModelInput(args.modelData, { toolResultCallIds })
+                    : args.modelData;
+            },
         };
         const agentForRun = this.#getAgentForRun(this.#agent, { sessionId });
-        const { supportsConversationChaining } = this.#getProviderCapabilities(this.#provider);
-        if (supportsConversationChaining && previousResponseId) {
+        const currentFallback = this.getFallbackState();
+        if (supportsConversationChaining && previousResponseId && !currentFallback?.isDowngraded) {
             options.previousResponseId = previousResponseId;
         }
-        return this.#executeWithRetry(() => this.#runAgent(agentForRun, state, options));
+        return this.#runAgent(agentForRun, state, options);
     }
-    async continueRunStream(state, { previousResponseId, sessionId } = {}) {
+    async continueRunStream(state, { previousResponseId, sessionId, toolResultCallIds } = {}) {
         this.abort();
         this.#currentAbortController = new AbortController();
         const signal = this.#currentAbortController.signal;
+        let userContext;
+        if (state && state._context) {
+            userContext = state._context.context;
+            if (!userContext) {
+                userContext = {};
+                state._context.context = userContext;
+            }
+        }
+        else {
+            userContext = {
+                turnCount: 0,
+            };
+        }
+        userContext.maxTurns = this.#maxTurns;
+        if (typeof userContext.turnCount !== 'number') {
+            userContext.turnCount = 0;
+        }
+        const supportsConversationChaining = getProvider(this.#provider)?.capabilities?.supportsConversationChaining ?? false;
         const options = {
             stream: true,
             maxTurns: this.#maxTurns,
             signal,
+            context: userContext,
+            toolExecution: { maxFunctionToolConcurrency: this.#getMaxParallelToolCalls() },
+            callModelInputFilter: (args) => {
+                if (args.context) {
+                    args.context.turnCount = (args.context.turnCount ?? 0) + 1;
+                }
+                const currentFallback = this.getFallbackState();
+                const chainingActive = supportsConversationChaining && previousResponseId && !currentFallback?.isDowngraded;
+                return chainingActive
+                    ? this.#filterAndGuardChainedModelInput(args.modelData, { toolResultCallIds })
+                    : args.modelData;
+            },
         };
         const agentForRun = this.#getAgentForRun(this.#agent, { sessionId });
-        const { supportsConversationChaining } = this.#getProviderCapabilities(this.#provider);
-        if (supportsConversationChaining && previousResponseId) {
+        const currentFallback = this.getFallbackState();
+        if (supportsConversationChaining && previousResponseId && !currentFallback?.isDowngraded) {
             options.previousResponseId = previousResponseId;
         }
-        return this.#executeWithRetry(() => this.#runAgent(agentForRun, state, options));
+        return this.#runAgent(agentForRun, state, options);
     }
     #runAgentWithProvider(providerId, runner, 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 } : {};
-        const { supportsTracingControl } = this.#getProviderCapabilities(providerId);
+        const supportsTracingControl = getProvider(providerId)?.capabilities?.supportsTracingControl ?? false;
         if (!supportsTracingControl) {
             effectiveOptions.tracingDisabled = true;
         }
@@ -453,17 +614,6 @@ export class OpenAIAgentClient {
             }
         }
     }
-    async #executeWithRetry(operation, retries = this.#retryAttempts) {
-        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', {
@@ -487,7 +637,9 @@ export class OpenAIAgentClient {
             const tempModel = options.model || this.#model;
             const tempEffort = options.reasoningEffort || this.#reasoningEffort;
             if (options.model || options.reasoningEffort || options.instructions || options.provider) {
-                const modelSettings = {};
+                const modelSettings = {
+                    retry: { maxRetries: 0 },
+                };
                 let effectiveEffort = tempEffort;
                 if (tempProvider === 'codex' && isDefaultSetting && (!effectiveEffort || effectiveEffort === 'default')) {
                     const defaultReasoningLevel = getModelDefaultReasoningLevel('codex', tempModel);
@@ -546,7 +698,9 @@ export class OpenAIAgentClient {
         try {
             const tempModel = options.model || this.#model;
             const tempEffort = options.reasoningEffort || this.#reasoningEffort;
-            const modelSettings = {};
+            const modelSettings = {
+                retry: { maxRetries: 0 },
+            };
             let effectiveEffort = tempEffort;
             if (tempProvider === 'codex' && isDefaultSetting && (!effectiveEffort || effectiveEffort === 'default')) {
                 const defaultReasoningLevel = getModelDefaultReasoningLevel('codex', tempModel);
@@ -601,7 +755,8 @@ export class OpenAIAgentClient {
         return '';
     }
     #getAgentForRun(agent, { sessionId } = {}) {
-        if (this.#provider !== 'codex' || !sessionId) {
+        const supportsPromptCacheKey = getProvider(this.#provider)?.capabilities?.supportsPromptCacheKey;
+        if (!supportsPromptCacheKey || !sessionId) {
             return agent;
         }
         return agent.clone({
@@ -612,6 +767,9 @@ export class OpenAIAgentClient {
         });
     }
     #createMentor = async (question) => {
+        if (!this.#subagentManager) {
+            throw new Error('Transient agent clients cannot spawn subagents.');
+        }
         this.#activeSubagentsCount++;
         try {
             const result = await this.#subagentManager.run({ role: 'mentor', task: question, parentTool: 'ask_mentor' });
@@ -636,6 +794,9 @@ export class OpenAIAgentClient {
         }
     };
     #runSubagent = async (params, _context, details) => {
+        if (!this.#subagentManager) {
+            throw new Error('Transient agent clients cannot spawn subagents.');
+        }
         // Forward any resumeState from the SDK (populated in the Agent.asTool
         // path) to the subagent manager so it can restore the agent run state
         // for nested approval continuation.
@@ -664,258 +825,8 @@ export class OpenAIAgentClient {
             }
         }
     };
-    #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,
-            askMentor: this.#createMentor,
-            runSubagent: this.#runSubagent,
-        }, resolvedModel);
-        const providerCapabilities = this.#getProviderCapabilities(this.#provider);
-        const shouldUseNativePatchToolForModel = shouldUseNativePatchTool({
-            providerId: this.#provider,
-            model: resolvedModel,
-            capabilities: providerCapabilities,
-        });
-        const tools = this.#buildAgentTools({
-            toolDefinitions,
-            resolvedModel,
-            shouldUseNativePatchTool: shouldUseNativePatchToolForModel,
-        });
-        let effectiveReasoningEffort = reasoningEffort;
-        const isDefaultSetting = this.#settings.get('agent.reasoningEffort') === 'default';
-        if (this.#provider === 'codex' &&
-            isDefaultSetting &&
-            (!effectiveReasoningEffort || effectiveReasoningEffort === 'default')) {
-            const defaultReasoningLevel = getModelDefaultReasoningLevel('codex', resolvedModel);
-            if (defaultReasoningLevel) {
-                effectiveReasoningEffort = defaultReasoningLevel;
-            }
-        }
-        const modelSettings = this.#buildModelSettings({
-            reasoningEffort: effectiveReasoningEffort,
-            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 (effectiveReasoningEffort && effectiveReasoningEffort !== 'default') {
-            agent.defaultRunOptions = {
-                ...(agent.defaultRunOptions || {}),
-                // Pass through to underlying client for models that support it
-                reasoning: { effort: effectiveReasoningEffort },
-            };
-        }
-        return agent;
-    }
-    #buildAgentTools({ toolDefinitions, resolvedModel, shouldUseNativePatchTool, }) {
-        const providerCapabilities = this.#getProviderCapabilities(this.#provider);
-        const useStrictToolSchema = shouldUseStrictToolSchema({
-            providerId: this.#provider,
-            capabilities: providerCapabilities,
-        });
-        const executeWithToolConcurrency = async (details, runTask) => {
-            const parentSignal = this.#currentAbortController?.signal;
-            const toolSignal = details?.signal;
-            const combined = combineAbortSignals(parentSignal, toolSignal);
-            const combinedSignal = combined?.signal;
-            const cleanupSignal = combined?.cleanup;
-            const wrappedDetails = details
-                ? Object.create(Object.getPrototypeOf(details), {
-                    ...Object.getOwnPropertyDescriptors(details),
-                    ...(combinedSignal
-                        ? { signal: { value: combinedSignal, writable: true, enumerable: true, configurable: true } }
-                        : {}),
-                })
-                : combinedSignal
-                    ? { signal: combinedSignal }
-                    : undefined;
-            try {
-                return await this.#toolExecutionLimiter.run(() => runTask(wrappedDetails), combinedSignal);
-            }
-            finally {
-                cleanupSignal?.();
-            }
-        };
-        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: useStrictToolSchema ? toOpenAIStrictToolSchema(definition.parameters) : definition.parameters,
-            needsApproval: wrapNeedsApproval(definition, {
-                checkInterceptors: (params) => this.#checkToolInterceptors(definition.name, params),
-            }),
-            execute: async (params, _context, details) => {
-                const maxOutputLengthValue = this.#settings.get('shell.maxOutputChars');
-                // 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.debug('Tool execution intercepted', {
-                        tool: definition.name,
-                        params: JSON.stringify(params).substring(0, 100),
-                    });
-                    // Return a failure response that all tools should understand
-                    const rejected = JSON.stringify({
-                        output: [
-                            {
-                                success: false,
-                                error: rejectionMessage,
-                            },
-                        ],
-                    });
-                    return trimToolOutput(rejected, undefined, maxOutputLengthValue ?? undefined);
-                }
-                return executeWithToolConcurrency(details, async (wrappedDetails) => {
-                    // Normal execution with combined abort signal
-                    const result = await definition.execute(params, _context, wrappedDetails);
-                    return trimToolOutput(result, undefined, maxOutputLengthValue ?? undefined);
-                });
-            },
-        }), definition.parameters));
-        // 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.debug('Native tool execution intercepted', {
-                            tool: 'apply_patch',
-                            toolCallId,
-                            params: JSON.stringify(params).substring(0, 100),
-                        });
-                        const rejected = JSON.stringify({
-                            output: [
-                                {
-                                    success: false,
-                                    error: rejectionMessage,
-                                },
-                            ],
-                        });
-                        const maxOutputLengthValue = this.#settings.get('shell.maxOutputChars');
-                        return trimToolOutput(rejected, undefined, maxOutputLengthValue ?? undefined);
-                    }
-                    const maxOutputLengthValue = this.#settings.get('shell.maxOutputChars');
-                    return executeWithToolConcurrency(details, async (wrappedDetails) => {
-                        const result = await originalInvoke.call(nativePatchTool, runContext, normalizedInput, wrappedDetails);
-                        return trimToolOutput(result, undefined, maxOutputLengthValue ?? undefined);
-                    });
-                };
-            }
-            tools.push(nativePatchTool);
-            this.#logger.debug('Using native applyPatchTool from SDK', {
-                model: resolvedModel,
-                provider: this.#provider,
-            });
-        }
-        else {
-            this.#logger.debug('Using custom apply_patch implementation', {
-                model: resolvedModel,
-                provider: this.#provider,
-            });
-        }
-        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.
-        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;
-        }
-        // OpenAI Flex Service Tier: only pass when enabled and using OpenAI provider
-        // This reduces costs by using the flex service tier for lower priority requests
-        // See: https://platform.openai.com/docs/guides/service-tier
-        const useFlexServiceTier = this.#settings.get('agent.useFlexServiceTier');
-        if (useFlexServiceTier &&
-            this.#serviceTierOverrideForNextRequest !== 'standard' &&
-            (this.#provider === 'openai' || this.#provider === 'openrouter')) {
-            modelSettings.providerData = {
-                ...(modelSettings.providerData || {}),
-                service_tier: 'flex',
-            };
-        }
-        if (this.#provider === 'codex') {
-            modelSettings.store = false;
-            modelSettings.include = ['reasoning.encrypted_content'];
-        }
-        return modelSettings;
-    }
     getSettings() {
         return this.#settings;
     }
 }
-export function combineAbortSignals(signal1, signal2) {
-    if (!signal1 && !signal2)
-        return undefined;
-    if (!signal1)
-        return { signal: signal2, cleanup: () => { } };
-    if (!signal2)
-        return { signal: signal1, cleanup: () => { } };
-    if (typeof AbortSignal.any === 'function') {
-        return { signal: AbortSignal.any([signal1, signal2]), cleanup: () => { } };
-    }
-    const controller = new AbortController();
-    const onAbort = () => {
-        controller.abort();
-        cleanup();
-    };
-    const cleanup = () => {
-        signal1.removeEventListener('abort', onAbort);
-        signal2.removeEventListener('abort', onAbort);
-    };
-    if (signal1.aborted || signal2.aborted) {
-        controller.abort();
-    }
-    else {
-        signal1.addEventListener('abort', onAbort);
-        signal2.addEventListener('abort', onAbort);
-    }
-    return { signal: controller.signal, cleanup };
-}
 //# sourceMappingURL=openai-agent-client.js.map