@qduc/term2 0.7.1 → 0.7.3

package/dist/lib/openai-agent-client.public-methods.test.js

@@ -1,6 +1,10 @@
 import test from 'ava';
 import { OpenAIAgentClient } from './openai-agent-client.js';
 import { registerProvider } from '../providers/registry.js';
+const createSessionContextService = () => ({
+    runWithContext: (_context, fn) => fn(),
+    getContext: () => null,
+});
 // ========== Mock Utilities ==========
 function createMockLogger() {
     return {
@@ -63,6 +67,8 @@ let chainingProviderRegistered = false;
 let chainingRunnerCalls = [];
 let codexProviderRegistered = false;
 let codexRunnerCalls = [];
+let openaiProviderRegistered = false;
+let openaiRunnerCalls = [];
 let failingProviderRegistered = false;
 function ensureMentorProvidersRegistered() {
     if (!mentorProviderRegistered) {
@@ -127,7 +133,7 @@ function ensureChainingProvidersRegistered() {
             label: 'Mock Chaining False',
             createRunner: () => ({
                 run: async (_agent, _input, options) => {
-                    chainingRunnerCalls.push({ options, providerId: 'mock-chaining-false' });
+                    chainingRunnerCalls.push({ input: _input, options, providerId: 'mock-chaining-false' });
                     return {
                         status: 'completed',
                         finalOutput: 'ok',
@@ -146,7 +152,7 @@ function ensureChainingProvidersRegistered() {
             label: 'Mock Chaining True',
             createRunner: () => ({
                 run: async (_agent, _input, options) => {
-                    chainingRunnerCalls.push({ options, providerId: 'mock-chaining-true' });
+                    chainingRunnerCalls.push({ input: _input, options, providerId: 'mock-chaining-true' });
                     return {
                         status: 'completed',
                         finalOutput: 'ok',
@@ -182,11 +188,37 @@ function ensureCodexProviderRegistered() {
             capabilities: {
                 supportsConversationChaining: true,
                 supportsTracingControl: true,
+                supportsPromptCacheKey: true,
             },
         }, { allowOverride: true });
         codexProviderRegistered = true;
     }
 }
+function ensureOpenAIProviderRegistered() {
+    if (!openaiProviderRegistered) {
+        registerProvider({
+            id: 'openai',
+            label: 'Mock OpenAI',
+            createRunner: () => ({
+                run: async (agent, _input, options) => {
+                    openaiRunnerCalls.push({ agent, options });
+                    return {
+                        status: 'completed',
+                        finalOutput: 'ok',
+                        messages: [],
+                    };
+                },
+            }),
+            fetchModels: async () => [{ id: 'mock-model' }],
+            capabilities: {
+                supportsConversationChaining: true,
+                supportsTracingControl: true,
+                supportsPromptCacheKey: true,
+            },
+        }, { allowOverride: true });
+        openaiProviderRegistered = true;
+    }
+}
 function ensureFailingProviderRegistered() {
     if (!failingProviderRegistered) {
         registerProvider({
@@ -210,6 +242,7 @@ test.beforeEach(() => {
     ensureMentorProvidersRegistered();
     ensureChainingProvidersRegistered();
     ensureCodexProviderRegistered();
+    ensureOpenAIProviderRegistered();
     ensureFailingProviderRegistered();
     capturedMainAgentForMentorTest = null;
     mentorInputs = [];
@@ -217,12 +250,13 @@ test.beforeEach(() => {
     mentorResponseCounter = 0;
     chainingRunnerCalls = [];
     codexRunnerCalls = [];
+    openaiRunnerCalls = [];
 });
 // ========== setModel tests ==========
 test.serial('setModel updates the internal model', async (t) => {
     const settings = createMockSettings();
     const client = new OpenAIAgentClient({
-        deps: { logger: createMockLogger(), settings },
+        deps: { logger: createMockLogger(), settings, sessionContextService: createSessionContextService() },
     });
     // Set a new model
     client.setModel('gpt-4-turbo');
@@ -237,14 +271,14 @@ test.serial('setModel updates the internal model', async (t) => {
 test.serial('getProvider returns current provider', (t) => {
     const settings = createMockSettings({ 'agent.provider': 'mock-provider-public-methods' });
     const client = new OpenAIAgentClient({
-        deps: { logger: createMockLogger(), settings },
+        deps: { logger: createMockLogger(), settings, sessionContextService: createSessionContextService() },
     });
     t.is(client.getProvider(), 'mock-provider-public-methods');
 });
 test.serial('setProvider updates provider and persists to settings', (t) => {
     const settings = createMockSettings({ 'agent.provider': 'mock-provider-public-methods' });
     const client = new OpenAIAgentClient({
-        deps: { logger: createMockLogger(), settings },
+        deps: { logger: createMockLogger(), settings, sessionContextService: createSessionContextService() },
     });
     client.setProvider('openai');
     t.is(client.getProvider(), 'openai');
@@ -253,7 +287,7 @@ test.serial('setProvider updates provider and persists to settings', (t) => {
 test.serial('setProvider does not initialize provider credentials eagerly', async (t) => {
     const settings = createMockSettings({ 'agent.provider': 'mock-provider-public-methods' });
     const client = new OpenAIAgentClient({
-        deps: { logger: createMockLogger(), settings },
+        deps: { logger: createMockLogger(), settings, sessionContextService: createSessionContextService() },
     });
     client.setProvider('mock-missing-creds');
     t.is(client.getProvider(), 'mock-missing-creds');
@@ -266,7 +300,7 @@ test.serial('startStream only passes previousResponseId when provider supports c
         'agent.provider': 'mock-chaining-false',
     });
     const client = new OpenAIAgentClient({
-        deps: { logger: createMockLogger(), settings },
+        deps: { logger: createMockLogger(), settings, sessionContextService: createSessionContextService() },
     });
     await client.startStream('Hello', { previousResponseId: 'prev-1' });
     t.is(chainingRunnerCalls.length, 1);
@@ -276,18 +310,203 @@ test.serial('startStream only passes previousResponseId when provider supports c
     t.is(chainingRunnerCalls.length, 2);
     t.is(chainingRunnerCalls[1].options.previousResponseId, 'prev-2');
 });
+test.serial('continueRunStream filters replayed history to delta input when chaining from previousResponseId', async (t) => {
+    const settings = createMockSettings({
+        'agent.provider': 'mock-chaining-true',
+    });
+    const client = new OpenAIAgentClient({
+        deps: { logger: createMockLogger(), settings, sessionContextService: createSessionContextService() },
+    });
+    const state = {
+        _context: { context: { turnCount: 0 } },
+        _generatedItems: [
+            { rawItem: { type: 'function_call', callId: 'call-read', name: 'read_file', arguments: '{}' } },
+            { rawItem: { type: 'function_call_output', callId: 'call-read', output: 'done' } },
+        ],
+    };
+    await client.continueRunStream(state, { previousResponseId: 'resp-prev' });
+    t.is(chainingRunnerCalls.length, 1);
+    const call = chainingRunnerCalls[0];
+    t.is(call.input, state);
+    t.is(call.options.previousResponseId, 'resp-prev');
+    const filtered = call.options.callModelInputFilter({
+        context: { turnCount: 0 },
+        modelData: {
+            input: [
+                { role: 'user', type: 'message', content: 'inspect file' },
+                { role: 'assistant', type: 'message', content: [{ type: 'output_text', text: 'I will inspect it.' }] },
+                { type: 'function_call', callId: 'call-read', name: 'read_file', arguments: '{}' },
+                { type: 'function_call_output', callId: 'call-read', output: 'done' },
+            ],
+            instructions: 'system',
+        },
+    });
+    t.deepEqual(filtered.input, [{ type: 'function_call_output', callId: 'call-read', output: 'done' }]);
+    t.is(filtered.instructions, 'system');
+});
+test.serial('continueRunStream filters replayed history to delta input with function_call_output_result and tool_call_output_item', async (t) => {
+    const settings = createMockSettings({
+        'agent.provider': 'mock-chaining-true',
+    });
+    const client = new OpenAIAgentClient({
+        deps: { logger: createMockLogger(), settings, sessionContextService: createSessionContextService() },
+    });
+    await client.continueRunStream({ _context: { context: { turnCount: 0 } } }, { previousResponseId: 'resp-prev' });
+    const filtered = chainingRunnerCalls[0].options.callModelInputFilter({
+        context: { turnCount: 0 },
+        modelData: {
+            input: [
+                { role: 'user', type: 'message', content: 'inspect file' },
+                { role: 'assistant', type: 'message', content: [{ type: 'output_text', text: 'I will inspect it.' }] },
+                { type: 'function_call', callId: 'call-read', name: 'read_file', arguments: '{}' },
+                { type: 'function_call_output_result', callId: 'call-read', output: 'done' },
+                { type: 'tool_call_output_item', callId: 'call-read', output: 'done' },
+            ],
+            instructions: 'system',
+        },
+    });
+    t.deepEqual(filtered.input, [
+        { type: 'function_call_output_result', callId: 'call-read', output: 'done' },
+        { type: 'tool_call_output_item', callId: 'call-read', output: 'done' },
+    ]);
+});
+test.serial('continueRunStream keeps the latest user item when chained model input replays full history', async (t) => {
+    const settings = createMockSettings({
+        'agent.provider': 'mock-chaining-true',
+    });
+    const client = new OpenAIAgentClient({
+        deps: { logger: createMockLogger(), settings, sessionContextService: createSessionContextService() },
+    });
+    await client.continueRunStream({ _context: { context: { turnCount: 0 } } }, { previousResponseId: 'resp-prev' });
+    const filtered = chainingRunnerCalls[0].options.callModelInputFilter({
+        context: { turnCount: 0 },
+        modelData: {
+            input: [
+                { role: 'user', type: 'message', content: 'first' },
+                { role: 'assistant', type: 'message', content: [{ type: 'output_text', text: 'first response' }] },
+                { role: 'user', type: 'message', content: 'second' },
+            ],
+            instructions: 'system',
+        },
+    });
+    t.deepEqual(filtered.input, [{ role: 'user', type: 'message', content: 'second' }]);
+});
+test.serial('startStream filters replayed history to delta input when chaining from previousResponseId', async (t) => {
+    const settings = createMockSettings({
+        'agent.provider': 'mock-chaining-true',
+    });
+    const client = new OpenAIAgentClient({
+        deps: { logger: createMockLogger(), settings, sessionContextService: createSessionContextService() },
+    });
+    await client.startStream('inspect file', { previousResponseId: 'resp-prev' });
+    t.is(chainingRunnerCalls.length, 1);
+    const call = chainingRunnerCalls[0];
+    t.is(call.options.previousResponseId, 'resp-prev');
+    const filtered = call.options.callModelInputFilter({
+        context: { turnCount: 0 },
+        modelData: {
+            input: [
+                { role: 'user', type: 'message', content: 'inspect file' },
+                { role: 'assistant', type: 'message', content: [{ type: 'output_text', text: 'I will inspect it.' }] },
+                { type: 'function_call', callId: 'call-read', name: 'read_file', arguments: '{}' },
+                { type: 'function_call_output', callId: 'call-read', output: 'done' },
+            ],
+            instructions: 'system',
+        },
+    });
+    t.deepEqual(filtered.input, [{ type: 'function_call_output', callId: 'call-read', output: 'done' }]);
+    t.is(filtered.instructions, 'system');
+});
+test.serial('continueRun filters replayed history to delta input when chaining from previousResponseId', async (t) => {
+    const settings = createMockSettings({
+        'agent.provider': 'mock-chaining-true',
+    });
+    const client = new OpenAIAgentClient({
+        deps: { logger: createMockLogger(), settings, sessionContextService: createSessionContextService() },
+    });
+    const state = {
+        _context: { context: { turnCount: 0 } },
+        _generatedItems: [
+            { rawItem: { type: 'function_call', callId: 'call-read', name: 'read_file', arguments: '{}' } },
+            { rawItem: { type: 'function_call_output', callId: 'call-read', output: 'done' } },
+        ],
+    };
+    await client.continueRun(state, { previousResponseId: 'resp-prev' });
+    t.is(chainingRunnerCalls.length, 1);
+    const call = chainingRunnerCalls[0];
+    t.is(call.input, state);
+    t.is(call.options.previousResponseId, 'resp-prev');
+    const filtered = call.options.callModelInputFilter({
+        context: { turnCount: 0 },
+        modelData: {
+            input: [
+                { role: 'user', type: 'message', content: 'inspect file' },
+                { role: 'assistant', type: 'message', content: [{ type: 'output_text', text: 'I will inspect it.' }] },
+                { type: 'function_call', callId: 'call-read', name: 'read_file', arguments: '{}' },
+                { type: 'function_call_output', callId: 'call-read', output: 'done' },
+            ],
+            instructions: 'system',
+        },
+    });
+    t.deepEqual(filtered.input, [{ type: 'function_call_output', callId: 'call-read', output: 'done' }]);
+    t.is(filtered.instructions, 'system');
+});
+test.serial('continueRunStream filters and keeps user message even with custom type', async (t) => {
+    const settings = createMockSettings({
+        'agent.provider': 'mock-chaining-true',
+    });
+    const client = new OpenAIAgentClient({
+        deps: { logger: createMockLogger(), settings, sessionContextService: createSessionContextService() },
+    });
+    await client.continueRunStream({ _context: { context: { turnCount: 0 } } }, { previousResponseId: 'resp-prev' });
+    const filtered = chainingRunnerCalls[0].options.callModelInputFilter({
+        context: { turnCount: 0 },
+        modelData: {
+            input: [
+                { role: 'user', type: 'message', content: 'first' },
+                { role: 'assistant', type: 'message', content: [{ type: 'output_text', text: 'first response' }] },
+                { role: 'user', type: 'custom_input_type', content: 'second' },
+            ],
+            instructions: 'system',
+        },
+    });
+    t.deepEqual(filtered.input, [{ role: 'user', type: 'custom_input_type', content: 'second' }]);
+});
 test.serial('codex startStream puts prompt_cache_key on agent modelSettings, not run options', async (t) => {
     const settings = createMockSettings({
         'agent.provider': 'codex',
     });
     const client = new OpenAIAgentClient({
-        deps: { logger: createMockLogger(), settings },
+        deps: { logger: createMockLogger(), settings, sessionContextService: createSessionContextService() },
     });
     await client.startStream('Hello', { sessionId: 'session-123' });
     t.is(codexRunnerCalls.length, 1);
     t.is(codexRunnerCalls[0].agent.modelSettings.prompt_cache_key, 'session-123');
     t.false('modelSettings' in codexRunnerCalls[0].options);
 });
+test.serial('openai startStream puts prompt_cache_key on agent modelSettings, not run options', async (t) => {
+    const settings = createMockSettings({
+        'agent.provider': 'openai',
+    });
+    const client = new OpenAIAgentClient({
+        deps: { logger: createMockLogger(), settings, sessionContextService: createSessionContextService() },
+    });
+    await client.startStream('Hello', { sessionId: 'session-456' });
+    t.is(openaiRunnerCalls.length, 1);
+    t.is(openaiRunnerCalls[0].agent.modelSettings.prompt_cache_key, 'session-456');
+    t.false('modelSettings' in openaiRunnerCalls[0].options);
+});
+test.serial('startStream omits prompt_cache_key when provider does not support it', async (t) => {
+    const settings = createMockSettings({
+        'agent.provider': 'mock-provider-public-methods',
+    });
+    const client = new OpenAIAgentClient({
+        deps: { logger: createMockLogger(), settings, sessionContextService: createSessionContextService() },
+    });
+    await client.startStream('Hello', { sessionId: 'session-789' });
+    t.is(runnerCalls.length, 1);
+    t.falsy(runnerCalls[0].agent.modelSettings?.prompt_cache_key);
+});
 test.serial('abort logs with active trace id before clearing correlation', async (t) => {
     const debugLogs = [];
     let correlationId;
@@ -312,7 +531,7 @@ test.serial('abort logs with active trace id before clearing correlation', async
         'agent.provider': 'mock-chaining-false',
     });
     const client = new OpenAIAgentClient({
-        deps: { logger, settings },
+        deps: { logger, settings, sessionContextService: createSessionContextService() },
     });
     await client.startStream('Hello');
     const activeCorrelationId = correlationId;
@@ -328,7 +547,7 @@ test.serial('abort logs with active trace id before clearing correlation', async
 test.serial('addToolInterceptor returns removal function', (t) => {
     const settings = createMockSettings();
     const client = new OpenAIAgentClient({
-        deps: { logger: createMockLogger(), settings },
+        deps: { logger: createMockLogger(), settings, sessionContextService: createSessionContextService() },
     });
     const remove = client.addToolInterceptor(async () => {
         return null;
@@ -341,7 +560,7 @@ test.serial('addToolInterceptor returns removal function', (t) => {
 test.serial('addToolInterceptor can be removed', (t) => {
     const settings = createMockSettings();
     const client = new OpenAIAgentClient({
-        deps: { logger: createMockLogger(), settings },
+        deps: { logger: createMockLogger(), settings, sessionContextService: createSessionContextService() },
     });
     const remove = client.addToolInterceptor(async () => {
         return null;
@@ -356,7 +575,7 @@ test.serial('addToolInterceptor can be removed', (t) => {
 test.serial('abort does not throw when called without active operation', (t) => {
     const settings = createMockSettings();
     const client = new OpenAIAgentClient({
-        deps: { logger: createMockLogger(), settings },
+        deps: { logger: createMockLogger(), settings, sessionContextService: createSessionContextService() },
     });
     // Should not throw
     t.notThrows(() => client.abort());
@@ -364,7 +583,7 @@ test.serial('abort does not throw when called without active operation', (t) =>
 test.serial('abort can be called multiple times', (t) => {
     const settings = createMockSettings();
     const client = new OpenAIAgentClient({
-        deps: { logger: createMockLogger(), settings },
+        deps: { logger: createMockLogger(), settings, sessionContextService: createSessionContextService() },
     });
     t.notThrows(() => {
         client.abort();
@@ -376,14 +595,14 @@ test.serial('abort can be called multiple times', (t) => {
 test.serial('clearConversations does not throw', (t) => {
     const settings = createMockSettings();
     const client = new OpenAIAgentClient({
-        deps: { logger: createMockLogger(), settings },
+        deps: { logger: createMockLogger(), settings, sessionContextService: createSessionContextService() },
     });
     t.notThrows(() => client.clearConversations());
 });
 test.serial('clearConversations can be called multiple times', (t) => {
     const settings = createMockSettings();
     const client = new OpenAIAgentClient({
-        deps: { logger: createMockLogger(), settings },
+        deps: { logger: createMockLogger(), settings, sessionContextService: createSessionContextService() },
     });
     t.notThrows(() => {
         client.clearConversations();
@@ -394,7 +613,7 @@ test.serial('clearConversations can be called multiple times', (t) => {
 test.serial('setReasoningEffort accepts valid effort levels', (t) => {
     const settings = createMockSettings();
     const client = new OpenAIAgentClient({
-        deps: { logger: createMockLogger(), settings },
+        deps: { logger: createMockLogger(), settings, sessionContextService: createSessionContextService() },
     });
     t.notThrows(() => client.setReasoningEffort('high'));
     t.notThrows(() => client.setReasoningEffort('medium'));
@@ -406,7 +625,7 @@ test.serial('setReasoningEffort accepts valid effort levels', (t) => {
 test.serial('setTemperature accepts numeric values', (t) => {
     const settings = createMockSettings();
     const client = new OpenAIAgentClient({
-        deps: { logger: createMockLogger(), settings },
+        deps: { logger: createMockLogger(), settings, sessionContextService: createSessionContextService() },
     });
     t.notThrows(() => client.setTemperature(0.5));
     t.notThrows(() => client.setTemperature(1.0));
@@ -417,10 +636,45 @@ test.serial('setTemperature accepts numeric values', (t) => {
 test.serial('setRetryCallback accepts callback function', (t) => {
     const settings = createMockSettings();
     const client = new OpenAIAgentClient({
-        deps: { logger: createMockLogger(), settings },
+        deps: { logger: createMockLogger(), settings, sessionContextService: createSessionContextService() },
     });
     t.notThrows(() => client.setRetryCallback(() => { }));
 });
+test.serial('setAskUserAnswer stores and consumes answers by call id', (t) => {
+    const settings = createMockSettings();
+    const client = new OpenAIAgentClient({
+        deps: { logger: createMockLogger(), settings, sessionContextService: createSessionContextService() },
+    });
+    client.setAskUserAnswer('call-1', 'Use the existing config');
+    t.is(client.getAskUserAnswer('call-1'), 'Use the existing config');
+    t.is(client.getAskUserAnswer('call-1'), undefined);
+});
+test.serial('getAskUserAnswer returns undefined for unknown call ids', (t) => {
+    const settings = createMockSettings();
+    const client = new OpenAIAgentClient({
+        deps: { logger: createMockLogger(), settings, sessionContextService: createSessionContextService() },
+    });
+    t.is(client.getAskUserAnswer('missing-call'), undefined);
+    t.is(client.getAskUserAnswer(), undefined);
+});
+test.serial('ask_user tool executes using the stored approval answer', async (t) => {
+    const settings = createMockSettings({
+        'agent.provider': 'mock-main-mentor-refresh',
+        'agent.model': 'mock-model',
+        'app.liteMode': false,
+    });
+    const client = new OpenAIAgentClient({
+        deps: { logger: createMockLogger(), settings, sessionContextService: createSessionContextService() },
+    });
+    await client.chat('prime tools');
+    const askUserTool = capturedMainAgentForMentorTest?.tools?.find((tool) => tool?.name === 'ask_user');
+    t.truthy(askUserTool);
+    t.is(typeof askUserTool?.invoke, 'function');
+    client.setAskUserAnswer('call-bridge', 'Use the safe option');
+    const result = await askUserTool.invoke({}, JSON.stringify({ question: 'Which option should I use?', options: ['Use the safe option', 'Ask later'] }), { toolCall: { callId: 'call-bridge' } });
+    t.is(result, 'Use the safe option');
+    t.is(client.getAskUserAnswer('call-bridge'), undefined);
+});
 test.serial('setModel resets mentor conversation chain used by ask_mentor', async (t) => {
     const settings = createMockSettings({
         'agent.provider': 'mock-main-mentor-refresh',
@@ -430,7 +684,7 @@ test.serial('setModel resets mentor conversation chain used by ask_mentor', asyn
         'app.liteMode': false,
     });
     const client = new OpenAIAgentClient({
-        deps: { logger: createMockLogger(), settings },
+        deps: { logger: createMockLogger(), settings, sessionContextService: createSessionContextService() },
     });
     await client.chat('prime tools');
     const askMentorTool = capturedMainAgentForMentorTest?.tools?.find((tool) => tool?.name === 'ask_mentor');
@@ -458,7 +712,7 @@ test.serial('ask_mentor resets conversation chain when mentor provider changes',
         'app.liteMode': false,
     });
     const client = new OpenAIAgentClient({
-        deps: { logger: createMockLogger(), settings },
+        deps: { logger: createMockLogger(), settings, sessionContextService: createSessionContextService() },
     });
     await client.chat('prime tools');
     const askMentorTool = capturedMainAgentForMentorTest?.tools?.find((tool) => tool?.name === 'ask_mentor');
@@ -505,7 +759,7 @@ test.serial('setSubagentEventSink defers cleanup to null when subagents are acti
         'app.liteMode': false,
     });
     const client = new OpenAIAgentClient({
-        deps: { logger: createMockLogger(), settings },
+        deps: { logger: createMockLogger(), settings, sessionContextService: createSessionContextService() },
     });
     await client.chat('prime tools');
     const askMentorTool = capturedMainAgentForMentorTest?.tools?.find((tool) => tool?.name === 'ask_mentor');
@@ -557,7 +811,7 @@ test.serial('codex resolves default_reasoning_level if agent.reasoningEffort is
         },
     }, { allowOverride: true });
     const client = new OpenAIAgentClient({
-        deps: { logger: createMockLogger(), settings },
+        deps: { logger: createMockLogger(), settings, sessionContextService: createSessionContextService() },
     });
     await client.startStream('Hello');
     t.is(codexRunnerCalls.length, 1);
@@ -592,7 +846,7 @@ test.serial('codex chat resolves default_reasoning_level if agent.reasoningEffor
         },
     }, { allowOverride: true });
     const client = new OpenAIAgentClient({
-        deps: { logger: createMockLogger(), settings },
+        deps: { logger: createMockLogger(), settings, sessionContextService: createSessionContextService() },
     });
     await client.chat('Hello', { provider: 'codex', model: 'gpt-5.3-codex', reasoningEffort: 'default' });
     t.is(codexRunnerCalls.length, 1);
@@ -600,4 +854,53 @@ test.serial('codex chat resolves default_reasoning_level if agent.reasoningEffor
     t.truthy(agent);
     t.is(agent.modelSettings?.reasoning?.effort, 'medium');
 });
+test.serial('main agent client injects warning into tool output when turns left <= 5', async (t) => {
+    let executeOutput = null;
+    registerProvider({
+        id: 'mock-provider-maxturns',
+        label: 'Mock Provider MaxTurns',
+        createRunner: () => ({
+            run: async (agent, _input, options) => {
+                if (options.callModelInputFilter) {
+                    // Simulate 96 turns
+                    for (let i = 0; i < 96; i++) {
+                        await options.callModelInputFilter({
+                            modelData: { input: [] },
+                            agent,
+                            context: options.context,
+                        });
+                    }
+                }
+                // Execute a tool to see if the warning is injected
+                const readFileTool = agent.tools.find((tool) => tool.name === 'read_file');
+                if (readFileTool) {
+                    const mockRunContext = {
+                        context: options.context,
+                    };
+                    executeOutput = await readFileTool.invoke(mockRunContext, JSON.stringify({ path: 'package.json' }), {});
+                }
+                return {
+                    status: 'completed',
+                    finalOutput: 'done',
+                    history: [],
+                    messages: [],
+                };
+            },
+        }),
+        fetchModels: async () => [{ id: 'mock-model' }],
+    });
+    const settings = createMockSettings({
+        'agent.provider': 'mock-provider-maxturns',
+        'agent.model': 'mock-model',
+    });
+    const client = new OpenAIAgentClient({
+        maxTurns: 100,
+        deps: { logger: createMockLogger(), settings, sessionContextService: createSessionContextService() },
+    });
+    // Trigger startStream to initiate the provider run with correct context
+    await client.startStream('Hello');
+    t.truthy(executeOutput);
+    t.true(executeOutput.includes('approaching the maximum turn limit'), 'should contain max turns warning');
+    t.true(executeOutput.includes('4 turns left'), 'should indicate correct number of turns left');
+});
 //# sourceMappingURL=openai-agent-client.public-methods.test.js.map