fix(ai): route OpenAI pro/codex models to Responses API

gpt-5.5-pro (and gpt-5-pro, o1/o3-pro, codex) are Responses-API-only and
404 on /chat/completions with 'not a chat model'. Detect them and route to
/v1/responses in both the ai-sidebar extension and the model-providers
adapter; other OpenAI-compatible providers stay on /chat/completions.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: ralyodio

apps/desktop/extensions/ai-sidebar/providers.js

@@ -57,6 +57,17 @@ export async function listModels(cfg) {
     .filter(Boolean);
 }
 
+/**
+ * OpenAI's "pro" reasoning models (gpt-5-pro, gpt-5.5-pro, o1-pro, o3-pro) and
+ * the codex models are served only by the Responses API (/v1/responses). Posting
+ * them to /chat/completions 404s with "This is not a chat model...". Route those
+ * to /responses. Only OpenAI itself has this endpoint — the other
+ * OpenAI-compatible providers stay on /chat/completions.
+ */
+export function usesResponsesApi(provider, model) {
+  return provider === 'openai' && /-pro(\b|-)|codex/i.test(model || '');
+}
+
 async function* sse(res) {
   const reader = res.body.getReader();
   const dec = new TextDecoder();
@@ -109,6 +120,32 @@ export async function chatStream(cfg, messages, onDelta) {
 
   const headers = { 'content-type': 'application/json' };
   if (cfg.apiKey) headers['authorization'] = 'Bearer ' + cfg.apiKey;
+
+  if (usesResponsesApi(cfg.provider, cfg.model)) {
+    // Responses API: `input` takes the same role/content messages; pro models
+    // reject `temperature`, so send only model + input. Deltas arrive as
+    // `response.output_text.delta` events instead of chat `choices[].delta`.
+    const res = await fetch(baseUrl + '/responses', {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({ model: cfg.model, input: messages, stream: true }),
+    });
+    if (!res.ok) throw new Error(cfg.provider + ' ' + res.status + ': ' + (await res.text()));
+    for await (const data of sse(res)) {
+      if (data === '[DONE]') break;
+      try {
+        const evt = JSON.parse(data);
+        if (evt.type === 'response.output_text.delta' && typeof evt.delta === 'string') {
+          full += evt.delta;
+          onDelta(evt.delta);
+        } else if (evt.type === 'response.completed' || evt.type === 'response.failed') {
+          break;
+        }
+      } catch { /* ignore keep-alives */ }
+    }
+    return full;
+  }
+
   const res = await fetch(baseUrl + '/chat/completions', {
     method: 'POST',
     headers,

packages/model-providers/src/adapter-openai.ts

@@ -19,6 +19,30 @@ export interface OpenAIAdapterConfig {
   fetchImpl?: typeof fetch;
 }
 
+/**
+ * OpenAI's "pro" reasoning models (gpt-5-pro, gpt-5.5-pro, o1-pro, o3-pro) and
+ * the codex models are served only by the Responses API (/v1/responses). Posting
+ * them to /chat/completions 404s with "This is not a chat model...". Route those
+ * to /responses. Only OpenAI itself exposes that endpoint — the other
+ * OpenAI-compatible providers (DeepSeek, Perplexity, …) stay on /chat/completions.
+ */
+export function usesResponsesApi(providerId: ProviderId, model: string): boolean {
+  return providerId === 'openai' && /-pro(\b|-)|codex/i.test(model);
+}
+
+/** Concatenates the text of every `output_text` part in a Responses `output`. */
+function extractResponsesText(
+  output?: { type?: string; content?: { type?: string; text?: string }[] }[],
+): string {
+  let text = '';
+  for (const item of output ?? []) {
+    for (const part of item.content ?? []) {
+      if (part.type === 'output_text' && part.text) text += part.text;
+    }
+  }
+  return text;
+}
+
 export class OpenAICompatibleProvider implements ModelProvider {
   constructor(
     readonly id: ProviderId,
@@ -44,6 +68,7 @@ export class OpenAICompatibleProvider implements ModelProvider {
   }
 
   async complete(req: CompletionRequest): Promise<CompletionResponse> {
+    if (usesResponsesApi(this.id, req.model)) return this.completeViaResponses(req);
     const res = await this.fetch(`${this.config.baseUrl}/chat/completions`, {
       method: 'POST',
       headers: this.headers(),
@@ -72,6 +97,10 @@ export class OpenAICompatibleProvider implements ModelProvider {
   }
 
   async *stream(req: CompletionRequest): AsyncIterable<CompletionChunk> {
+    if (usesResponsesApi(this.id, req.model)) {
+      yield* this.streamViaResponses(req);
+      return;
+    }
     const res = await this.fetch(`${this.config.baseUrl}/chat/completions`, {
       method: 'POST',
       headers: this.headers(),
@@ -101,6 +130,73 @@ export class OpenAICompatibleProvider implements ModelProvider {
     }
     yield { delta: '', done: true };
   }
+
+  /**
+   * Responses API (/v1/responses) path for OpenAI's pro/codex models. The
+   * role/content messages map straight onto `input`; pro models reject
+   * `temperature`, so it is omitted.
+   */
+  private async completeViaResponses(req: CompletionRequest): Promise<CompletionResponse> {
+    const res = await this.fetch(`${this.config.baseUrl}/responses`, {
+      method: 'POST',
+      headers: this.headers(),
+      body: JSON.stringify({
+        model: req.model,
+        input: req.messages,
+        max_output_tokens: req.maxTokens,
+        stream: false,
+      }),
+    });
+    if (!res.ok) throw new Error(`${this.id} completion failed: ${res.status} ${await res.text()}`);
+    const body = (await res.json()) as {
+      output_text?: string;
+      output?: { type?: string; content?: { type?: string; text?: string }[] }[];
+      usage?: { input_tokens: number; output_tokens: number };
+    };
+    const text = body.output_text ?? extractResponsesText(body.output);
+    const out: CompletionResponse = { text, model: req.model };
+    if (body.usage) {
+      out.usage = {
+        promptTokens: body.usage.input_tokens,
+        completionTokens: body.usage.output_tokens,
+      };
+    }
+    return out;
+  }
+
+  private async *streamViaResponses(req: CompletionRequest): AsyncIterable<CompletionChunk> {
+    const res = await this.fetch(`${this.config.baseUrl}/responses`, {
+      method: 'POST',
+      headers: this.headers(),
+      body: JSON.stringify({
+        model: req.model,
+        input: req.messages,
+        max_output_tokens: req.maxTokens,
+        stream: true,
+      }),
+    });
+    if (!res.ok || !res.body) {
+      throw new Error(`${this.id} stream failed: ${res.status}`);
+    }
+    for await (const data of sseLines(res.body)) {
+      if (data === '[DONE]') {
+        yield { delta: '', done: true };
+        return;
+      }
+      try {
+        const evt = JSON.parse(data) as { type?: string; delta?: string };
+        if (evt.type === 'response.output_text.delta' && typeof evt.delta === 'string') {
+          yield { delta: evt.delta, done: false };
+        } else if (evt.type === 'response.completed' || evt.type === 'response.failed') {
+          yield { delta: '', done: true };
+          return;
+        }
+      } catch {
+        // ignore keep-alive / non-JSON lines
+      }
+    }
+    yield { delta: '', done: true };
+  }
 }
 
 /** Yields the payload of each `data:` line from an SSE response stream. */

packages/model-providers/src/adapter.test.ts

@@ -63,6 +63,57 @@ describe('OpenAI-compatible adapter', () => {
     expect(out.join('')).toBe('Hello');
   });
 
+  it('routes OpenAI pro models through /responses', async () => {
+    const fetchImpl = vi.fn(async () =>
+      jsonResponse({
+        output: [{ type: 'message', content: [{ type: 'output_text', text: 'deep answer' }] }],
+        usage: { input_tokens: 7, output_tokens: 4 },
+      }),
+    ) as unknown as typeof fetch;
+
+    const provider = createProvider('openai', { apiKey: 'k', fetchImpl });
+    const res = await provider.complete({ model: 'gpt-5.5-pro', messages: [{ role: 'user', content: 'hi' }] });
+
+    expect(res.text).toBe('deep answer');
+    expect(res.usage).toEqual({ promptTokens: 7, completionTokens: 4 });
+    const [url, init] = (fetchImpl as unknown as ReturnType<typeof vi.fn>).mock.calls[0];
+    expect(url).toBe('https://api.openai.com/v1/responses');
+    const sent = JSON.parse((init as RequestInit).body as string);
+    expect(sent.input).toEqual([{ role: 'user', content: 'hi' }]);
+    expect(sent).not.toHaveProperty('messages');
+  });
+
+  it('streams OpenAI pro models from Responses events', async () => {
+    const fetchImpl = vi.fn(async () =>
+      sseResponse([
+        'data: {"type":"response.output_text.delta","delta":"Hel"}\n',
+        'data: {"type":"response.output_text.delta","delta":"lo"}\n',
+        'data: {"type":"response.completed"}\n',
+      ]),
+    ) as unknown as typeof fetch;
+
+    const provider = createProvider('openai', { apiKey: 'k', fetchImpl });
+    const out: string[] = [];
+    for await (const c of provider.stream({ model: 'gpt-5.5-pro', messages: [{ role: 'user', content: 'hi' }] })) {
+      if (c.delta) out.push(c.delta);
+    }
+    expect(out.join('')).toBe('Hello');
+    expect((fetchImpl as unknown as ReturnType<typeof vi.fn>).mock.calls[0][0]).toBe(
+      'https://api.openai.com/v1/responses',
+    );
+  });
+
+  it('keeps non-pro OpenAI models on /chat/completions', async () => {
+    const fetchImpl = vi.fn(async () =>
+      jsonResponse({ choices: [{ message: { content: 'ok' } }] }),
+    ) as unknown as typeof fetch;
+    const provider = createProvider('openai', { apiKey: 'k', fetchImpl });
+    await provider.complete({ model: 'gpt-5.5', messages: [{ role: 'user', content: 'hi' }] });
+    expect((fetchImpl as unknown as ReturnType<typeof vi.fn>).mock.calls[0][0]).toBe(
+      'https://api.openai.com/v1/chat/completions',
+    );
+  });
+
   it('throws on a non-ok response', async () => {
     const fetchImpl = vi.fn(async () => jsonResponse({ error: 'nope' }, false, 401)) as unknown as typeof fetch;
     const provider = createProvider('openai', { apiKey: 'bad', fetchImpl });