Add tests

Author: seratch

packages/agents-core/test/run.test.ts

@@ -1,4 +1,13 @@
-import { beforeAll, describe, expect, expectTypeOf, it, vi } from 'vitest';
+import {
+  beforeAll,
+  beforeEach,
+  afterEach,
+  describe,
+  expect,
+  expectTypeOf,
+  it,
+  vi,
+} from 'vitest';
 import { z } from 'zod';
 import {
   Agent,
@@ -32,7 +41,7 @@ import {
   TEST_MODEL_RESPONSE_BASIC,
   TEST_TOOL,
 } from './stubs';
-import { Model, ModelRequest } from '../src/model';
+import { Model, ModelProvider, ModelRequest } from '../src/model';
 
 describe('Runner.run', () => {
   beforeAll(() => {
@@ -148,7 +157,11 @@ describe('Runner.run', () => {
 
       // Track agent_end events on both the agent and runner
       const agentEndEvents: Array<{ context: any; output: string }> = [];
-      const runnerEndEvents: Array<{ context: any; agent: any; output: string }> = [];
+      const runnerEndEvents: Array<{
+        context: any;
+        agent: any;
+        output: string;
+      }> = [];
 
       agent.on('agent_end', (context, output) => {
         agentEndEvents.push({ context, output });
@@ -407,7 +420,7 @@ describe('Runner.run', () => {
         usage: new Usage(),
       };
       class SimpleStreamingModel implements Model {
-        constructor(private resps: ModelResponse[]) { }
+        constructor(private resps: ModelResponse[]) {}
         async getResponse(_req: ModelRequest): Promise<ModelResponse> {
           const r = this.resps.shift();
           if (!r) {
@@ -525,6 +538,124 @@ describe('Runner.run', () => {
     });
   });
 
+  describe('gpt-5 default model adjustments', () => {
+    class InspectableModel extends FakeModel {
+      lastRequest: ModelRequest | undefined;
+
+      constructor(response: ModelResponse) {
+        super([response]);
+      }
+
+      override async getResponse(
+        request: ModelRequest,
+      ): Promise<ModelResponse> {
+        this.lastRequest = request;
+        return await super.getResponse(request);
+      }
+    }
+
+    class InspectableModelProvider implements ModelProvider {
+      constructor(private readonly model: Model) {}
+
+      async getModel(_name: string): Promise<Model> {
+        return this.model;
+      }
+    }
+
+    let originalDefaultModel: string | undefined;
+
+    beforeEach(() => {
+      originalDefaultModel = process.env.OPENAI_DEFAULT_MODEL;
+      process.env.OPENAI_DEFAULT_MODEL = 'gpt-5o';
+    });
+
+    afterEach(() => {
+      if (originalDefaultModel === undefined) {
+        delete process.env.OPENAI_DEFAULT_MODEL;
+      } else {
+        process.env.OPENAI_DEFAULT_MODEL = originalDefaultModel;
+      }
+    });
+
+    function createGpt5ModelSettings() {
+      return {
+        temperature: 0.42,
+        providerData: {
+          reasoning: { effort: 'high' },
+          text: { verbosity: 'high' },
+          reasoning_effort: 'medium',
+          keep: 'value',
+        },
+        reasoning: { effort: 'high', summary: 'detailed' },
+        text: { verbosity: 'medium' },
+      };
+    }
+
+    it('strips GPT-5-only settings when the runner model is not a GPT-5 string', async () => {
+      const modelResponse: ModelResponse = {
+        output: [fakeModelMessage('Hello non GPT-5')],
+        usage: new Usage(),
+      };
+      const inspectableModel = new InspectableModel(modelResponse);
+      const agent = new Agent({
+        name: 'NonGpt5Runner',
+        model: inspectableModel,
+        modelSettings: createGpt5ModelSettings(),
+      });
+
+      const runner = new Runner();
+      const result = await runner.run(agent, 'hello');
+
+      expect(result.finalOutput).toBe('Hello non GPT-5');
+      expect(inspectableModel.lastRequest).toBeDefined();
+
+      const requestSettings = inspectableModel.lastRequest!.modelSettings;
+      expect(requestSettings.temperature).toBe(0.42);
+      expect(requestSettings.providerData?.keep).toBe('value');
+      expect(requestSettings.providerData?.reasoning).toBeUndefined();
+      expect(requestSettings.providerData?.text?.verbosity).toBeUndefined();
+      expect(
+        (requestSettings.providerData as any)?.reasoning_effort,
+      ).toBeUndefined();
+      expect(requestSettings.reasoning?.effort).toBeUndefined();
+      expect(requestSettings.reasoning?.summary).toBeUndefined();
+      expect(requestSettings.text?.verbosity).toBeUndefined();
+    });
+
+    it('keeps GPT-5-only settings when the agent relies on the default model', async () => {
+      const modelResponse: ModelResponse = {
+        output: [fakeModelMessage('Hello default GPT-5')],
+        usage: new Usage(),
+      };
+      const inspectableModel = new InspectableModel(modelResponse);
+      const runner = new Runner({
+        modelProvider: new InspectableModelProvider(inspectableModel),
+      });
+
+      const agent = new Agent({
+        name: 'DefaultModelAgent',
+        modelSettings: createGpt5ModelSettings(),
+      });
+
+      const result = await runner.run(agent, 'hello');
+
+      expect(result.finalOutput).toBe('Hello default GPT-5');
+      expect(inspectableModel.lastRequest).toBeDefined();
+
+      const requestSettings = inspectableModel.lastRequest!.modelSettings;
+      expect(requestSettings.providerData?.reasoning).toEqual({
+        effort: 'high',
+      });
+      expect(requestSettings.providerData?.text?.verbosity).toBe('high');
+      expect((requestSettings.providerData as any)?.reasoning_effort).toBe(
+        'medium',
+      );
+      expect(requestSettings.reasoning?.effort).toBe('high');
+      expect(requestSettings.reasoning?.summary).toBe('detailed');
+      expect(requestSettings.text?.verbosity).toBe('medium');
+    });
+  });
+
   describe('selectModel', () => {
     const MODEL_A = 'gpt-4o';
     const MODEL_B = 'gpt-4.1-mini';

packages/agents-openai/test/openaiChatCompletionsModel.test.ts

@@ -250,6 +250,39 @@ describe('OpenAIChatCompletionsModel', () => {
     ]);
   });
 
+  it('merges top-level reasoning and text settings into chat completions request payload', async () => {
+    const client = new FakeClient();
+    const response = {
+      id: 'r',
+      choices: [{ message: { content: 'hi' } }],
+      usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+    } as any;
+    client.chat.completions.create.mockResolvedValue(response);
+
+    const model = new OpenAIChatCompletionsModel(client as any, 'gpt');
+    const req: any = {
+      input: 'u',
+      modelSettings: {
+        reasoning: { effort: 'high' },
+        text: { verbosity: 'medium' },
+        providerData: { customOption: 'keep' },
+      },
+      tools: [],
+      outputType: 'text',
+      handoffs: [],
+      tracing: false,
+    };
+
+    await withTrace('t', () => model.getResponse(req));
+
+    expect(client.chat.completions.create).toHaveBeenCalledTimes(1);
+    const [args, options] = client.chat.completions.create.mock.calls[0];
+    expect(args.reasoning_effort).toBe('high');
+    expect(args.verbosity).toBe('medium');
+    expect(args.customOption).toBe('keep');
+    expect(options).toEqual({ headers: HEADERS, signal: undefined });
+  });
+
   it('handles function tool calls', async () => {
     const client = new FakeClient();
     const response = {

packages/agents-openai/test/openaiResponsesModel.test.ts

@@ -74,6 +74,65 @@ describe('OpenAIResponsesModel', () => {
     });
   });
 
+  it('merges top-level reasoning and text settings into provider data for Responses API', async () => {
+    withTrace('test', async () => {
+      const fakeResponse = {
+        id: 'res-settings',
+        usage: {
+          input_tokens: 0,
+          output_tokens: 0,
+          total_tokens: 0,
+        },
+        output: [],
+      };
+      const createMock = vi.fn().mockResolvedValue(fakeResponse);
+      const fakeClient = {
+        responses: { create: createMock },
+      } as unknown as OpenAI;
+      const model = new OpenAIResponsesModel(fakeClient, 'gpt-settings');
+
+      const request = {
+        systemInstructions: undefined,
+        input: 'hi',
+        modelSettings: {
+          reasoning: { effort: 'medium', summary: 'concise' },
+          text: { verbosity: 'low' },
+          providerData: {
+            reasoning: { summary: 'override', note: 'provider' },
+            text: { tone: 'playful' },
+            customFlag: true,
+          },
+        },
+        tools: [],
+        outputType: 'text',
+        handoffs: [],
+        tracing: false,
+        signal: undefined,
+      };
+
+      await model.getResponse(request as any);
+
+      expect(createMock).toHaveBeenCalledTimes(1);
+      const [args] = createMock.mock.calls[0];
+      expect(args.reasoning).toEqual({
+        effort: 'medium',
+        summary: 'override',
+        note: 'provider',
+      });
+      expect(args.text).toEqual({ verbosity: 'low', tone: 'playful' });
+      expect(args.customFlag).toBe(true);
+
+      // ensure original provider data object was not mutated
+      expect(request.modelSettings.providerData.reasoning).toEqual({
+        summary: 'override',
+        note: 'provider',
+      });
+      expect(request.modelSettings.providerData.text).toEqual({
+        tone: 'playful',
+      });
+    });
+  });
+
   it('getStreamedResponse yields events and calls client with stream flag', async () => {
     withTrace('test', async () => {
       const fakeResponse = { id: 'res2', usage: {}, output: [] };