@zergai/ztc 0.2.6-dev.36101352252 → 0.2.7-dev.36236183737

package/dist/agent/backends/codex_account_status.js

@@ -0,0 +1,196 @@
+import { CodexAppServerClient, CODEX_SUBSCRIPTION_CONFIG_ARGS, buildCodexAppServerEnv } from './codex_app_server.js';
+/**
+ * Minimum spacing between probes of one credential home, even when forced, for
+ * the shared mirror cache. A forced read spawns the Codex App Server and
+ * refreshes the login's token, so repeated refresh clicks (or a looping client)
+ * share one recent probe.
+ */
+export const CODEX_STATUS_MIN_FORCED_INTERVAL_MS = 30_000;
+/** Cache official Codex status per credential home so a mirror poll does not spawn a CLI each time. */
+export class CodexStatusCache {
+    probe;
+    entries = new Map();
+    pending = new Map();
+    generations = new Map();
+    minForcedIntervalMs;
+    constructor(probe, options = {}) {
+        this.probe = probe;
+        this.minForcedIntervalMs = options.minForcedIntervalMs ?? 0;
+    }
+    async read(home, force = false) {
+        const pending = this.pending.get(home);
+        if (pending)
+            return pending;
+        const entry = this.entries.get(home);
+        if (entry && Date.now() < entry.nextReadAt
+            && (!force || Date.now() - entry.probedAt < this.minForcedIntervalMs)) {
+            return entry.status;
+        }
+        const generation = this.generations.get(home) ?? 0;
+        const work = (async () => {
+            let status;
+            try {
+                status = await this.probe(home);
+                if (status.state === 'quota_unavailable' && entry?.status.windows.length && status.windows.length === 0) {
+                    status = { ...status, windows: entry.status.windows,
+                        ...(entry.status.observedAt !== undefined ? { observedAt: entry.status.observedAt } : {}) };
+                }
+            }
+            catch {
+                status = {
+                    state: 'unavailable',
+                    windows: entry?.status.windows ?? [],
+                    ...(entry?.status.observedAt !== undefined ? { observedAt: entry.status.observedAt } : {}),
+                    ...(entry?.status.email ? { email: entry.status.email } : {}),
+                    ...(entry?.status.plan ? { plan: entry.status.plan } : {}),
+                    ...(entry?.status.usage ? { usage: entry.status.usage, usageStale: true } : {}),
+                };
+            }
+            if (status.usageStale && !status.usage && entry?.status.usage) {
+                status = { ...status, usage: entry.status.usage };
+            }
+            if ((this.generations.get(home) ?? 0) === generation) {
+                const probedAt = Date.now();
+                this.entries.set(home, { status, probedAt, nextReadAt: probedAt
+                        + (status.state === 'unavailable' || status.state === 'quota_unavailable' ? 15_000 : 5 * 60_000) });
+            }
+            return status;
+        })();
+        this.pending.set(home, work);
+        try {
+            return await work;
+        }
+        finally {
+            if (this.pending.get(home) === work)
+                this.pending.delete(home);
+        }
+    }
+    invalidate(home) {
+        this.entries.delete(home);
+        this.pending.delete(home);
+        this.generations.set(home, (this.generations.get(home) ?? 0) + 1);
+    }
+}
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value : null;
+}
+function projectWindow(name, value, reached) {
+    const bucket = record(value);
+    if (!bucket)
+        return null;
+    const used = bucket.usedPercent;
+    const remaining = bucket.remainingPercent;
+    const percent = reached ? 0 : typeof remaining === 'number' ? remaining
+        : typeof used === 'number' ? 100 - used : NaN;
+    if (!Number.isFinite(percent) || percent < 0 || percent > 100)
+        return null;
+    const rawReset = bucket.resetsAt ?? bucket.resetAt;
+    const duration = bucket.windowDurationMins;
+    const label = typeof duration === 'number' && Number.isSafeInteger(duration) && duration > 0
+        ? duration % 1_440 === 0 ? `${duration / 1_440}d`
+            : duration % 60 === 0 ? `${duration / 60}h` : `${duration}m`
+        : name;
+    const resetAt = typeof rawReset === 'number'
+        ? (rawReset < 10_000_000_000 ? rawReset * 1000 : rawReset)
+        : typeof rawReset === 'string' ? Date.parse(rawReset) : NaN;
+    return { name: label, remainingPercent: percent,
+        ...(Number.isFinite(resetAt) && resetAt > 0 ? { resetAt } : {}) };
+}
+function projectWindows(value) {
+    const root = record(value);
+    if (!root)
+        return [];
+    const main = record(root.rateLimits);
+    const byId = record(root.rateLimitsByLimitId);
+    const windows = [];
+    const addBucket = (bucket, prefix) => {
+        const reached = bucket.rateLimitReachedType === 'rate_limit_reached';
+        for (const key of ['primary', 'secondary']) {
+            if (windows.length >= 12)
+                return;
+            const window = projectWindow(key, bucket[key], reached);
+            if (window)
+                windows.push({ ...window,
+                    name: prefix ? `${prefix} ${window.name}` : window.name });
+        }
+    };
+    const codex = record(byId?.codex);
+    if (codex)
+        addBucket(codex, '');
+    else if (main && (main.limitId === undefined || main.limitId === 'codex'))
+        addBucket(main, '');
+    if (byId) {
+        for (const [id, raw] of Object.entries(byId)) {
+            if (id === 'codex' || !/^[A-Za-z0-9_-]{1,40}$/.test(id))
+                continue;
+            const bucket = record(raw);
+            if (!bucket)
+                continue;
+            const label = typeof bucket.limitName === 'string'
+                && bucket.limitName.length > 0 && bucket.limitName.length <= 120
+                && !/[\u0000-\u001f\u007f]/.test(bucket.limitName)
+                ? bucket.limitName : id;
+            addBucket(bucket, label);
+            if (windows.length >= 12)
+                break;
+        }
+    }
+    return windows;
+}
+function projectUsage(value, observedAt) {
+    const root = record(value);
+    const summary = record(root?.summary);
+    const lifetime = summary?.lifetimeTokens;
+    const lifetimeTokens = typeof lifetime === 'number' && Number.isSafeInteger(lifetime) && lifetime >= 0
+        ? lifetime : undefined;
+    const today = new Date(observedAt).toISOString().slice(0, 10);
+    let todayTokens;
+    if (Array.isArray(root?.dailyUsageBuckets)) {
+        for (const value of root.dailyUsageBuckets) {
+            const bucket = record(value);
+            const tokens = bucket?.tokens;
+            if (bucket?.startDate === today && typeof tokens === 'number'
+                && Number.isSafeInteger(tokens) && tokens >= 0) {
+                todayTokens = Math.max(todayTokens ?? 0, tokens);
+            }
+        }
+    }
+    return lifetimeTokens === undefined && todayTokens === undefined ? undefined
+        : { ...(lifetimeTokens === undefined ? {} : { lifetimeTokens }),
+            ...(todayTokens === undefined ? {} : { todayTokens }), observedAt };
+}
+/** Read identity and quota through the official Codex App Server under one isolated CODEX_HOME. */
+export async function inspectCodexAccount(home) {
+    const client = new CodexAppServerClient({
+        args: [...CODEX_SUBSCRIPTION_CONFIG_ARGS, 'app-server'],
+        env: buildCodexAppServerEnv(home), requestTimeoutMs: 6_000,
+    });
+    try {
+        const result = await client.readAccount(true);
+        const account = record(result.account);
+        if (!account || account.type !== 'chatgpt' || result.requiresOpenaiAuth !== true) {
+            return { state: 'reauth_required', windows: [] };
+        }
+        const [limitsResult, usageResult] = await Promise.allSettled([
+            client.readRateLimits(), client.readUsage(),
+        ]);
+        const observedAt = Date.now();
+        const quotaAvailable = limitsResult.status === 'fulfilled';
+        const usageAvailable = usageResult.status === 'fulfilled';
+        return {
+            state: quotaAvailable ? 'ready' : 'quota_unavailable',
+            windows: projectWindows(quotaAvailable ? limitsResult.value : null),
+            ...(quotaAvailable ? { observedAt } : {}),
+            ...(usageAvailable ? { usage: projectUsage(usageResult.value, observedAt) } : { usageStale: true }),
+            ...(typeof account.email === 'string' ? { email: account.email } : {}),
+            ...(typeof account.planType === 'string' ? { plan: account.planType } : {}),
+        };
+    }
+    finally {
+        client.close();
+    }
+}
+export const codexStatusCache = new CodexStatusCache(inspectCodexAccount, {
+    minForcedIntervalMs: CODEX_STATUS_MIN_FORCED_INTERVAL_MS,
+});

package/dist/agent/backends/codex_app_server.d.ts

@@ -1,5 +1,5 @@
 import { RateLimitError } from './rate_limit.js';
-import type { ToolDefinition } from '../../types.js';
+import type { Message, ToolDefinition } from '../../types.js';
 import type { AgentBackend, BackendObservation, BackendRequest, BackendResponse, ClientToolCallResult, LlmMessage, StreamEvent } from './types.js';
 type JsonObject = Record<string, unknown>;
 export interface CodexAppServerTransport {
@@ -9,6 +9,8 @@ export interface CodexAppServerTransport {
 }
 export declare const MAX_CODEX_APP_SERVER_FRAME_BYTES = 1048576;
 export declare const MAX_CODEX_APP_SERVER_QUEUED_FRAMES = 1024;
+/** Keep managed profiles on their own auth.json and ChatGPT subscription. */
+export declare const CODEX_SUBSCRIPTION_CONFIG_ARGS: readonly ["-c", "cli_auth_credentials_store=\"file\"", "-c", "forced_login_method=\"chatgpt\""];
 /** Codex App Server `SandboxMode` for model-executed commands and edits. */
 export type CodexSandboxMode = 'read-only' | 'workspace-write' | 'danger-full-access';
 export interface CodexAppServerClientOptions {
@@ -29,6 +31,8 @@ export interface CodexAppServerClientOptions {
      * Ignored when a `transport` is supplied (tests/fakes own their own env).
      */
     env?: NodeJS.ProcessEnv;
+    /** Require the selected pooled profile to use ChatGPT subscription auth. */
+    requireChatGptSubscription?: boolean;
     /**
      * Sandbox for the threads ZTC starts. Defaults to `workspace-write`: an
      * omitted `sandbox` makes the App Server fall back to read-only, and since
@@ -44,7 +48,7 @@ export interface CodexAppServerClientOptions {
 /**
  * Environment for the spawned `codex app-server`, pinned to the account's own
  * credentials. Injects the per-account CODEX_HOME (when given) and SCRUBS a
- * stray `OPENAI_API_KEY` / `OPENAI_BASE_URL` from the parent env — otherwise the
+ * stray auth overrides from the parent env — otherwise the
  * codex CLI would bill that API key instead of the account's ChatGPT
  * subscription (auth.json under CODEX_HOME). This is the codex counterpart to
  * {@link buildClaudeCliEnv}'s ANTHROPIC_API_KEY scrub, and it applies even with
@@ -118,6 +122,7 @@ export declare class CodexAppServerClient {
     private command;
     private args;
     private env?;
+    private requireChatGptSubscription;
     private requestTimeoutMs;
     private turnTimeoutMs;
     /** Sandbox requested on thread/start. Readable so the factory's plan-mode
@@ -142,6 +147,8 @@ export declare class CodexAppServerClient {
      */
     private threadState;
     constructor(options?: CodexAppServerClientOptions);
+    /** Submit text to the active Codex turn; return false so the TUI can retry on a new turn. */
+    steerUserMessage(message: Message): Promise<boolean>;
     initialize(onActivity?: () => void): Promise<void>;
     listModels(): Promise<string[]>;
     streamTurn(options: CodexTurnOptions): AsyncIterable<StreamEvent>;
@@ -156,6 +163,8 @@ export declare class CodexAppServerClient {
         account: unknown;
         requiresOpenaiAuth: boolean;
     }>;
+    readRateLimits(): Promise<unknown>;
+    readUsage(): Promise<unknown>;
     private ensureTransport;
     private request;
     private requireAccount;
@@ -209,6 +218,7 @@ export declare class CodexAppServerBackend implements AgentBackend {
     /** The sandbox this backend's thread runs under. Observable so the factory's
      * plan-mode read-only downgrade can be asserted. */
     get sandbox(): CodexSandboxMode;
+    steerUserMessage(message: Message): Promise<boolean>;
     generate(request: BackendRequest): Promise<BackendResponse>;
     generateStream(request: BackendRequest): AsyncIterable<StreamEvent>;
     close(): void;

package/dist/agent/backends/codex_app_server.js

@@ -4,6 +4,10 @@ import { RateLimitError, parseResetAt } from './rate_limit.js';
 import { CODEX_APP_SERVER_PROVIDER } from './provider_ids.js';
 export const MAX_CODEX_APP_SERVER_FRAME_BYTES = 1_048_576;
 export const MAX_CODEX_APP_SERVER_QUEUED_FRAMES = 1_024;
+/** Keep managed profiles on their own auth.json and ChatGPT subscription. */
+export const CODEX_SUBSCRIPTION_CONFIG_ARGS = [
+    '-c', 'cli_auth_credentials_store="file"', '-c', 'forced_login_method="chatgpt"',
+];
 const MAX_CODEX_APP_SERVER_STDOUT_CHUNK_BYTES = 4 * MAX_CODEX_APP_SERVER_FRAME_BYTES;
 const DEFAULT_CODEX_APP_SERVER_REQUEST_TIMEOUT_MS = 30_000;
 const MAX_CODEX_APP_SERVER_REQUEST_TIMEOUT_MS = 120_000;
@@ -15,7 +19,7 @@ const MAX_CODEX_APP_SERVER_MODELS = 2_000;
 /**
  * Environment for the spawned `codex app-server`, pinned to the account's own
  * credentials. Injects the per-account CODEX_HOME (when given) and SCRUBS a
- * stray `OPENAI_API_KEY` / `OPENAI_BASE_URL` from the parent env — otherwise the
+ * stray auth overrides from the parent env — otherwise the
  * codex CLI would bill that API key instead of the account's ChatGPT
  * subscription (auth.json under CODEX_HOME). This is the codex counterpart to
  * {@link buildClaudeCliEnv}'s ANTHROPIC_API_KEY scrub, and it applies even with
@@ -25,8 +29,11 @@ export function buildCodexAppServerEnv(codexHome, base = process.env) {
     const env = { ...base };
     if (codexHome)
         env.CODEX_HOME = codexHome;
-    delete env.OPENAI_API_KEY;
-    delete env.OPENAI_BASE_URL;
+    for (const name of [
+        'OPENAI_API_KEY', 'OPENAI_BASE_URL', 'CODEX_ACCESS_TOKEN', 'CODEX_API_KEY',
+        'OPENAI_IDENTITY_TOKEN_FILE', 'OPENAI_FEDERATION_RULE_ID', 'CODEX_SQLITE_HOME',
+    ])
+        delete env[name];
     return env;
 }
 /** Stable sha1 hex digest of a string — used to fingerprint reusable thread state. */
@@ -348,6 +355,7 @@ export class CodexAppServerClient {
     command;
     args;
     env;
+    requireChatGptSubscription;
     requestTimeoutMs;
     turnTimeoutMs;
     /** Sandbox requested on thread/start. Readable so the factory's plan-mode
@@ -377,10 +385,39 @@ export class CodexAppServerClient {
         this.command = options.command || process.env.ZTC_CODEX_APP_SERVER_COMMAND || 'codex';
         this.args = options.args || ['app-server'];
         this.env = options.env;
+        this.requireChatGptSubscription = options.requireChatGptSubscription ?? false;
         this.sandbox = options.sandbox || 'workspace-write';
         this.requestTimeoutMs = resolveRequestTimeoutMs(options.requestTimeoutMs);
         this.turnTimeoutMs = resolveTurnTimeoutMs(options.turnTimeoutMs);
     }
+    /** Submit text to the active Codex turn; return false so the TUI can retry on a new turn. */
+    async steerUserMessage(message) {
+        // The app-server wire input below is text-only. Keep attachments on ZTC's
+        // ordinary next-turn path until image steering has an exact conversion.
+        if (message.attachments?.length)
+            return false;
+        const active = this.turnWaiters.filter(waiter => waiter.turnId && !waiter.terminalReceived);
+        if (active.length !== 1)
+            return false;
+        const waiter = active[0];
+        try {
+            const reply = await this.request('turn/steer', {
+                threadId: waiter.threadId,
+                expectedTurnId: waiter.turnId,
+                input: [{ type: 'text', text: message.content, text_elements: [] }],
+                clientUserMessageId: message.id,
+            });
+            if (reply.turnId !== waiter.turnId)
+                return false;
+            if (this.threadState?.threadId === waiter.threadId) {
+                this.threadState.acceptedSteering.push(message.content);
+            }
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     async initialize(onActivity) {
         if (this.initialized) {
             return;
@@ -507,10 +544,14 @@ export class CodexAppServerClient {
             // cached thread is the wrong shape and must not be reused.
             const signature = this.threadSignature(options, dynamicToolsPayload);
             const cached = this.threadState;
+            const gap = cached ? options.messages.slice(cached.knownCount) : [];
+            const userGap = gap.filter(message => message.role === 'user');
             const canReuse = Boolean(cached
                 && cached.signature === signature
                 && options.messages.length > cached.knownCount
-                && sha1(JSON.stringify(options.messages.slice(0, cached.knownCount))) === cached.prefixHash);
+                && sha1(JSON.stringify(options.messages.slice(0, cached.knownCount))) === cached.prefixHash
+                && userGap.length > cached.acceptedSteering.length
+                && cached.acceptedSteering.every((text, index) => this.flattenMessageContent(userGap[index]) === text));
             let threadId;
             let toolsActive;
             let input;
@@ -522,9 +563,8 @@ export class CodexAppServerClient {
                 // Send only the user messages added since the thread's last turn, as bare
                 // text. Assistant messages in the gap are the thread's OWN replies — it
                 // already holds them, so they're dropped from the input.
-                const gap = options.messages.slice(cached.knownCount);
                 input = [
-                    { type: 'text', text: gap.filter((m) => m.role === 'user').map((m) => this.flattenMessageContent(m)).join('\n\n'), text_elements: [] },
+                    { type: 'text', text: userGap.slice(cached.acceptedSteering.length).map((m) => this.flattenMessageContent(m)).join('\n\n'), text_elements: [] },
                     ...this.collectLocalImages(gap),
                 ];
             }
@@ -617,6 +657,7 @@ export class CodexAppServerClient {
                 knownCount: options.messages.length,
                 prefixHash: sha1(JSON.stringify(options.messages)),
                 signature: this.threadSignature(options, toolsActive ? dynamicToolsPayload : null),
+                acceptedSteering: [],
             };
             if (options.signal?.aborted) {
                 abort();
@@ -710,6 +751,14 @@ export class CodexAppServerClient {
         await this.initialize(onActivity);
         return await this.request('account/read', { refreshToken }, onActivity);
     }
+    async readRateLimits() {
+        await this.initialize();
+        return await this.request('account/rateLimits/read', {});
+    }
+    async readUsage() {
+        await this.initialize();
+        return await this.request('account/usage/read', {});
+    }
     ensureTransport() {
         if (!this.transport) {
             this.transport = this.transportFactory
@@ -770,6 +819,10 @@ export class CodexAppServerClient {
         if (!result.account) {
             throw new Error("codex_app_server is not logged in. Run 'codex login status' or 'codex login' before using ZTC's official Codex provider.");
         }
+        if (this.requireChatGptSubscription
+            && (result.account.type !== 'chatgpt' || result.requiresOpenaiAuth !== true)) {
+            throw new Error('codex_app_server requires a ChatGPT subscription login; an API key or alternate provider is active. Run codex login for this account.');
+        }
     }
     sendNotification(method) {
         this.ensureTransport();
@@ -918,6 +971,10 @@ export class CodexAppServerClient {
                     inputTokens,
                     outputTokens,
                     totalTokens,
+                    ...(typeof last.cachedInputTokens === 'number'
+                        && Number.isSafeInteger(last.cachedInputTokens)
+                        && last.cachedInputTokens >= 0
+                        ? { cachedInputTokens: last.cachedInputTokens } : {}),
                     estimated: false,
                     ...(typeof contextWindow === 'number' && contextWindow > 0 ? { contextWindow } : {}),
                 };
@@ -1257,6 +1314,9 @@ export class CodexAppServerBackend {
     get sandbox() {
         return this.client.sandbox;
     }
+    async steerUserMessage(message) {
+        return this.client.steerUserMessage(message);
+    }
     async generate(request) {
         const content = [];
         let stopReason = 'completed';

package/dist/agent/backends/index.d.ts

@@ -17,6 +17,7 @@ export { ClaudeCliBackend, ClaudeCliError, CLAUDE_CODE_AUTH_SENTINEL, hasUsableC
 export type { AgentBackend, BackendObservation, BackendRequest, BackendResponse, ContentBlock, TextBlock, ToolUseBlock, LlmMessage, RequestContentBlock, RequestVideoBlock, ToolResultBlock, TokenUsage, StreamEvent } from './types.js';
 import type { AgentBackend, BackendRequest, BackendResponse, StreamEvent } from './types.js';
 import { AccountPool, type RotationMode } from './account_rotation.js';
+import type { Message } from '../../types.js';
 export interface CreateBackendOptions {
     apiKey: string;
     baseUrl?: string;
@@ -58,6 +59,7 @@ export declare class TracedBackend implements AgentBackend {
     private readonly provider;
     private readonly backend;
     constructor(provider: string, backend: AgentBackend);
+    steerUserMessage(message: Message): Promise<boolean>;
     /** Forward disposal so a process-backed inner (RotatingBackend, codex child)
      * is closed when the agent is. Without this, tracing (ZTC_BACKEND_TRACE=1)
      * leaks the child on every agent swap/dispose. */

package/dist/agent/backends/index.js

@@ -21,7 +21,7 @@ import { OpenAICompatibleBackend } from './openai_compatible.js';
 import { InceptionBackend } from './inception.js';
 import { GeminiBackend } from './gemini.js';
 import { KimiBackend } from './kimi.js';
-import { CodexAppServerBackend, buildCodexAppServerEnv } from './codex_app_server.js';
+import { CodexAppServerBackend, CODEX_SUBSCRIPTION_CONFIG_ARGS, buildCodexAppServerEnv } from './codex_app_server.js';
 import { CodexAuthManager, CodexAuthBackend } from './codex_auth.js';
 import { ClarifaiBackend } from './clarifai.js';
 import { ClaudeCodeAuthBackend, ClaudeCodeAuthManager } from './claude_code_auth.js';
@@ -38,6 +38,9 @@ export class TracedBackend {
         this.provider = provider;
         this.backend = backend;
     }
+    async steerUserMessage(message) {
+        return this.backend.steerUserMessage?.(message) ?? false;
+    }
     /** Forward disposal so a process-backed inner (RotatingBackend, codex child)
      * is closed when the agent is. Without this, tracing (ZTC_BACKEND_TRACE=1)
      * leaks the child on every agent swap/dispose. */
@@ -98,14 +101,16 @@ function traced(provider, backend) {
  * Replaces duplicated switch statements in sim/llm.ts, agent/subagent.ts, optimize/llm.ts, etc.
  */
 export function createBackendForProvider(provider, opts) {
-    // Auto-rotate: when the caller opted in and >1 account is REGISTERED for the
-    // provider, wrap the concrete backend so a 429 cools the active account and
+    // Auto-rotate non-Codex providers only: when the caller opted in and >1
+    // account is REGISTERED, wrap the concrete backend so a 429 cools the active account and
     // fails over. Gate on registered (not ready) count: with one ready account and
     // the config-active pointer on a different cooling/logged-out one, a ready-only
     // gate would build directly on the stale active and hard-fail the first turn —
     // the wrapper's selectActive is what moves off it. The inner build recurses
     // with rotation cleared + the chosen account's source.
-    if (opts.rotation && opts.rotationPool && opts.rotationPool.accountsFor(provider).length > 1) {
+    if (normalizeProviderId(provider) !== CODEX_APP_SERVER_PROVIDER
+        && normalizeProviderId(provider) !== CODEX_LEGACY_PROVIDER
+        && opts.rotation && opts.rotationPool && opts.rotationPool.accountsFor(provider).length > 1) {
         const pool = opts.rotationPool;
         return traced(provider, new RotatingBackend({
             provider,
@@ -152,12 +157,15 @@ export function createBackendForProvider(provider, opts) {
         case CODEX_APP_SERVER_PROVIDER:
             return traced(provider, new CodexAppServerBackend(undefined, {
                 command: opts.codexAppServerCommand,
-                args: opts.codexAppServerArgs,
+                args: opts.codexHome
+                    ? [...CODEX_SUBSCRIPTION_CONFIG_ARGS, ...(opts.codexAppServerArgs ?? ['app-server'])]
+                    : opts.codexAppServerArgs,
                 sandbox: opts.codexAppServerSandbox,
                 // Point the spawned app-server at this account's codex home AND scrub a
                 // stray OPENAI_API_KEY so it uses the account's ChatGPT subscription, not
                 // an API key (mirrors the claude_code ANTHROPIC_API_KEY scrub).
                 env: buildCodexAppServerEnv(opts.codexHome),
+                requireChatGptSubscription: opts.codexHome !== undefined,
             }));
         case CODEX_LEGACY_PROVIDER: {
             // Per-account: read this account's auth.json (default ~/.codex when unset).

package/dist/agent/backends/openai.d.ts

@@ -1,8 +1,8 @@
 /**
  * OpenAI backend — smart router between Chat Completions and Responses API.
  *
- * Models that require the Responses API (codex models,
- * gpt-5.x-codex-*, etc.) are automatically routed there. Everything else goes through Chat Completions.
+ * Codex models and GPT-6 Sol/Luna use Responses so reasoning and tool calls
+ * can be combined. Everything else goes through Chat Completions.
  */
 import { AgentBackend, BackendRequest, BackendResponse, StreamEvent } from './types.js';
 interface OpenAIConfig {

package/dist/agent/backends/openai.js

@@ -1,14 +1,15 @@
 /**
  * OpenAI backend — smart router between Chat Completions and Responses API.
  *
- * Models that require the Responses API (codex models,
- * gpt-5.x-codex-*, etc.) are automatically routed there. Everything else goes through Chat Completions.
+ * Codex models and GPT-6 Sol/Luna use Responses so reasoning and tool calls
+ * can be combined. Everything else goes through Chat Completions.
  */
 import { OpenAICompatibleBackend } from './openai_compatible.js';
 import { OpenAIResponsesBackend } from './openai_responses.js';
-/** Models that only work with the Responses API. */
+/** Models routed to the Responses API. */
 const RESPONSES_API_PATTERNS = [
     /codex/i, // codex-mini-latest, gpt-5.1-codex-mini, gpt-5.2-codex, etc.
+    /^gpt-6-(?:sol|luna)$/i,
 ];
 function needsResponsesAPI(model) {
     return RESPONSES_API_PATTERNS.some(p => p.test(model));

package/dist/agent/backends/openai_compatible.js

@@ -36,11 +36,11 @@ export class OpenAICompatibleBackend {
      *  and generateStream(). generateStream() adds `stream`/`stream_options`. */
     async buildCall(request) {
         const url = `${this.baseUrl}${this.apiPath}`;
-        // O-series (o1, o3, o4-mini) and GPT-5+ use max_completion_tokens instead of
+        // O-series (o1, o3, o4-mini) and GPT-5/6 use max_completion_tokens instead of
         // max_tokens; Moonshot marks max_tokens "Deprecated, please refer to
         // max_completion_tokens" for the Kimi models too.
         const useCompletionTokens = /^o\d/.test(request.model)
-            || /^gpt-5/.test(request.model)
+            || /^gpt-[56]/.test(request.model)
             || isKimiModel(request.model);
         // Cap max_tokens for models with lower limits (gpt-4o: 16384)
         const isGpt4o = request.model.startsWith('gpt-4o');
@@ -49,19 +49,19 @@ export class OpenAICompatibleBackend {
         const tokenParam = effectiveMaxTokens === undefined ? {} : useCompletionTokens
             ? { max_completion_tokens: effectiveMaxTokens }
             : { max_tokens: effectiveMaxTokens };
+        const isGpt6Model = /^gpt-6-(?:sol|luna)$/i.test(request.model);
+        const reasoningEffort = (request.model === 'gpt-5.6-sol' || isGpt6Model) && request.tools.length > 0
+            ? 'none'
+            : isGpt6Model ? request.codexEffort : undefined;
         const body = {
             ...this.extraBody,
             ...(this.requestBodyExtras?.(request) ?? {}),
             model: request.model,
             ...tokenParam,
-            // OpenAI's gpt-5.6-sol Chat Completions contract rejects function
-            // tools while its default reasoning mode is active. The Responses API
-            // supports both, but this backend intentionally speaks Chat
-            // Completions, so disable reasoning only for the calls that carry tools.
-            // Tool-free turns keep the model's normal reasoning default.
-            ...(request.model === 'gpt-5.6-sol' && request.tools.length > 0
-                ? { reasoning_effort: 'none' }
-                : {}),
+            // Chat Completions accepts GPT-6 Sol/Luna function tools only with
+            // reasoning disabled. The direct OpenAI backend uses Responses instead;
+            // keep this rule for explicitly configured compatible endpoints.
+            ...(reasoningEffort ? { reasoning_effort: reasoningEffort } : {}),
             messages: buildOpenAIMessages(request),
             ...(request.tools.length > 0 ? { tools: buildOpenAIToolDefs(request.tools) } : {})
         };

package/dist/agent/backends/openai_responses.d.ts

@@ -52,6 +52,22 @@ interface ResponsesReasoning {
     summary: unknown[];
 }
 type ResponsesOutputItem = ResponsesMessage | ResponsesFunctionCall | ResponsesReasoning;
+interface ResponsesAPIResponse {
+    id: string;
+    status: string;
+    incomplete_details?: {
+        reason?: string;
+    } | null;
+    output: ResponsesOutputItem[];
+    usage?: {
+        input_tokens?: number;
+        output_tokens?: number;
+        total_tokens?: number;
+        input_tokens_details?: {
+            cached_tokens?: number;
+        };
+    };
+}
 export declare function isValidResponsesOutputItem(value: unknown): value is Record<string, unknown>;
 export declare function requireValidResponsesOutputItem(value: unknown): asserts value is Record<string, unknown>;
 /** A terminal event must carry a valid response shape or follow real output. */
@@ -98,11 +114,7 @@ export declare function parseResponsesOutput(data: {
         reason?: string;
     } | null;
     output: ResponsesOutputItem[];
-    usage?: {
-        input_tokens?: number;
-        output_tokens?: number;
-        total_tokens?: number;
-    };
+    usage?: ResponsesAPIResponse['usage'];
 }): BackendResponse;
 /**
  * Consume a Responses API SSE response into incremental StreamEvents. Yields

package/dist/agent/backends/openai_responses.js

@@ -13,6 +13,7 @@
  *   - Token param → `max_output_tokens`
  */
 import { BaseBackend } from './base.js';
+import { parseTokenUsage } from './token_usage.js';
 function isRecord(value) {
     return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 }
@@ -252,9 +253,6 @@ export function parseResponsesOutput(data) {
             }
         }
     }
-    const inputTokens = data.usage?.input_tokens ?? 0;
-    const outputTokens = data.usage?.output_tokens ?? 0;
-    const totalTokens = data.usage?.total_tokens ?? (inputTokens + outputTokens);
     // An incomplete terminal response outranks any partial function call it may
     // contain. Executing that payload as a normal tool_use would turn truncated
     // JSON into a side effect; the Agent consumes this stop state fail-closed.
@@ -266,7 +264,7 @@ export function parseResponsesOutput(data) {
     return {
         content: blocks,
         stopReason,
-        usage: data.usage ? { inputTokens, outputTokens, totalTokens } : undefined,
+        usage: data.usage ? parseTokenUsage(data.usage) : undefined,
         ...(reasoningParts.length > 0 ? { reasoning: reasoningParts.join('\n\n') } : {}),
     };
 }

package/dist/agent/backends/token_usage.js

@@ -11,7 +11,7 @@ export function parseTokenUsage(value) {
     const outputTokens = counter(raw.completion_tokens ?? raw.output_tokens) ?? 0;
     const usage = { inputTokens, outputTokens, totalTokens: counter(raw.total_tokens) ?? inputTokens + outputTokens };
     const optional = {
-        cachedInputTokens: counter(raw.cached_input_tokens ?? record(raw.prompt_tokens_details).cached_tokens ?? raw.prompt_cache_hit_tokens),
+        cachedInputTokens: counter(raw.cached_input_tokens ?? record(raw.input_tokens_details).cached_tokens ?? record(raw.prompt_tokens_details).cached_tokens ?? raw.prompt_cache_hit_tokens),
         cacheWriteInputTokens: counter(raw.cache_creation_input_tokens),
         reasoningTokens: counter(record(raw.completion_tokens_details).reasoning_tokens ?? raw.reasoning_tokens),
     };

package/dist/agent/backends/types.d.ts

@@ -1,4 +1,5 @@
 import { ToolDefinition } from '../../types.js';
+import type { Message } from '../../types.js';
 export interface RequestTextBlock {
     type: 'text';
     text: string;
@@ -257,6 +258,8 @@ export type StreamEvent = {
     stopReason: string;
 };
 export interface AgentBackend {
+    /** Deliver user input into a provider-owned active turn when supported. */
+    steerUserMessage?(message: Message): Promise<boolean>;
     /**
      * True when the backend owns a usable authentication source independently
      * of AgentConfig.apiKey (for example, a host-provided rotating token).