@moxxy/plugin-provider-openai-codex 0.41.2 → 0.42.0

package/src/live/gpt-live-call.test.ts

@@ -0,0 +1,169 @@
+import { once } from 'node:events';
+import { createServer, type IncomingHttpHeaders, type ServerResponse } from 'node:http';
+import type { AddressInfo } from 'node:net';
+import { afterEach, describe, expect, it } from 'vitest';
+import {
+  GPT_LIVE_MODEL,
+  GptLiveCallClient,
+  buildGptLiveCallsUrl,
+} from './gpt-live-call.js';
+
+// The ChatGPT realtime backend is an external network API, so these tests stand
+// up a real loopback HTTP server in its place (the same seam the Codex
+// transcriber uses). Everything on the moxxy side — URL, headers, body, SDP and
+// Location parsing — runs for real.
+interface Captured {
+  readonly method: string;
+  readonly url: string;
+  readonly headers: IncomingHttpHeaders;
+  readonly body: unknown;
+}
+
+const OFFER = 'v=0\r\no=- 1 2 IN IP4 127.0.0.1\r\ns=-\r\nt=0 0\r\n';
+const ANSWER = 'v=0\r\no=- 3 4 IN IP4 0.0.0.0\r\ns=-\r\nt=0 0\r\na=ice-lite\r\n';
+const closers: Array<() => Promise<void>> = [];
+
+afterEach(async () => {
+  await Promise.all(closers.splice(0).map((close) => close()));
+});
+
+async function startBackend(
+  respond: (res: ServerResponse) => void,
+): Promise<{ readonly baseUrl: string; readonly requests: Captured[] }> {
+  const requests: Captured[] = [];
+  const server = createServer(async (req, res) => {
+    const chunks: Buffer[] = [];
+    for await (const chunk of req) chunks.push(Buffer.from(chunk as Buffer));
+    const raw = Buffer.concat(chunks).toString('utf8');
+    requests.push({
+      method: req.method ?? '',
+      url: req.url ?? '',
+      headers: req.headers,
+      body: raw ? JSON.parse(raw) : null,
+    });
+    respond(res);
+  });
+  server.listen(0, '127.0.0.1');
+  await once(server, 'listening');
+  closers.push(
+    () =>
+      new Promise((resolve) => {
+        server.closeAllConnections();
+        server.close(() => resolve());
+      }),
+  );
+  const { port } = server.address() as AddressInfo;
+  return { baseUrl: `http://127.0.0.1:${port}/backend-api`, requests };
+}
+
+function answerWith(res: ServerResponse): void {
+  res.writeHead(201, {
+    'content-type': 'text/plain; charset=utf-8',
+    location: '/v1/realtime/calls/rtc_u32_ETCRZp3oN5zeME7AqoW9SLcJTYbQ5Vvy',
+  });
+  res.end(ANSWER);
+}
+
+function client(baseUrl: string): GptLiveCallClient {
+  return new GptLiveCallClient({
+    baseUrl,
+    sessionIdProvider: () => 'voice-session-1',
+    resolveCredentials: async () => ({ accessToken: 'access-token-123', accountId: 'acct-9' }),
+  });
+}
+
+describe('GptLiveCallClient', () => {
+  it('negotiates a GPT-Live WebRTC call with the existing ChatGPT OAuth credentials', async () => {
+    const backend = await startBackend(answerWith);
+
+    const answer = await client(backend.baseUrl).start({
+      sdp: OFFER,
+      instructions: 'Answer the user yourself.',
+      history: [
+        { role: 'user', text: 'Sekretne słowo to pomarańcza.' },
+        { role: 'assistant', text: 'Zapamiętałem.' },
+      ],
+    });
+
+    expect(answer).toEqual({ sdp: ANSWER, callId: 'rtc_u32_ETCRZp3oN5zeME7AqoW9SLcJTYbQ5Vvy' });
+    const [request] = backend.requests;
+    expect(request?.method).toBe('POST');
+    expect(request?.url).toBe('/backend-api/codex/realtime/calls?intent=quicksilver&architecture=avas');
+    expect(request?.headers).toMatchObject({
+      authorization: 'Bearer access-token-123',
+      'chatgpt-account-id': 'acct-9',
+      'openai-alpha': 'quicksilver=v2',
+      originator: 'codex_cli_rs',
+      'x-session-id': 'voice-session-1',
+      accept: 'application/sdp',
+      'content-type': 'application/json',
+    });
+    expect(request?.body).toEqual({
+      sdp: OFFER,
+      session: {
+        instructions: 'Answer the user yourself.',
+        model: GPT_LIVE_MODEL,
+        audio: { output: { voice: 'maple' } },
+        delegation: { type: 'client' },
+        initial_items: [
+          { type: 'message', role: 'user', content: [{ type: 'input_text', text: 'Sekretne słowo to pomarańcza.' }] },
+          { type: 'message', role: 'assistant', content: [{ type: 'output_text', text: 'Zapamiętałem.' }] },
+        ],
+      },
+    });
+  });
+
+  it('omits initial items for an empty conversation', async () => {
+    const backend = await startBackend(answerWith);
+
+    await client(backend.baseUrl).start({ sdp: OFFER, instructions: 'Hi.', history: [] });
+
+    const body = backend.requests[0]?.body as { session: Record<string, unknown> };
+    expect(body.session).not.toHaveProperty('initial_items');
+  });
+
+  it('surfaces the backend rejection without leaking the bearer token', async () => {
+    const backend = await startBackend((res) => {
+      res.writeHead(403, { 'content-type': 'application/json' });
+      res.end('{"detail":"Voice session access denied"}');
+    });
+
+    const failure = client(backend.baseUrl).start({ sdp: OFFER, instructions: 'x', history: [] });
+
+    await expect(failure).rejects.toThrow(/403.*Voice session access denied/);
+    await expect(failure).rejects.not.toThrow(/access-token-123/);
+  });
+
+  it('rejects an answer without a call location', async () => {
+    const backend = await startBackend((res) => {
+      res.writeHead(201, { 'content-type': 'text/plain' });
+      res.end(ANSWER);
+    });
+
+    await expect(
+      client(backend.baseUrl).start({ sdp: OFFER, instructions: 'x', history: [] }),
+    ).rejects.toThrow(/Location/);
+  });
+
+  it('rejects an invalid offer before any credential leaves the process', async () => {
+    const backend = await startBackend(answerWith);
+
+    await expect(
+      client(backend.baseUrl).start({ sdp: 'not-an-sdp', instructions: 'x', history: [] }),
+    ).rejects.toThrow(/offer/);
+    expect(backend.requests).toHaveLength(0);
+  });
+});
+
+describe('buildGptLiveCallsUrl', () => {
+  it('targets the ChatGPT backend by default', () => {
+    expect(buildGptLiveCallsUrl()).toBe(
+      'https://chatgpt.com/backend-api/codex/realtime/calls?intent=quicksilver&architecture=avas',
+    );
+  });
+
+  it('refuses to send OAuth credentials to any other origin', () => {
+    expect(() => buildGptLiveCallsUrl('https://evil.example/backend-api')).toThrow(/Refusing/);
+    expect(() => buildGptLiveCallsUrl('http://chatgpt.com/backend-api')).toThrow(/Refusing/);
+  });
+});

package/src/live/gpt-live-call.ts

@@ -0,0 +1,148 @@
+import { randomUUID } from 'node:crypto';
+import { ORIGINATOR } from '../oauth.js';
+import type { GptLiveHistoryItem } from './gpt-live-history.js';
+
+/**
+ * GPT-Live over the user's existing ChatGPT OAuth login.
+ *
+ * The public `/v1/live/sessions` API requires a platform API key; a ChatGPT
+ * subscription reaches GPT-Live only through the Codex realtime route below —
+ * the same one the open-source Codex app-server uses. It is an undocumented
+ * preview contract, so every wire detail lives in this one module.
+ */
+export const DEFAULT_GPT_LIVE_BASE_URL = 'https://chatgpt.com/backend-api';
+export const GPT_LIVE_MODEL = 'gpt-live-1-codex';
+export const GPT_LIVE_DEFAULT_VOICE = 'maple';
+const GPT_LIVE_PROTOCOL = 'quicksilver=v2';
+const CALLS_PATH = '/codex/realtime/calls';
+const CALLS_QUERY = '?intent=quicksilver&architecture=avas';
+const DEFAULT_TIMEOUT_MS = 30_000;
+const MAX_SDP_BYTES = 1_000_000;
+const MAX_ERROR_CHARS = 2_048;
+const CALL_ID = /^(rtc_[A-Za-z0-9_-]+|[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/i;
+
+export interface GptLiveCredentials {
+  readonly accessToken: string;
+  readonly accountId?: string;
+}
+
+export interface GptLiveCallStart {
+  /** The browser-created WebRTC offer. */
+  readonly sdp: string;
+  readonly instructions: string;
+  /** Conversation the model should already know when the call opens. */
+  readonly history: ReadonlyArray<GptLiveHistoryItem>;
+  readonly voice?: string;
+}
+
+export interface GptLiveCallAnswer {
+  readonly sdp: string;
+  readonly callId: string;
+}
+
+export interface GptLiveCallClientOptions {
+  readonly resolveCredentials: () => Promise<GptLiveCredentials>;
+  /** `https://chatgpt.com/backend-api`, or a loopback host for tests. */
+  readonly baseUrl?: string;
+  readonly sessionIdProvider?: () => string;
+  readonly timeoutMs?: number;
+}
+
+/** Negotiates one GPT-Live WebRTC call; audio and events then flow peer-to-peer. */
+export class GptLiveCallClient {
+  private readonly resolveCredentials: () => Promise<GptLiveCredentials>;
+  private readonly callsUrl: string;
+  private readonly sessionIdProvider: () => string;
+  private readonly timeoutMs: number;
+
+  constructor(options: GptLiveCallClientOptions) {
+    this.resolveCredentials = options.resolveCredentials;
+    this.callsUrl = buildGptLiveCallsUrl(options.baseUrl);
+    this.sessionIdProvider = options.sessionIdProvider ?? randomUUID;
+    this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  }
+
+  async start(input: GptLiveCallStart): Promise<GptLiveCallAnswer> {
+    assertSdp(input.sdp, 'offer');
+    const credentials = await this.resolveCredentials();
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+      Accept: 'application/sdp',
+      Authorization: `Bearer ${credentials.accessToken}`,
+      originator: ORIGINATOR,
+      'openai-alpha': GPT_LIVE_PROTOCOL,
+      'x-session-id': this.sessionIdProvider(),
+    };
+    if (credentials.accountId) headers['ChatGPT-Account-Id'] = credentials.accountId;
+
+    const response = await fetch(this.callsUrl, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({ sdp: input.sdp, session: buildGptLiveSession(input) }),
+      signal: AbortSignal.timeout(this.timeoutMs),
+    });
+    const body = await response.text();
+    if (!response.ok) {
+      throw new Error(
+        `GPT-Live returned ${response.status}: ${body.slice(0, MAX_ERROR_CHARS) || response.statusText}`,
+      );
+    }
+    assertSdp(body, 'answer');
+    return { sdp: body, callId: parseCallId(response.headers.get('location')) };
+  }
+}
+
+function buildGptLiveSession(input: GptLiveCallStart): Record<string, unknown> {
+  const session: Record<string, unknown> = {
+    instructions: input.instructions,
+    model: GPT_LIVE_MODEL,
+    audio: { output: { voice: input.voice ?? GPT_LIVE_DEFAULT_VOICE } },
+    // `client` delegation keeps every task request on this side, where moxxy
+    // runs the user's own words as an agent turn rather than letting a backend
+    // model act on its paraphrase.
+    delegation: { type: 'client' },
+  };
+  if (input.history.length > 0) {
+    session.initial_items = input.history.map((item) => ({
+      type: 'message',
+      role: item.role,
+      content: [{ type: item.role === 'user' ? 'input_text' : 'output_text', text: item.text }],
+    }));
+  }
+  return session;
+}
+
+/**
+ * The call carries a live bearer token, so a configurable base URL may only
+ * point at https://chatgpt.com or a loopback host (the local test seam).
+ */
+export function buildGptLiveCallsUrl(baseUrl = DEFAULT_GPT_LIVE_BASE_URL): string {
+  const url = new URL(baseUrl);
+  const httpsChatgpt = url.protocol === 'https:' && url.hostname === 'chatgpt.com';
+  if (!httpsChatgpt && !isLoopbackHostname(url.hostname)) {
+    throw new Error(
+      `Refusing to send ChatGPT OAuth credentials to ${url.origin}; GPT-Live must use https://chatgpt.com.`,
+    );
+  }
+  return `${url.origin}${url.pathname.replace(/\/+$/, '')}${CALLS_PATH}${CALLS_QUERY}`;
+}
+
+function isLoopbackHostname(hostname: string): boolean {
+  const host = hostname.replace(/^\[|\]$/g, '').toLowerCase();
+  return host === 'localhost' || host === '127.0.0.1' || host === '::1';
+}
+
+function assertSdp(value: string, kind: 'offer' | 'answer'): void {
+  if (!value.startsWith('v=0') || Buffer.byteLength(value, 'utf8') > MAX_SDP_BYTES) {
+    throw new Error(`Invalid GPT-Live ${kind} SDP`);
+  }
+}
+
+function parseCallId(location: string | null): string {
+  const path = location ? location.split('?', 1).join('') : '';
+  const segment = path.split('/').filter(Boolean).at(-1);
+  if (!segment || !CALL_ID.test(segment)) {
+    throw new Error('GPT-Live answer is missing a valid Location header');
+  }
+  return segment;
+}

package/src/live/gpt-live-history.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, it } from 'vitest';
+import {
+  asEventId,
+  asSessionId,
+  asTurnId,
+  type MoxxyEvent,
+} from '@moxxy/sdk';
+import {
+  GPT_LIVE_HISTORY_MAX_ITEMS,
+  GPT_LIVE_HISTORY_MAX_ITEM_CHARS,
+  buildGptLiveHistory,
+} from './gpt-live-history.js';
+
+let seq = 0;
+function base(turn: string) {
+  seq += 1;
+  return {
+    id: asEventId(`event-${seq}`),
+    seq,
+    ts: seq,
+    sessionId: asSessionId('session-1'),
+    turnId: asTurnId(turn),
+  };
+}
+
+function prompt(text: string, turn = `turn-${seq}`): MoxxyEvent {
+  return { ...base(turn), type: 'user_prompt', source: 'user', text };
+}
+
+function reply(content: string, turn = `turn-${seq}`): MoxxyEvent {
+  return { ...base(turn), type: 'assistant_message', source: 'model', content, stopReason: 'end_turn' };
+}
+
+describe('buildGptLiveHistory', () => {
+  it('maps the chat conversation to ordered user and assistant items', () => {
+    const history = buildGptLiveHistory([
+      prompt('Sekretne słowo to pomarańcza.'),
+      { ...base('turn-x'), type: 'tool_result', source: 'tool', callId: 'c1', output: 'ignored' } as unknown as MoxxyEvent,
+      reply('Zapamiętałem sekretne słowo.'),
+    ]);
+
+    expect(history).toEqual([
+      { role: 'user', text: 'Sekretne słowo to pomarańcza.' },
+      { role: 'assistant', text: 'Zapamiętałem sekretne słowo.' },
+    ]);
+  });
+
+  it('skips blank messages and mid-turn checkpoint prompts', () => {
+    const checkpoint = {
+      ...prompt('Verify your work before finishing.'),
+      origin: { kind: 'checkpoint', name: 'verify' },
+    } as MoxxyEvent;
+
+    const history = buildGptLiveHistory([prompt('   '), checkpoint, reply('Gotowe.')]);
+
+    expect(history).toEqual([{ role: 'assistant', text: 'Gotowe.' }]);
+  });
+
+  it('keeps only the newest items when the conversation exceeds the item limit', () => {
+    const events = Array.from({ length: GPT_LIVE_HISTORY_MAX_ITEMS + 10 }, (_, index) =>
+      prompt(`wiadomość ${index}`),
+    );
+
+    const history = buildGptLiveHistory(events);
+
+    expect(history).toHaveLength(GPT_LIVE_HISTORY_MAX_ITEMS);
+    expect(history.at(-1)).toEqual({ role: 'user', text: `wiadomość ${GPT_LIVE_HISTORY_MAX_ITEMS + 9}` });
+    expect(history[0]).toEqual({ role: 'user', text: 'wiadomość 10' });
+  });
+
+  it('keeps the newest messages that fit the token budget', () => {
+    const long = 'x'.repeat(GPT_LIVE_HISTORY_MAX_ITEM_CHARS);
+    const events = Array.from({ length: 40 }, (_, index) => prompt(`${index}:${long}`));
+
+    const history = buildGptLiveHistory(events);
+    const approxTokens = history.reduce((sum, item) => sum + Math.ceil(item.text.length / 4), 0);
+
+    expect(history.length).toBeLessThan(40);
+    expect(approxTokens).toBeLessThanOrEqual(8_192);
+    expect(history.at(-1)?.text.startsWith('39:')).toBe(true);
+  });
+
+  it('truncates a single oversized message instead of dropping it', () => {
+    const history = buildGptLiveHistory([reply('y'.repeat(GPT_LIVE_HISTORY_MAX_ITEM_CHARS * 3))]);
+
+    expect(history).toHaveLength(1);
+    expect(history[0]?.text.length).toBeLessThanOrEqual(GPT_LIVE_HISTORY_MAX_ITEM_CHARS);
+    expect(history[0]?.text.endsWith('…')).toBe(true);
+  });
+});

package/src/live/gpt-live-history.ts

@@ -0,0 +1,59 @@
+import type { MoxxyEvent } from '@moxxy/sdk';
+
+/** GPT-Live accepts at most 128 initial items totalling 8,192 tokens. */
+export const GPT_LIVE_HISTORY_MAX_ITEMS = 128;
+export const GPT_LIVE_HISTORY_MAX_TOKENS = 8_192;
+/** One message may use at most ~2,048 tokens (a quarter of the budget), so a
+ *  single long reply cannot crowd every other message out of the model's view. */
+export const GPT_LIVE_HISTORY_MAX_ITEM_CHARS = 8_192;
+
+export interface GptLiveHistoryItem {
+  readonly role: 'user' | 'assistant';
+  readonly text: string;
+}
+
+/**
+ * Project a moxxy session log onto the conversation GPT-Live sees when a voice
+ * call starts: the user prompts and assistant replies, newest kept first until
+ * the item or token budget is spent, returned oldest-first.
+ */
+export function buildGptLiveHistory(
+  events: ReadonlyArray<MoxxyEvent>,
+): GptLiveHistoryItem[] {
+  const newestFirst: GptLiveHistoryItem[] = [];
+  let tokens = 0;
+  for (let index = events.length - 1; index >= 0; index -= 1) {
+    if (newestFirst.length >= GPT_LIVE_HISTORY_MAX_ITEMS) break;
+    const item = toHistoryItem(events[index]);
+    if (!item) continue;
+    const cost = approximateTokens(item.text);
+    if (tokens + cost > GPT_LIVE_HISTORY_MAX_TOKENS) break;
+    tokens += cost;
+    newestFirst.push(item);
+  }
+  return newestFirst.reverse();
+}
+
+function toHistoryItem(event: MoxxyEvent | undefined): GptLiveHistoryItem | null {
+  if (event?.type === 'user_prompt' && event.origin?.kind !== 'checkpoint') {
+    return fromText('user', event.text);
+  }
+  if (event?.type === 'assistant_message') return fromText('assistant', event.content);
+  return null;
+}
+
+function fromText(role: GptLiveHistoryItem['role'], raw: string): GptLiveHistoryItem | null {
+  const text = raw.trim();
+  if (!text) return null;
+  return { role, text: truncate(text) };
+}
+
+function truncate(text: string): string {
+  if (text.length <= GPT_LIVE_HISTORY_MAX_ITEM_CHARS) return text;
+  return `${text.slice(0, GPT_LIVE_HISTORY_MAX_ITEM_CHARS - 1)}…`;
+}
+
+/** Same rough four-characters-per-token estimate the Codex client budgets with. */
+function approximateTokens(text: string): number {
+  return Math.ceil(text.length / 4);
+}

package/src/models.test.ts

@@ -10,3 +10,30 @@ it('gives Astra an OAuth-specific operational budget without changing the defaul
   });
   expect(DEFAULT_CODEX_MODEL).toBe('gpt-5.6-sol');
 });
+
+it('lists only the models the ChatGPT plan still serves: GPT-6 and GPT-5.6', () => {
+  expect(codexModels.map((m) => m.id)).toEqual([
+    'gpt-6-astra',
+    'gpt-6-sol',
+    'gpt-6-luna',
+    'gpt-5.6-sol',
+    'gpt-5.6-terra',
+    'gpt-5.6-luna',
+  ]);
+});
+
+it("budgets every model to the Codex backend's 272k window less its 5% margin", () => {
+  for (const model of codexModels) {
+    expect(model).toMatchObject({
+      contextWindow: 258_400,
+      maxOutputTokens: 16_384,
+      supportsTools: true,
+      supportsImages: true,
+      supportsReasoning: true,
+    });
+  }
+});
+
+it('offers fast mode on every model the plan serves', () => {
+  for (const model of codexModels) expect(model.supportsFast, model.id).toBe(true);
+});

package/src/models.ts

@@ -9,28 +9,25 @@ import type { ModelDescriptor } from '@moxxy/sdk';
 // Every Codex-served model is a gpt-5-family reasoning model, so all advertise
 // `supportsReasoning` — the request already sends `reasoning.summary: 'auto'`;
 // the per-provider toggle decides whether the summary is surfaced.
+// The Codex backend serves every model below with a 272k window and uses 95%
+// of it (`effective_context_window_percent`), even where the raw API window is
+// 1.05M. Advertising more made the proactive compactor's
+// `estimatedTokens > 0.75 * contextWindow` gate unreachable, so every overflow
+// fell through to the reactive compact-on-overflow retry.
+const CODEX_CONTEXT_WINDOW = 258_400;
+// The OAuth backend rejects `max_output_tokens`; this is only the compactor's
+// reserve for the reply.
+const CODEX_OUTPUT_RESERVE = 16_384;
+
 export const codexModels: ReadonlyArray<ModelDescriptor> = [
-  // Astra's operational OAuth window: 272k less the agreed 5% safety margin.
-  // Output is a compaction reserve; the OAuth backend rejects max_output_tokens.
-  { id: 'gpt-6-astra', contextWindow: 258_400, maxOutputTokens: 16_384, supportsTools: true, supportsStreaming: true, supportsImages: true, supportsDocuments: true, supportsReasoning: true, hostedTools: ['web_search'] },
-  // The ChatGPT-plan Codex backend enforces a ~400k window for the gpt-5-family
-  // models it serves, well below the raw API ceiling. Advertising 1M here made
-  // the proactive compactor's `estimatedTokens > 0.75 * contextWindow` gate
-  // unreachable, so every overflow fell through to the reactive
-  // compact-on-overflow retry. Keep these in step with the rest of the catalog.
-  // GPT-5.6 family (GA July 9, 2026): served to ChatGPT-Pro/Plus subscribers
-  // under the same ids the API uses (sol/terra/luna — no `-codex` variant).
-  // Sol is OpenAI's default Codex model. The ChatGPT-plan window cap applies
-  // here too, so keep them at 400k like the rest of this list.
-  { id: 'gpt-5.6-sol', contextWindow: 400_000, maxOutputTokens: 128_000, supportsTools: true, supportsStreaming: true, supportsImages: true, supportsDocuments: true, supportsReasoning: true, hostedTools: ['web_search'] },
-  { id: 'gpt-5.6-terra', contextWindow: 400_000, maxOutputTokens: 128_000, supportsTools: true, supportsStreaming: true, supportsImages: true, supportsDocuments: true, supportsReasoning: true, hostedTools: ['web_search'] },
-  { id: 'gpt-5.6-luna', contextWindow: 400_000, maxOutputTokens: 128_000, supportsTools: true, supportsStreaming: true, supportsImages: true, supportsDocuments: true, supportsReasoning: true, hostedTools: ['web_search'] },
-  { id: 'gpt-5.5', contextWindow: 400_000, maxOutputTokens: 128_000, supportsTools: true, supportsStreaming: true, supportsImages: true, supportsDocuments: true, supportsReasoning: true, hostedTools: ['web_search'] },
-  { id: 'gpt-5.4', contextWindow: 400_000, maxOutputTokens: 128_000, supportsTools: true, supportsStreaming: true, supportsImages: true, supportsDocuments: true, supportsReasoning: true, hostedTools: ['web_search'] },
-  { id: 'gpt-5.4-mini', contextWindow: 400_000, maxOutputTokens: 128_000, supportsTools: true, supportsStreaming: true, supportsImages: true, supportsDocuments: true, supportsReasoning: true, hostedTools: ['web_search'] },
-  { id: 'gpt-5.3-codex', contextWindow: 400_000, maxOutputTokens: 128_000, supportsTools: true, supportsStreaming: true, supportsImages: true, supportsDocuments: true, supportsReasoning: true, hostedTools: ['web_search'] },
-  { id: 'gpt-5.3-codex-spark', contextWindow: 400_000, maxOutputTokens: 128_000, supportsTools: true, supportsStreaming: true, supportsImages: true, supportsDocuments: true, supportsReasoning: true, hostedTools: ['web_search'] },
-  { id: 'gpt-5.2', contextWindow: 400_000, maxOutputTokens: 128_000, supportsTools: true, supportsStreaming: true, supportsImages: true, supportsDocuments: true, supportsReasoning: true, hostedTools: ['web_search'] },
+  // GPT-6: Astra, Sol (flagship) and Luna (fast).
+  { id: 'gpt-6-astra', contextWindow: CODEX_CONTEXT_WINDOW, maxOutputTokens: CODEX_OUTPUT_RESERVE, supportsTools: true, supportsStreaming: true, supportsImages: true, supportsDocuments: true, supportsReasoning: true, supportsFast: true, hostedTools: ['web_search'] },
+  { id: 'gpt-6-sol', contextWindow: CODEX_CONTEXT_WINDOW, maxOutputTokens: CODEX_OUTPUT_RESERVE, supportsTools: true, supportsStreaming: true, supportsImages: true, supportsDocuments: true, supportsReasoning: true, supportsFast: true, hostedTools: ['web_search'] },
+  { id: 'gpt-6-luna', contextWindow: CODEX_CONTEXT_WINDOW, maxOutputTokens: CODEX_OUTPUT_RESERVE, supportsTools: true, supportsStreaming: true, supportsImages: true, supportsDocuments: true, supportsReasoning: true, supportsFast: true, hostedTools: ['web_search'] },
+  // GPT-5.6 family (GA July 9, 2026), under the same ids the API uses.
+  { id: 'gpt-5.6-sol', contextWindow: CODEX_CONTEXT_WINDOW, maxOutputTokens: CODEX_OUTPUT_RESERVE, supportsTools: true, supportsStreaming: true, supportsImages: true, supportsDocuments: true, supportsReasoning: true, supportsFast: true, hostedTools: ['web_search'] },
+  { id: 'gpt-5.6-terra', contextWindow: CODEX_CONTEXT_WINDOW, maxOutputTokens: CODEX_OUTPUT_RESERVE, supportsTools: true, supportsStreaming: true, supportsImages: true, supportsDocuments: true, supportsReasoning: true, supportsFast: true, hostedTools: ['web_search'] },
+  { id: 'gpt-5.6-luna', contextWindow: CODEX_CONTEXT_WINDOW, maxOutputTokens: CODEX_OUTPUT_RESERVE, supportsTools: true, supportsStreaming: true, supportsImages: true, supportsDocuments: true, supportsReasoning: true, supportsFast: true, hostedTools: ['web_search'] },
 ];
 
 // OpenAI's own Codex default moved to gpt-5.6-sol at GA (July 9, 2026); mirror

package/src/provider.test.ts

@@ -7,6 +7,7 @@ import { CODEX_RESPONSES_URL } from './oauth.js';
 import type { CodexTokens } from './types.js';
 import type { ProviderEvent, ProviderRequest } from '@moxxy/sdk';
 import { assertDefined, defineTool, z } from '@moxxy/sdk';
+import { removeDir } from '@moxxy/vitest-preset/fs';
 
 // The refresh path takes a cross-process lockfile under `<moxxy home>/locks`;
 // point MOXXY_HOME at a temp dir so tests never touch the real ~/.moxxy.
@@ -19,7 +20,7 @@ beforeAll(async () => {
 afterAll(async () => {
   if (priorMoxxyHome === undefined) delete process.env.MOXXY_HOME;
   else process.env.MOXXY_HOME = priorMoxxyHome;
-  await fs.rm(moxxyHomeTmp, { recursive: true, force: true });
+  await removeDir(moxxyHomeTmp);
 });
 
 function makeTokens(overrides: Partial<CodexTokens> = {}): CodexTokens {
@@ -50,7 +51,7 @@ async function collect<T>(it: AsyncIterable<T>): Promise<T[]> {
 
 function baseRequest(over: Partial<ProviderRequest> = {}): ProviderRequest {
   return {
-    model: 'gpt-5.3-codex',
+    model: 'gpt-5.6-sol',
     messages: [{ role: 'user', content: [{ type: 'text', text: 'hi' }] }],
     ...over,
   };
@@ -124,7 +125,7 @@ describe('CodexProvider.stream', () => {
     expect(h['Accept']).toBe('text/event-stream');
 
     // Event sequence: message_start, text_delta('hello'), message_end (with usage)
-    expect(events[0]).toMatchObject({ type: 'message_start', model: 'gpt-5.3-codex' });
+    expect(events[0]).toMatchObject({ type: 'message_start', model: 'gpt-5.6-sol' });
     expect(events.some((e) => e.type === 'text_delta' && e.delta === 'hello')).toBe(true);
     const end = events.find((e): e is Extract<ProviderEvent, { type: 'message_end' }> => e.type === 'message_end');
     expect(end?.usage).toEqual({ inputTokens: 3, outputTokens: 5 });
@@ -211,6 +212,19 @@ describe('CodexProvider.stream', () => {
     expect(bodies[1]?.reasoning).toMatchObject({ effort: 'high' });
   });
 
+  it('sends the xhigh reasoning effort a request asks for', async () => {
+    let body: Record<string, unknown> = {};
+    const fakeFetch = vi.fn(async (_u: RequestInfo | URL, init?: RequestInit) => {
+      body = JSON.parse(String(init?.body)) as Record<string, unknown>;
+      return new Response(sseStream(['data: {"type":"response.completed"}\n\n']), { status: 200 });
+    });
+    const provider = new CodexProvider({ tokens: makeTokens(), fetch: fakeFetch as unknown as typeof fetch });
+
+    await collect(provider.stream({ ...baseRequest(), reasoning: { effort: 'xhigh' } }));
+
+    expect(body.reasoning).toMatchObject({ effort: 'xhigh' });
+  });
+
   it('uses a stable default session id across turns so the prefix cache can hit', async () => {
     const keys: unknown[] = [];
     const fakeFetch = vi.fn(async (_u: RequestInfo | URL, init?: RequestInit) => {
@@ -465,13 +479,13 @@ describe('CodexProvider.stream', () => {
     const provider = new CodexProvider({ tokens: makeTokens() });
     const bigImage = 'A'.repeat(4 * 1024 * 1024); // 4 MiB of base64
     const withImage = await provider.countTokens({
-      model: 'gpt-5.3-codex',
+      model: 'gpt-5.6-sol',
       messages: [
         { role: 'user', content: [{ type: 'image', mediaType: 'image/png', data: bigImage }] },
       ],
     });
     const textOnly = await provider.countTokens({
-      model: 'gpt-5.3-codex',
+      model: 'gpt-5.6-sol',
       messages: [{ role: 'user', content: [{ type: 'text', text: 'hi' }] }],
     });
     // A 4 MiB base64 image must NOT be counted as ~1M tokens (4MiB/4) — the

package/src/provider.ts

@@ -62,7 +62,7 @@ export interface CodexProviderConfig {
    * moxxy.config.ts (e.g. `{ reasoningEffort: 'high' }`); the CLI's
    * credential resolution merges that config through to `createClient`.
    */
-  readonly reasoningEffort?: 'low' | 'medium' | 'high';
+  readonly reasoningEffort?: 'low' | 'medium' | 'high' | 'xhigh';
   /** Test seam — when omitted we use the global `fetch`. */
   readonly fetch?: typeof fetch;
   /** Test seam — when omitted we use crypto.randomUUID for the per-request session id. */
@@ -96,7 +96,7 @@ export class CodexProvider implements LLMProvider {
   private readonly onTokensRefreshed?: (next: CodexTokens) => void | Promise<void>;
   private readonly reloadTokens?: () => Promise<CodexTokens | null>;
   private readonly defaultModel: string;
-  private readonly reasoningEffort?: 'low' | 'medium' | 'high';
+  private readonly reasoningEffort?: 'low' | 'medium' | 'high' | 'xhigh';
   private readonly fetchImpl: typeof fetch;
   private readonly sessionIdProvider: () => string;
   private readonly idleTimeoutMs: number;

package/src/translate.test.ts

@@ -141,7 +141,7 @@ describe('extractSystemText', () => {
 
 describe('toResponsesBody', () => {
   const req = {
-    model: 'gpt-5.3-codex',
+    model: 'gpt-5.6-sol',
     messages: [
       { role: 'system' as const, content: [{ type: 'text' as const, text: 'BASE' }] },
       { role: 'user' as const, content: [{ type: 'text' as const, text: 'hi' }] },
@@ -175,4 +175,9 @@ describe('toResponsesBody', () => {
       { type: 'web_search' },
     ]);
   });
+
+  it('asks for the fast tier only when fast mode is on', () => {
+    expect(toResponsesBody({ ...req, fast: true }).service_tier).toBe('priority');
+    expect(toResponsesBody(req)).not.toHaveProperty('service_tier');
+  });
 });