@theia/ai-openai 1.76.0-next.7 → 1.76.0

package/src/node/openai-language-models-manager-impl.spec.ts

@@ -18,11 +18,41 @@ import { expect } from 'chai';
 import { OpenAiModelDescription } from '../common';
 import { OpenAiLanguageModelsManagerImpl } from './openai-language-models-manager-impl';
 import { OPENAI_SERVER_TOOLS, OPENAI_WEB_SEARCH } from './openai-server-tools';
+import { APIConnectionError } from 'openai';
+import { MockLogger } from '@theia/core/lib/common/test/mock-logger';
+import { DiscoveredModel } from '@theia/ai-core';
+import { TestModelDiscoveryFetcher } from '@theia/ai-core/lib/node/test/test-model-discovery-fetcher';
 
 class TestableOpenAiLanguageModelsManagerImpl extends OpenAiLanguageModelsManagerImpl {
     resolveServerToolsForTest(description: OpenAiModelDescription): typeof OPENAI_SERVER_TOOLS | undefined {
         return this.resolveServerTools(description);
     }
+
+    public stubbedModels: Array<{ id: string; created?: number }> = [];
+    public listCalls = 0;
+    /** Throw {@link failWith} for the first `failTimes` list calls, then return {@link stubbedModels}. */
+    public failTimes = 0;
+    public failWith: Error = new Error('boom');
+    /** The real discovery fetcher, snapshotting in memory and retrying without waiting. */
+    public readonly testFetcher = new TestModelDiscoveryFetcher();
+    protected override readonly discoveryFetcher = this.testFetcher;
+
+    /** In-memory stand-in for the on-disk snapshot. */
+    public get snapshot(): DiscoveredModel[] | undefined {
+        return this.testFetcher.snapshot;
+    }
+
+    public set snapshot(models: DiscoveredModel[] | undefined) {
+        this.testFetcher.snapshot = models;
+    }
+
+    protected override async listModels(_apiKey: string, _proxyUrl: string | undefined): Promise<Array<{ id: string; created?: number }>> {
+        this.listCalls++;
+        if (this.listCalls <= this.failTimes) {
+            throw this.failWith;
+        }
+        return this.stubbedModels;
+    }
 }
 
 function modelDescription(overrides: Partial<OpenAiModelDescription> = {}): OpenAiModelDescription {
@@ -55,3 +85,151 @@ describe('OpenAiLanguageModelsManagerImpl server tools', () => {
         expect(manager.resolveServerToolsForTest(modelDescription())).to.equal(undefined);
     });
 });
+
+describe('OpenAiLanguageModelsManagerImpl - fetchAvailableModels', () => {
+    let manager: TestableOpenAiLanguageModelsManagerImpl;
+
+    beforeEach(() => {
+        manager = new TestableOpenAiLanguageModelsManagerImpl();
+        (manager as unknown as { logger: MockLogger }).logger = new MockLogger();
+        manager.setApiKey('key');
+    });
+
+    it('returns an empty result and skips the network when no API key is set', async () => {
+        const previous = process.env.OPENAI_API_KEY;
+        delete process.env.OPENAI_API_KEY;
+        try {
+            manager.setApiKey(undefined);
+            expect(await manager.fetchAvailableModels()).to.deep.equal({ models: [], fromCache: false });
+            expect(manager.listCalls).to.equal(0);
+        } finally {
+            if (previous !== undefined) { process.env.OPENAI_API_KEY = previous; }
+        }
+    });
+
+    it('keeps the text-chat families and drops the other model types the endpoint lists', async () => {
+        manager.stubbedModels = [
+            { id: 'gpt-5.5' },
+            { id: 'chatgpt-5-latest' },
+            { id: 'o3-mini' },
+            { id: 'gpt-4o-audio-preview' },
+            { id: 'gpt-image-1' },
+            { id: 'text-embedding-3-large' },
+            { id: 'omni-moderation-latest' },
+            { id: 'whisper-1' },
+            { id: 'computer-use-preview' },
+            { id: 'gpt-4o-search-preview' },
+            // Multimodal, so it speaks the realtime/live API rather than chat completions.
+            { id: 'gpt-live-1' },
+            // Caught by the same `search` term, and rightly so: it speaks the responses API, not this one.
+            { id: 'o3-deep-research' },
+            { id: 'gpt-3.5-turbo-instruct' },
+            { id: 'gpt-5.5' }
+        ];
+        const result = await manager.fetchAvailableModels();
+        expect(result.fromCache).to.equal(false);
+        expect(result.models.map(model => model.id)).to.deep.equal(['gpt-5.5', 'chatgpt-5-latest', 'o3-mini']);
+        expect(manager.snapshot).to.deep.equal(result.models);
+    });
+
+    it('recognises the legacy year-less snapshots as releases of one model', async () => {
+        manager.stubbedModels = [
+            { id: 'gpt-4-0613', created: 1_686_000_000 },
+            { id: 'gpt-4-0125', created: 1_706_000_000 },
+            { id: 'gpt-4-32k-0613', created: 1_686_000_000 }
+        ];
+        const result = await manager.fetchAvailableModels();
+        // Two aliases for the two models, then the snapshots they were derived from.
+        expect(result.models.map(model => model.id)).to.deep.equal([
+            'gpt-4',
+            'gpt-4-32k',
+            'gpt-4-0613',
+            'gpt-4-0125',
+            'gpt-4-32k-0613'
+        ]);
+    });
+
+    it('adds the undated alias of each release-pinned model, keeping the releases themselves', async () => {
+        manager.stubbedModels = [
+            { id: 'gpt-5.6-sol-2026-04-01' },
+            { id: 'gpt-5.6-sol-2025-11-20' },
+            { id: 'gpt-5.6-luna' }
+        ];
+        const result = await manager.fetchAvailableModels();
+        expect(result.models.map(model => model.id)).to.deep.equal([
+            'gpt-5.6-sol',
+            'gpt-5.6-sol-2026-04-01',
+            'gpt-5.6-sol-2025-11-20',
+            'gpt-5.6-luna'
+        ]);
+    });
+
+    it('reports the creation timestamp in milliseconds', async () => {
+        manager.stubbedModels = [{ id: 'gpt-5.5', created: 1_700_000_000 }];
+        const result = await manager.fetchAvailableModels();
+        expect(result.models[0].released).to.equal(1_700_000_000_000);
+    });
+
+    it('retries transient connection errors and then succeeds', async () => {
+        manager.stubbedModels = [{ id: 'gpt-5.5' }];
+        manager.failTimes = 2;
+        manager.failWith = new APIConnectionError({ message: 'network down' });
+        const result = await manager.fetchAvailableModels();
+        expect(result.models.map(model => model.id)).to.deep.equal(['gpt-5.5']);
+        expect(manager.listCalls).to.equal(3);
+    });
+
+    it('falls back to the cached snapshot when the fetch keeps failing', async () => {
+        manager.snapshot = [{ id: 'gpt-5.5' }];
+        manager.failTimes = 99;
+        manager.failWith = new APIConnectionError({ message: 'still down' });
+        const result = await manager.fetchAvailableModels();
+        expect(result).to.deep.equal({ models: [{ id: 'gpt-5.5' }], fromCache: true, error: 'still down' });
+        expect(manager.listCalls).to.equal(3);
+    });
+
+    it('does not retry auth errors and throws without a snapshot', async () => {
+        manager.failTimes = 99;
+        manager.failWith = new Error('401 unauthorized');
+        let threw = false;
+        try {
+            await manager.fetchAvailableModels();
+        } catch (error) {
+            threw = true;
+            expect((error as Error).message).to.equal('401 unauthorized');
+        }
+        expect(threw).to.be.true;
+        expect(manager.listCalls).to.equal(1);
+    });
+});
+
+describe('OpenAiLanguageModelsManagerImpl - environment API key consent', () => {
+
+    it('leaves an environment key unused until it is allowed, wherever a key would be read', async () => {
+        const previous = { OPENAI_API_KEY: process.env.OPENAI_API_KEY };
+        delete process.env.OPENAI_API_KEY;
+        process.env.OPENAI_API_KEY = 'from-the-environment';
+        try {
+            const manager = new TestableOpenAiLanguageModelsManagerImpl();
+            // The gate sits on the key, so a custom endpoint or a configured model cannot reach past it either.
+            expect(manager.apiKey).to.equal(undefined);
+            // Discovery still needs to know the key is there, in order to ask for it.
+            expect(await manager.getApiKeySource()).to.equal('environment');
+
+            manager.setAllowEnvironmentApiKey(true);
+            expect(manager.apiKey).to.equal('from-the-environment');
+
+            // Withdrawing the consent stops it being used at once.
+            manager.setAllowEnvironmentApiKey(false);
+            expect(manager.apiKey).to.equal(undefined);
+        } finally {
+            if (previous.OPENAI_API_KEY !== undefined) { process.env.OPENAI_API_KEY = previous.OPENAI_API_KEY; } else { delete process.env.OPENAI_API_KEY; }
+        }
+    });
+
+    it('uses a key set in the preferences whatever the environment says', () => {
+        const manager = new TestableOpenAiLanguageModelsManagerImpl();
+        manager.setApiKey('from-the-preference');
+        expect(manager.apiKey).to.equal('from-the-preference');
+    });
+});

package/src/node/openai-language-models-manager-impl.ts

@@ -14,16 +14,28 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { LanguageModelRegistry, LanguageModelStatus, ReasoningSupport } from '@theia/ai-core';
-import { getProxyUrl } from '@theia/ai-core/lib/node';
+import {
+    ApiKeySource, DiscoveredModel, DiscoveredModels, LanguageModelRegistry, LanguageModelStatus, ModelDiscoveryResult, ReasoningSupport
+} from '@theia/ai-core';
+import { getProxyUrl, ModelDiscoveryFetcher } from '@theia/ai-core/lib/node';
 import { inject, injectable, named } from '@theia/core/shared/inversify';
-import { DeveloperMessageSettings, OpenAiModel, OpenAiModelUtils } from './openai-language-model';
+import { APIConnectionError } from 'openai';
+import { createOpenAiClient, DeveloperMessageSettings, OpenAiModel, OpenAiModelUtils } from './openai-language-model';
 import { OpenAiResponseApiUtils } from './openai-response-api-utils';
 import { getOpenAiModelDefaults } from './openai-model-defaults';
 import { OpenAiLanguageModelsManager, OpenAiModelDescription } from '../common';
 import { ILogger } from '@theia/core';
 import { OPENAI_SERVER_TOOLS } from './openai-server-tools';
 
+const OPENAI_SNAPSHOT_FILE = 'openai-models.json';
+
+/** The part of an OpenAI `/v1/models` entry this manager reads. */
+interface ListedOpenAiModel {
+    id: string;
+    /** Creation time in seconds since the epoch. */
+    created?: number;
+}
+
 interface ResolvedModelMetadata {
     maxInputTokens?: number;
     reasoningSupport?: ReasoningSupport;
@@ -46,14 +58,94 @@ export class OpenAiLanguageModelsManagerImpl implements OpenAiLanguageModelsMana
     protected readonly logger: ILogger;
 
     protected _apiKey: string | undefined;
+    /**
+     * Whether a key found in the environment may be used. Withheld until the user confirms it, so the
+     * gate sits on the key itself: every path that reaches for one — discovery, a custom endpoint, a
+     * manually configured model — is covered, and revoking the consent takes effect at once.
+     */
+    protected _allowEnvironmentApiKey = false;
     protected _apiVersion: string | undefined;
     protected _proxyUrl: string | undefined;
 
     @inject(LanguageModelRegistry)
     protected readonly languageModelRegistry: LanguageModelRegistry;
 
+    @inject(ModelDiscoveryFetcher)
+    protected readonly discoveryFetcher: ModelDiscoveryFetcher;
+
     get apiKey(): string | undefined {
-        return this._apiKey ?? process.env.OPENAI_API_KEY;
+        return this._apiKey ?? (this._allowEnvironmentApiKey ? process.env.OPENAI_API_KEY : undefined);
+    }
+
+    async getApiKeySource(): Promise<ApiKeySource> {
+        if (this._apiKey) {
+            return 'preference';
+        }
+        if (process.env.OPENAI_API_KEY) {
+            return 'environment';
+        }
+        return 'none';
+    }
+
+    async fetchAvailableModels(): Promise<ModelDiscoveryResult> {
+        const apiKey = this.apiKey;
+        if (!apiKey) {
+            return { models: [], fromCache: false };
+        }
+        const proxyUrl = getProxyUrl('https://api.openai.com', this._proxyUrl);
+        return this.discoveryFetcher.fetch({
+            snapshotFile: OPENAI_SNAPSHOT_FILE,
+            providerLabel: 'OpenAI',
+            listModels: async () => this.toDiscoveredModels(await this.listModels(apiKey, proxyUrl)),
+            // Retry only transient connection errors; auth/HTTP errors fail fast.
+            isRetryable: error => error instanceof APIConnectionError
+        });
+    }
+
+    /**
+     * Maps the endpoint's entries onto {@link DiscoveredModel}s and adds the undated alias of every
+     * release-pinned id. The endpoint reports no display name or description — only the id, the
+     * owner and a creation timestamp — so a discovered OpenAI model carries no label.
+     */
+    protected toDiscoveredModels(models: ListedOpenAiModel[]): DiscoveredModel[] {
+        const byId = new Map<string, DiscoveredModel>();
+        for (const model of models) {
+            // OpenAI's /v1/models lists every model type (embeddings, audio, image, …) with no capability
+            // metadata, so we heuristically keep the text-chat families. Custom endpoints cover the rest.
+            if (this.isChatModelId(model.id) && !byId.has(model.id)) {
+                // `created` is in seconds; DiscoveredModel.released is in milliseconds.
+                byId.set(model.id, { id: model.id, released: model.created === undefined ? undefined : model.created * 1000 });
+            }
+        }
+        return DiscoveredModels.withUndatedAliases([...byId.values()]);
+    }
+
+    /**
+     * Heuristic for the text-chat models among everything `/v1/models` reports: the `gpt-*`,
+     * `chatgpt-*` and `o1`/`o3`/`o4`-style families, minus the variants that speak a different API
+     * than chat completions: audio, realtime, live, transcription, speech, image, embeddings,
+     * moderation, the search and computer-use tool endpoints, and the legacy `-instruct` completion
+     * models.
+     *
+     * The terms match anywhere in the id, so a family that carries one in a longer word goes with it
+     * (`o3-deep-research`, which speaks the responses API and not this one). Anything this drops or
+     * misses can still be configured as a custom endpoint.
+     */
+    protected isChatModelId(id: string): boolean {
+        if (!/^(gpt|chatgpt|o\d)/.test(id)) {
+            return false;
+        }
+        return !/(audio|realtime|-live|transcribe|tts|image|embedding|moderation|search|computer-use|-instruct)/.test(id);
+    }
+
+    /** Iterates the (auto-paginated) `/v1/models` endpoint. Overridable for testing. */
+    protected async listModels(apiKey: string, proxyUrl: string | undefined): Promise<ListedOpenAiModel[]> {
+        const openai = createOpenAiClient({ apiKey, proxyUrl });
+        const models: ListedOpenAiModel[] = [];
+        for await (const model of openai.models.list()) {
+            models.push(model);
+        }
+        return models;
     }
 
     get apiVersion(): string | undefined {
@@ -122,7 +214,9 @@ export class OpenAiLanguageModelsManagerImpl implements OpenAiLanguageModelsMana
                     serverTools,
                     serverSideCompactionSupport: metadata.serverSideCompactionSupport,
                     serverSideCompactionEnabledByDefault: modelDescription.serverSideCompactionEnabledByDefault ?? false,
-                    serverSideCompactionTokenThresholdByDefault: modelDescription.serverSideCompactionTokenThresholdByDefault
+                    serverSideCompactionTokenThresholdByDefault: modelDescription.serverSideCompactionTokenThresholdByDefault,
+                    headers: modelDescription.headers,
+                    released: modelDescription.released
                 });
             } else {
                 this.languageModelRegistry.addLanguageModels([
@@ -147,7 +241,9 @@ export class OpenAiLanguageModelsManagerImpl implements OpenAiLanguageModelsMana
                         serverTools,
                         metadata.serverSideCompactionSupport,
                         modelDescription.serverSideCompactionEnabledByDefault ?? false,
-                        modelDescription.serverSideCompactionTokenThresholdByDefault
+                        modelDescription.serverSideCompactionTokenThresholdByDefault,
+                        modelDescription.headers,
+                        modelDescription.released
                     )
                 ]);
             }
@@ -181,6 +277,10 @@ export class OpenAiLanguageModelsManagerImpl implements OpenAiLanguageModelsMana
         this.languageModelRegistry.removeLanguageModels(modelIds);
     }
 
+    setAllowEnvironmentApiKey(allowed: boolean): void {
+        this._allowEnvironmentApiKey = allowed;
+    }
+
     setApiKey(apiKey: string | undefined): void {
         if (apiKey) {
             this._apiKey = apiKey;

package/src/node/openai-model-defaults.spec.ts

@@ -22,6 +22,16 @@ describe('getOpenAiModelDefaults', () => {
         expect(getOpenAiModelDefaults('totally-made-up-model')).to.deep.equal({});
     });
 
+    describe('GPT-6 Astra', () => {
+        it('matches gpt-6-astra at 1,050,000 with reasoning that drops `minimal`', () => {
+            const d = getOpenAiModelDefaults('gpt-6-astra');
+            expect(d.contextWindow).to.equal(1_050_000);
+            expect(d.reasoningSupport?.supportedLevels).to.not.include('minimal');
+            expect(d.reasoningSupport?.supportedLevels).to.include('high');
+            expect(d.reasoningSupport?.defaultLevel).to.equal('auto');
+        });
+    });
+
     describe('GPT-5.6', () => {
         it('matches the sol, terra, and luna tiers at 1,050,000 with GPT-5 reasoning', () => {
             for (const id of ['gpt-5.6-sol', 'gpt-5.6-terra', 'gpt-5.6-luna']) {

package/src/node/openai-model-defaults.ts

@@ -41,12 +41,20 @@ const O_SERIES_REASONING_SUPPORT: ReasoningSupport = {
     defaultLevel: 'auto'
 };
 
+// GPT-6 Astra reasons at every setting: it dropped the `none`/`minimal` efforts of the GPT-5 family.
+// Its `xhigh`/`max` efforts have no representation in ReasoningLevel, so we expose the mappable subset.
+const GPT6_REASONING_SUPPORT: ReasoningSupport = {
+    supportedLevels: ['low', 'medium', 'high', 'auto'],
+    defaultLevel: 'auto'
+};
+
 /**
  * First matching prefix wins, so more specific prefixes must come before broader ones
  * (e.g. `gpt-5.4-mini` before `gpt-5.4`). Snapshots inherit their family value
  * (e.g. `gpt-4o-2024-08-06` matches `gpt-4o`).
  */
 const OPENAI_MODEL_FAMILIES: ReadonlyArray<readonly [prefix: string, defaults: OpenAiModelDefaults]> = [
+    ['gpt-6', { contextWindow: 1_050_000, reasoningSupport: GPT6_REASONING_SUPPORT }],
     ['gpt-5.6', { contextWindow: 1_050_000, reasoningSupport: GPT5_REASONING_SUPPORT }],
     ['gpt-5.5', { contextWindow: 1_050_000, reasoningSupport: GPT5_REASONING_SUPPORT }],
     ['gpt-5.4-mini', { contextWindow: 400_000, reasoningSupport: GPT5_REASONING_SUPPORT }],

package/src/node/openai-reasoning.ts

@@ -21,8 +21,7 @@ import { ReasoningLevel } from '@theia/ai-core';
  * Returns `{}` when reasoning is not requested, unsupported, or disabled — so the caller
  * can spread it unconditionally.
  *
- * @param forResponseApi `true` for the Responses API (`reasoning: { effort }`, supports `minimal`);
- *                        `false` for Chat Completions (`reasoning_effort`, `low`|`medium`|`high` only).
+ * @param forResponseApi `true` for the Responses API (`reasoning: { effort, summary }`), `false` for Chat Completions (`reasoning_effort`).
  * @param supportsReasoning `false` for models without reasoning support — returns `{}`.
  */
 export function openAiReasoningFor(
@@ -40,13 +39,11 @@ export function openAiReasoningFor(
                     level === 'medium' ? 'medium' :
                         level === 'high' ? 'high' :
                             undefined;
-        return responsesEffort ? { reasoning: { effort: responsesEffort } } : {};
+        // Summaries are opt-in on the Responses API: without `summary` the model still reasons, but nothing is streamed to show.
+        return { reasoning: { ...(responsesEffort ? { effort: responsesEffort } : {}), summary: 'auto' } };
     }
-    // Chat Completions has no 'minimal' — map it down to 'low'.
-    const chatEffort =
-        level === 'minimal' || level === 'low' ? 'low' :
-            level === 'medium' ? 'medium' :
-                level === 'high' ? 'high' :
-                    undefined;
+    // Chat Completions takes the same effort values, `minimal` included. Models that reject it (e.g. o-series)
+    // leave it out of their `supportedLevels`, and the level is clamped to those before it gets here.
+    const chatEffort = level === 'minimal' || level === 'low' || level === 'medium' || level === 'high' ? level : undefined;
     return chatEffort ? { reasoning_effort: chatEffort } : {};
 }

package/src/node/openai-response-api-utils.spec.ts

@@ -16,10 +16,12 @@
 
 import { expect } from 'chai';
 import {
-    CompactionMessage, isCompactionResponsePart, isServerToolCallResponsePart, isUsageResponsePart, LanguageModelMessage, LanguageModelStreamResponsePart, UserRequest
+    CompactionMessage, isCompactionResponsePart, isServerToolCallResponsePart, isTextResponsePart, isThinkingResponsePart, isUsageResponsePart,
+    LanguageModelMessage, LanguageModelResponse, LanguageModelStreamResponsePart, UserRequest
 } from '@theia/ai-core';
 import { OpenAiModelUtils } from './openai-language-model';
 import { MockLogger } from '@theia/core/lib/common/test/mock-logger';
+import { OpenAI } from 'openai';
 import { OPENAI_FUNCTION_CALL_REASONING_DATA_KEY, OpenAiResponseApiUtils } from './openai-response-api-utils';
 import { OPENAI_WEB_SEARCH, OPENAI_WEB_SEARCH_REPLAY_DATA_KEY } from './openai-server-tools';
 
@@ -555,6 +557,187 @@ describe('OpenAiResponseApiUtils', () => {
         }]);
     });
 
+    describe('reasoning summaries', () => {
+        // Two summary parts of one reasoning item, as the Responses API streams them with `reasoning.summary` set.
+        const summaryEvents = [
+            { type: 'response.reasoning_summary_part.added', item_id: 'rs-1', output_index: 0, summary_index: 0, part: { type: 'summary_text', text: '' } },
+            { type: 'response.reasoning_summary_text.delta', item_id: 'rs-1', output_index: 0, summary_index: 0, delta: 'Weighing ' },
+            { type: 'response.reasoning_summary_text.delta', item_id: 'rs-1', output_index: 0, summary_index: 0, delta: 'options' },
+            { type: 'response.reasoning_summary_part.added', item_id: 'rs-1', output_index: 0, summary_index: 1, part: { type: 'summary_text', text: '' } },
+            { type: 'response.reasoning_summary_text.delta', item_id: 'rs-1', output_index: 0, summary_index: 1, delta: 'Deciding' }
+        ];
+
+        async function drain(response: LanguageModelResponse): Promise<LanguageModelStreamResponsePart[]> {
+            const parts: LanguageModelStreamResponsePart[] = [];
+            if ('stream' in response) {
+                for await (const part of response.stream) {
+                    parts.push(part);
+                }
+            }
+            return parts;
+        }
+
+        function thoughts(parts: LanguageModelStreamResponsePart[]): string {
+            return parts.filter(isThinkingResponsePart).map(part => part.thought).join('');
+        }
+
+        it('streams reasoning summaries as thoughts, separating summary parts', async () => {
+            const openai = {
+                responses: {
+                    stream: () => toStream([...summaryEvents, { type: 'response.output_text.delta', delta: 'Answer' }])
+                }
+            };
+            const request: UserRequest = {
+                sessionId: 'session-1',
+                requestId: 'request-1',
+                messages: [{ actor: 'user', type: 'text', text: 'hello' }]
+            };
+
+            const parts = await drain(await utils.handleRequest(
+                openai as never, request, {}, 'gpt-5', new OpenAiModelUtils(), 'developer',
+                { maxChatCompletions: 3 }, 'openai/gpt-5', true
+            ));
+
+            expect(thoughts(parts)).to.equal('Weighing options\n\nDeciding');
+            expect(parts.filter(isTextResponsePart).map(part => part.content).join('')).to.equal('Answer');
+        });
+
+        it('streams reasoning summaries as thoughts while tool calling', async () => {
+            const streams = [
+                [
+                    ...summaryEvents,
+                    {
+                        type: 'response.output_item.added',
+                        item: { id: 'item-1', call_id: 'call-1', type: 'function_call', name: 'lookup', arguments: '{}' }
+                    }
+                ],
+                [{ type: 'response.output_text.delta', delta: 'done' }]
+            ];
+            const openai = {
+                responses: {
+                    stream: () => toStream(streams.shift() ?? [])
+                }
+            };
+            const request: UserRequest = {
+                sessionId: 'session-1',
+                requestId: 'request-1',
+                messages: [{ actor: 'user', type: 'text', text: 'hello' }],
+                tools: [{
+                    id: 'lookup',
+                    name: 'lookup',
+                    parameters: { type: 'object', properties: {} },
+                    handler: async () => 'result'
+                }]
+            };
+
+            const parts = await drain(await utils.handleRequest(
+                openai as never, request, {}, 'gpt-5', new OpenAiModelUtils(), 'developer',
+                { maxChatCompletions: 3 }, 'openai/gpt-5', true
+            ));
+
+            expect(thoughts(parts)).to.equal('Weighing options\n\nDeciding');
+        });
+
+        describe('unverified organizations', () => {
+            const summarySettings = { reasoning: { effort: 'medium', summary: 'auto' } };
+            const request: UserRequest = {
+                sessionId: 'session-1',
+                requestId: 'request-1',
+                messages: [{ actor: 'user', type: 'text', text: 'hello' }]
+            };
+
+            function badRequest(param: string): Error {
+                const message = `400 Your organization must be verified to generate reasoning summaries (param: ${param})`;
+                return new OpenAI.BadRequestError(400, { message, param }, message, new Headers());
+            }
+
+            async function* rejectingStream(error: Error): AsyncIterable<unknown> {
+                throw error;
+            }
+
+            function summaryOf(params: { reasoning?: { summary?: string } }): string | undefined {
+                return params.reasoning?.summary;
+            }
+
+            it('retries a stream without the summary and omits it for later requests', async () => {
+                const sent: { reasoning?: { effort?: string; summary?: string } }[] = [];
+                const openai = {
+                    responses: {
+                        stream: (params: { reasoning?: { summary?: string } }) => {
+                            sent.push(params);
+                            return summaryOf(params)
+                                ? rejectingStream(badRequest('reasoning.summary'))
+                                : toStream([{ type: 'response.output_text.delta', delta: 'Answer' }]);
+                        }
+                    }
+                };
+                const send = async () => drain(await utils.handleRequest(
+                    openai as never, request, summarySettings, 'gpt-5', new OpenAiModelUtils(), 'developer',
+                    { maxChatCompletions: 3 }, 'openai/gpt-5', true
+                ));
+
+                const parts = await send();
+                await send();
+
+                expect(parts.filter(isTextResponsePart).map(part => part.content).join('')).to.equal('Answer');
+                expect(sent.map(summaryOf)).to.deep.equal(['auto', undefined, undefined]);
+                expect(sent[1].reasoning?.effort).to.equal('medium');
+            });
+
+            it('retries a non-streaming tool-calling request without the summary', async () => {
+                const sent: { reasoning?: { summary?: string } }[] = [];
+                const openai = {
+                    responses: {
+                        create: async (params: { reasoning?: { summary?: string } }) => {
+                            sent.push(params);
+                            if (summaryOf(params)) {
+                                throw badRequest('reasoning.summary');
+                            }
+                            return { output_text: 'done', output: [] };
+                        }
+                    }
+                };
+                const toolRequest: UserRequest = {
+                    ...request,
+                    tools: [{ id: 'lookup', name: 'lookup', parameters: { type: 'object', properties: {} }, handler: async () => 'result' }]
+                };
+
+                const parts = await drain(await utils.handleRequest(
+                    openai as never, toolRequest, summarySettings, 'gpt-5', new OpenAiModelUtils(), 'developer',
+                    { maxChatCompletions: 3 }, 'openai/gpt-5', false
+                ));
+
+                expect(parts.filter(isTextResponsePart).map(part => part.content).join('')).to.equal('done');
+                expect(sent.map(summaryOf)).to.deep.equal(['auto', undefined]);
+            });
+
+            it('does not retry other bad requests', async () => {
+                let calls = 0;
+                const openai = {
+                    responses: {
+                        create: async () => {
+                            calls++;
+                            throw badRequest('reasoning.effort');
+                        }
+                    }
+                };
+
+                let error: unknown;
+                try {
+                    await utils.handleRequest(
+                        openai as never, request, summarySettings, 'gpt-5', new OpenAiModelUtils(), 'developer',
+                        { maxChatCompletions: 3 }, 'openai/gpt-5', false
+                    );
+                } catch (e) {
+                    error = e;
+                }
+
+                expect(error).to.be.instanceOf(OpenAI.BadRequestError);
+                expect(calls).to.equal(1);
+            });
+        });
+    });
+
     describe('processMessages server-side compaction replay', () => {
 
         function userMessage(text: string): LanguageModelMessage {