remote-codex 0.1.9 → 0.11.0

package/packages/codex/src/management/codexHostConfig.ts

@@ -0,0 +1,188 @@
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+
+export type CodexServiceTier = 'fast' | null;
+const SERVICE_TIER_LINE_GLOBAL_PATTERN =
+  /^\s*service_tier\s*=\s*("fast"|"flex"|'fast'|'flex').*\n?/gm;
+
+function resolveCodexConfigPath(codexHome: string) {
+  return path.join(codexHome, 'config.toml');
+}
+
+export function parseCodexServiceTier(content: string): CodexServiceTier {
+  const match = content.match(
+    /^\s*service_tier\s*=\s*["'](?<tier>fast)["']\s*$/m,
+  );
+  const tier = match?.groups?.tier;
+  return tier === 'fast' ? tier : null;
+}
+
+export function isFastModeEnabledFromConfig(content: string) {
+  return parseCodexServiceTier(content) === 'fast';
+}
+
+export function readCodexFastModeSync(codexHome: string) {
+  try {
+    const content = fs.readFileSync(resolveCodexConfigPath(codexHome), 'utf8');
+    return isFastModeEnabledFromConfig(content);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+      return false;
+    }
+    throw error;
+  }
+}
+
+export function upsertCodexServiceTier(content: string, enabled: boolean) {
+  const normalized = content.replace(/\r\n/g, '\n');
+  const withoutServiceTier = normalized.replace(
+    SERVICE_TIER_LINE_GLOBAL_PATTERN,
+    '',
+  );
+
+  if (!enabled) {
+    return withoutServiceTier.replace(/\n{3,}/g, '\n\n').trimEnd()
+      + (withoutServiceTier.trim() ? '\n' : '');
+  }
+
+  const nextLine = 'service_tier = "fast"';
+  if (!withoutServiceTier.trim()) {
+    return `${nextLine}\n`;
+  }
+
+  const firstSectionMatch = withoutServiceTier.match(/^\s*\[[^\]]+\]/m);
+  if (!firstSectionMatch || firstSectionMatch.index === undefined) {
+    return withoutServiceTier.endsWith('\n')
+      ? `${withoutServiceTier}${nextLine}\n`
+      : `${withoutServiceTier}\n${nextLine}\n`;
+  }
+
+  const beforeFirstSection = withoutServiceTier.slice(0, firstSectionMatch.index).trimEnd();
+  const afterFirstSection = withoutServiceTier
+    .slice(firstSectionMatch.index)
+    .replace(/^\n+/, '');
+  return beforeFirstSection
+    ? `${beforeFirstSection}\n${nextLine}\n${afterFirstSection}`
+    : `${nextLine}\n${afterFirstSection}`;
+}
+
+export async function writeCodexFastMode(codexHome: string, enabled: boolean) {
+  const configPath = resolveCodexConfigPath(codexHome);
+  let current = '';
+  try {
+    current = await fsp.readFile(configPath, 'utf8');
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+      throw error;
+    }
+  }
+
+  const next = upsertCodexServiceTier(current, enabled);
+  await fsp.mkdir(path.dirname(configPath), { recursive: true });
+  await fsp.writeFile(configPath, next, 'utf8');
+  return next;
+}
+
+export function isCodexFeatureEnabledFromConfig(content: string, featureName: string) {
+  const escaped = featureName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const featuresMatch = content.match(/^[^\S\r\n]*\[features\][^\S\r\n]*$/m);
+  if (!featuresMatch || featuresMatch.index === undefined) {
+    return false;
+  }
+
+  const sectionStart = featuresMatch.index + featuresMatch[0].length;
+  const nextSectionMatch = content
+    .slice(sectionStart)
+    .match(/^[^\S\r\n]*\[[^\]\r\n]+\][^\S\r\n]*$/m);
+  const sectionEnd =
+    nextSectionMatch && nextSectionMatch.index !== undefined
+      ? sectionStart + nextSectionMatch.index
+      : content.length;
+  const featuresBody = content.slice(sectionStart, sectionEnd);
+  return new RegExp(`^\\s*${escaped}\\s*=\\s*true\\s*(?:#.*)?$`, 'm').test(featuresBody);
+}
+
+export async function readCodexFeatureFlag(
+  codexHome: string,
+  featureName: string,
+) {
+  try {
+    const content = await fsp.readFile(resolveCodexConfigPath(codexHome), 'utf8');
+    return isCodexFeatureEnabledFromConfig(content, featureName);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+      return false;
+    }
+    throw error;
+  }
+}
+
+export function upsertCodexFeatureFlag(
+  content: string,
+  featureName: string,
+  enabled: boolean,
+) {
+  const normalized = content.replace(/\r\n/g, '\n');
+  const escaped = featureName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const featuresMatch = normalized.match(/^[^\S\r\n]*\[features\][^\S\r\n]*$/m);
+  const nextLine = `${featureName} = ${enabled ? 'true' : 'false'}`;
+
+  if (!featuresMatch || featuresMatch.index === undefined) {
+    const prefix = normalized.trimEnd();
+    return prefix
+      ? `${prefix}\n\n[features]\n${nextLine}\n`
+      : `[features]\n${nextLine}\n`;
+  }
+
+  const sectionStart = featuresMatch.index + featuresMatch[0].length;
+  const nextSectionMatch = normalized
+    .slice(sectionStart)
+    .match(/^[^\S\r\n]*\[[^\]\r\n]+\][^\S\r\n]*$/m);
+  const sectionEnd =
+    nextSectionMatch && nextSectionMatch.index !== undefined
+      ? sectionStart + nextSectionMatch.index
+      : normalized.length;
+  const beforeSectionBody = normalized.slice(0, sectionStart);
+  const sectionBody = normalized.slice(sectionStart, sectionEnd);
+  const afterSection = normalized.slice(sectionEnd);
+  const flagPattern = new RegExp(
+    `(^[^\\S\\r\\n]*)${escaped}[^\\S\\r\\n]*=[^\\S\\r\\n]*(true|false)[^\\S\\r\\n]*(?:#.*)?$`,
+    'm',
+  );
+
+  if (flagPattern.test(sectionBody)) {
+    return (
+      beforeSectionBody +
+      sectionBody.replace(flagPattern, `$1${nextLine}`) +
+      afterSection
+    );
+  }
+
+  const bodyWithFlag = `${sectionBody.replace(/\n*$/, '')}\n${nextLine}\n`;
+  const normalizedAfterSection = afterSection.startsWith('\n')
+    ? afterSection
+    : `\n${afterSection}`;
+  return beforeSectionBody + bodyWithFlag + normalizedAfterSection;
+}
+
+export async function writeCodexFeatureFlag(
+  codexHome: string,
+  featureName: string,
+  enabled: boolean,
+) {
+  const configPath = resolveCodexConfigPath(codexHome);
+  let current = '';
+  try {
+    current = await fsp.readFile(configPath, 'utf8');
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+      throw error;
+    }
+  }
+
+  const next = upsertCodexFeatureFlag(current, featureName, enabled);
+  await fsp.mkdir(path.dirname(configPath), { recursive: true });
+  await fsp.writeFile(configPath, next, 'utf8');
+  return next;
+}

package/packages/codex/src/management/errors.ts

@@ -0,0 +1,20 @@
+import {
+  AgentRuntimeManagementError,
+} from '../../../agent-runtime/src/index';
+
+export class CodexManagementError extends AgentRuntimeManagementError {
+  constructor(
+    statusCode: ConstructorParameters<typeof AgentRuntimeManagementError>[0],
+    payload: ConstructorParameters<typeof AgentRuntimeManagementError>[1],
+  ) {
+    super(statusCode, payload);
+    this.name = 'CodexManagementError';
+  }
+}
+
+export function codexBadRequest(message: string): never {
+  throw new AgentRuntimeManagementError(400, {
+    code: 'bad_request',
+    message,
+  });
+}

package/packages/codex/src/modelPricing.test.ts

@@ -0,0 +1,184 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import {
+  buildTurnPricingSnapshot,
+  contextWindowForModel,
+  estimateTurnPrice,
+  resetPricingConfigCacheForTest,
+  supportsFastMode,
+} from './modelPricing';
+
+const sampleUsage = {
+  total: {
+    totalTokens: 3000,
+    inputTokens: 1500,
+    cachedInputTokens: 500,
+    outputTokens: 1500,
+    reasoningOutputTokens: 0,
+  },
+  last: {
+    totalTokens: 3000,
+    inputTokens: 1500,
+    cachedInputTokens: 500,
+    outputTokens: 1500,
+    reasoningOutputTokens: 0,
+  },
+  modelContextWindow: 272000,
+};
+
+describe('modelPricing', () => {
+  afterEach(() => {
+    resetPricingConfigCacheForTest();
+    vi.unstubAllEnvs();
+  });
+
+  it('prices gpt-5.5 standard turns from the local pricing config', () => {
+    const estimate = estimateTurnPrice(sampleUsage, {
+      pricingModelKey: 'gpt-5.5',
+      pricingTierKey: 'standard',
+    });
+
+    expect(estimate).toMatchObject({
+      pricingModelKey: 'gpt-5.5',
+      pricingTierKey: 'standard',
+      inputUsd: 0.005,
+      cachedInputUsd: 0.00025,
+      outputUsd: 0.045,
+    });
+    expect(estimate?.totalUsd).toBeCloseTo(0.05025, 10);
+  });
+
+  it('uses the gpt-5.5-specific fast multiplier and marks it fast-capable', () => {
+    expect(supportsFastMode('gpt-5.5')).toBe(true);
+    expect(contextWindowForModel('gpt-5.5')).toBe(272000);
+
+    const estimate = estimateTurnPrice(sampleUsage, {
+      pricingModelKey: 'gpt-5.5',
+      pricingTierKey: 'fast',
+    });
+
+    expect(estimate).toMatchObject({
+      pricingModelKey: 'gpt-5.5',
+      pricingTierKey: 'fast',
+      inputUsd: 0.0125,
+      cachedInputUsd: 0.000625,
+      outputUsd: 0.1125,
+    });
+    expect(estimate?.totalUsd).toBeCloseTo(0.125625, 10);
+  });
+
+  it('prices Claude Sonnet and its 1M context option from the local pricing config', () => {
+    expect(supportsFastMode('sonnet')).toBe(false);
+    expect(contextWindowForModel('sonnet')).toBe(200000);
+    expect(contextWindowForModel('sonnet[1m]')).toBe(1000000);
+
+    const standardEstimate = estimateTurnPrice(sampleUsage, {
+      pricingModelKey: 'sonnet',
+      pricingTierKey: 'standard',
+    });
+    expect(standardEstimate).toMatchObject({
+      pricingModelKey: 'sonnet',
+      pricingTierKey: 'standard',
+      inputUsd: 0.003,
+      cachedInputUsd: 0.00015,
+      outputUsd: 0.0225,
+    });
+
+    const oneMillionEstimate = estimateTurnPrice(sampleUsage, {
+      pricingModelKey: 'sonnet[1m]',
+      pricingTierKey: 'standard',
+    });
+    expect(oneMillionEstimate).toMatchObject({
+      pricingModelKey: 'sonnet[1m]',
+      pricingTierKey: 'standard',
+      inputUsd: 0.006,
+      cachedInputUsd: 0.0003,
+      outputUsd: 0.03375,
+    });
+  });
+
+  it('prices current Claude Opus and Haiku aliases from the local pricing config', () => {
+    expect(contextWindowForModel('claude-opus-4-7')).toBe(200000);
+    expect(contextWindowForModel('claude-haiku-4-5')).toBe(200000);
+
+    const opusEstimate = estimateTurnPrice(sampleUsage, {
+      pricingModelKey: 'claude-opus-4-7',
+      pricingTierKey: 'standard',
+    });
+    expect(opusEstimate).toMatchObject({
+      pricingModelKey: 'claude-opus-4-7',
+      pricingTierKey: 'standard',
+      inputUsd: 0.005,
+      cachedInputUsd: 0.00025,
+      outputUsd: 0.0375,
+    });
+
+    const haikuEstimate = estimateTurnPrice(sampleUsage, {
+      pricingModelKey: 'claude-haiku-4-5',
+      pricingTierKey: 'standard',
+    });
+    expect(haikuEstimate).toMatchObject({
+      pricingModelKey: 'claude-haiku-4-5',
+      pricingTierKey: 'standard',
+      inputUsd: 0.001,
+      cachedInputUsd: 0.00005,
+      outputUsd: 0.0075,
+    });
+  });
+
+  it('normalizes Claude date-stamped runtime model names to local pricing keys', () => {
+    expect(contextWindowForModel('claude-sonnet-4-5-20250929')).toBe(200000);
+    expect(supportsFastMode('claude-sonnet-4-5-20250929')).toBe(false);
+    expect(buildTurnPricingSnapshot('claude-sonnet-4-5-20250929', false)).toEqual({
+      pricingModelKey: 'claude-sonnet-4-5',
+      pricingTierKey: 'standard',
+    });
+
+    const estimate = estimateTurnPrice(sampleUsage, {
+      pricingModelKey: 'claude-sonnet-4-5-20250929',
+      pricingTierKey: 'standard',
+    });
+
+    expect(estimate).toMatchObject({
+      pricingModelKey: 'claude-sonnet-4-5',
+      pricingTierKey: 'standard',
+      inputUsd: 0.003,
+      cachedInputUsd: 0.00015,
+      outputUsd: 0.0225,
+    });
+  });
+
+  it('resolves pricing config from the installed package root when provided', async () => {
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remote-codex-pricing-root-'));
+    await fs.mkdir(path.join(tempDir, 'config'), { recursive: true });
+    await fs.writeFile(
+      path.join(tempDir, 'config', 'codex-model-pricing.json'),
+      JSON.stringify({
+        currency: 'USD',
+        tiers: {
+          standard: { multiplier: 1 },
+          fast: { multiplier: 2 },
+        },
+        models: {
+          'package-model': {
+            inputUsdPerMillion: 10,
+            cachedInputUsdPerMillion: 1,
+            outputUsdPerMillion: 20,
+            supportsFastMode: true,
+            contextWindowTokens: 123000,
+          },
+        },
+      }),
+      'utf8',
+    );
+    vi.stubEnv('REMOTE_CODEX_PACKAGE_ROOT', tempDir);
+    resetPricingConfigCacheForTest();
+
+    expect(contextWindowForModel('package-model')).toBe(123000);
+    expect(supportsFastMode('package-model')).toBe(true);
+  });
+});

package/packages/codex/src/modelPricing.ts

@@ -0,0 +1,9 @@
+export {
+  buildTurnPricingSnapshot,
+  contextWindowForModel,
+  estimateTurnPrice,
+  pricingTierForFastMode,
+  resetPricingConfigCacheForTest,
+  supportsFastMode,
+  type PricingTierKey,
+} from '../../agent-runtime/src/index';

package/packages/codex/src/runtime-errors.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it } from 'vitest';
+
+import { AgentRuntimeError } from '../../agent-runtime/src/index';
+import { JsonRpcClientError } from './jsonrpc';
+import {
+  isCodexRuntimeRequestError,
+  isRemoteThreadBootstrapError,
+  isUnsupportedHooksListError,
+  parseTurnSteerRace,
+  unwrapCodexJsonRpcError,
+} from './runtime-errors';
+
+describe('codex runtime error helpers', () => {
+  it('unwraps Codex JSON-RPC errors from runtime errors', () => {
+    const cause = new JsonRpcClientError('method not found', 'remote_error', { code: -32601 });
+    const error = new AgentRuntimeError('method not found', 'codex', 'remote_error', {}, cause);
+
+    expect(unwrapCodexJsonRpcError(error)).toBe(cause);
+    expect(isCodexRuntimeRequestError(error)).toBe(true);
+  });
+
+  it('classifies Codex remote errors used by ThreadService fallback paths', () => {
+    expect(
+      isRemoteThreadBootstrapError(
+        new AgentRuntimeError(
+          'failed to load rollout: rollout at /tmp/demo.jsonl is empty',
+          'codex',
+          'remote_error',
+          {},
+          new JsonRpcClientError(
+            'failed to load rollout: rollout at /tmp/demo.jsonl is empty',
+            'remote_error',
+          ),
+        ),
+      ),
+    ).toBe(true);
+
+    expect(
+      isUnsupportedHooksListError(
+        new AgentRuntimeError(
+          'endpoint not found: hooks/list',
+          'codex',
+          'remote_error',
+          {},
+          new JsonRpcClientError('endpoint not found: hooks/list', 'remote_error', {
+            code: -32601,
+          }),
+        ),
+      ),
+    ).toBe(true);
+  });
+
+  it('parses Codex steer races from wrapped runtime errors', () => {
+    expect(
+      parseTurnSteerRace(
+        new AgentRuntimeError(
+          'expected active turn id `turn-old` but found `turn-new`',
+          'codex',
+          'remote_error',
+          {},
+          new JsonRpcClientError(
+            'expected active turn id `turn-old` but found `turn-new`',
+            'remote_error',
+          ),
+        ),
+      ),
+    ).toEqual({
+      type: 'turnIdMismatch',
+      actualTurnId: 'turn-new',
+    });
+  });
+});

package/packages/codex/src/runtime-errors.ts

@@ -0,0 +1,37 @@
+import {
+  AgentRuntimeError,
+  isRemoteThreadBootstrapError,
+  isRuntimeRequestError,
+  isUnsupportedHooksListError,
+  parseTurnSteerRace,
+  TurnSteerRace,
+} from '../../agent-runtime/src/index';
+import { JsonRpcClientError } from './jsonrpc';
+
+export type CodexTurnSteerRace = TurnSteerRace;
+export {
+  isRemoteThreadBootstrapError,
+  isUnsupportedHooksListError,
+  parseTurnSteerRace,
+};
+
+export function unwrapCodexJsonRpcError(error: unknown): JsonRpcClientError | null {
+  if (error instanceof JsonRpcClientError) {
+    return error;
+  }
+
+  if (error instanceof AgentRuntimeError && error.provider === 'codex') {
+    return error.cause instanceof JsonRpcClientError ? error.cause : null;
+  }
+
+  return null;
+}
+
+function isCodexRemoteError(error: unknown) {
+  const codexError = unwrapCodexJsonRpcError(error);
+  return codexError?.code === 'remote_error' ? codexError : null;
+}
+
+export function isCodexRuntimeRequestError(error: unknown) {
+  return Boolean(unwrapCodexJsonRpcError(error)) || isRuntimeRequestError(error);
+}

package/packages/codex/src/runtimeAdapter.ts

@@ -23,6 +23,9 @@ import type {
   StartAgentSessionResult,
   StartAgentTurnInput,
 } from '../../agent-runtime/src/index';
+import type {
+  AgentBackendInstallationDto,
+} from '../../shared/src/index';
 import {
   buildCodexProviderRequestResponse,
   mapCodexProviderRequest,
@@ -51,6 +54,7 @@ import {
   ThreadStartInput,
   TurnStartInput,
   JsonRpcClientError,
+  supportsFastMode,
 } from './index';
 
 export const codexCapabilities: AgentProviderCapabilities = {
@@ -137,6 +141,7 @@ function mapModel(model: Awaited<ReturnType<CodexAppServerManager['listModels']>
     description: model.description,
     isDefault: model.isDefault,
     hidden: model.hidden,
+    supportsPerformanceMode: supportsFastMode(model.model),
     supportedReasoningEfforts: model.supportedReasoningEfforts.map((entry) => ({
       reasoningEffort: entry.reasoningEffort,
       description: entry.description,
@@ -209,6 +214,7 @@ function buildSandboxPolicy(
 }
 
 function mapSession(thread: CodexThreadRecord): AgentSessionDetail {
+  const threadWithTotal = thread as CodexThreadRecord & { totalTurnCount?: unknown };
   return {
     provider: 'codex',
     providerSessionId: thread.id,
@@ -219,6 +225,10 @@ function mapSession(thread: CodexThreadRecord): AgentSessionDetail {
     updatedAt: toIsoFromEpoch(thread.updatedAt),
     status: normalizeStatus(thread.status),
     turns: thread.turns.map(mapTurn),
+    totalTurnCount:
+      typeof threadWithTotal.totalTurnCount === 'number'
+        ? threadWithTotal.totalTurnCount
+        : null,
     rawSession: thread,
   };
 }
@@ -460,6 +470,16 @@ export class CodexRuntimeAdapter extends EventEmitter implements AgentRuntime {
   readonly displayName = 'Codex';
   readonly description = 'Local Codex app-server runtime.';
   readonly capabilities = codexCapabilities;
+  readonly installation: AgentBackendInstallationDto = {
+    packageName: '@openai/codex',
+    installed: true,
+    installedVersion: null,
+    latestVersion: null,
+    installCommand: null,
+    updateCommand: 'npm install -g @openai/codex@latest',
+    busy: false,
+    lastError: null,
+  };
   readonly managementSchema: AgentRuntimeManagementSchema = {
     hostConfigFiles: [
       {
@@ -573,8 +593,11 @@ export class CodexRuntimeAdapter extends EventEmitter implements AgentRuntime {
     return codexRuntimeCall(() => this.manager.listLoadedThreads());
   }
 
-  async readSession(providerSessionId: string): Promise<AgentSessionDetail> {
-    return mapSession(await codexRuntimeCall(() => this.manager.readThread(providerSessionId)));
+  async readSession(
+    providerSessionId: string,
+    options: { limit?: number; beforeTurnId?: string | null } = {},
+  ): Promise<AgentSessionDetail> {
+    return mapSession(await codexRuntimeCall(() => this.manager.readThread(providerSessionId, options)));
   }
 
   async startSession(input: StartAgentSessionInput): Promise<StartAgentSessionResult> {

package/packages/codex/src/thread-title.ts

@@ -0,0 +1 @@
+export { truncateAutoThreadTitle } from '../../shared/src/index';

package/packages/db/src/repositories.ts

@@ -416,6 +416,21 @@ export function deleteThreadTurnMetadataByThreadId(db: DatabaseClient, threadId:
   db.delete(threadTurnMetadata).where(eq(threadTurnMetadata.threadId, threadId)).run();
 }
 
+export function deleteThreadTurnMetadataByThreadAndTurnId(
+  db: DatabaseClient,
+  threadId: string,
+  turnId: string,
+) {
+  db.delete(threadTurnMetadata)
+    .where(
+      and(
+        eq(threadTurnMetadata.threadId, threadId),
+        eq(threadTurnMetadata.turnId, turnId),
+      ),
+    )
+    .run();
+}
+
 export function listThreadHistoryItemRecordsByThreadId(
   db: DatabaseClient,
   threadId: string,
@@ -476,6 +491,21 @@ export function deleteThreadHistoryItemRecordsByThreadId(
   db.delete(threadHistoryItems).where(eq(threadHistoryItems.threadId, threadId)).run();
 }
 
+export function deleteThreadHistoryItemRecordsByThreadAndTurnId(
+  db: DatabaseClient,
+  threadId: string,
+  turnId: string,
+) {
+  db.delete(threadHistoryItems)
+    .where(
+      and(
+        eq(threadHistoryItems.threadId, threadId),
+        eq(threadHistoryItems.turnId, turnId),
+      ),
+    )
+    .run();
+}
+
 export function listThreadPendingSteerRecordsByThreadId(
   db: DatabaseClient,
   threadId: string,