remote-codex 0.1.9 → 0.11.0

package/packages/agent-runtime/src/model-pricing.ts

@@ -0,0 +1,312 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import type {
+  ThreadTurnPriceEstimateDto,
+  ThreadTurnTokenUsageDto,
+} from '../../shared/src/index';
+
+export type PricingTierKey = 'standard' | 'fast';
+
+interface ModelPricingEntry {
+  inputUsdPerMillion: number;
+  cachedInputUsdPerMillion: number;
+  outputUsdPerMillion: number;
+  supportsFastMode: boolean;
+  fastMultiplier?: number;
+  contextWindowTokens?: number;
+}
+
+interface PricingTierConfig {
+  multiplier: number;
+}
+
+interface TurnPricingSnapshot {
+  pricingModelKey: string;
+  pricingTierKey: PricingTierKey;
+}
+
+interface PricingConfig {
+  currency: 'USD';
+  tiers: Record<PricingTierKey, PricingTierConfig>;
+  models: Record<string, ModelPricingEntry>;
+}
+
+const TOKEN_PRICE_DENOMINATOR = 1_000_000;
+let cachedPricingConfig: PricingConfig | null = null;
+
+function resolvePackageRoot(start = process.cwd()) {
+  if (process.env.REMOTE_CODEX_PACKAGE_ROOT) {
+    return path.resolve(process.env.REMOTE_CODEX_PACKAGE_ROOT);
+  }
+
+  let current = path.resolve(start);
+
+  while (current !== path.dirname(current)) {
+    if (fs.existsSync(path.join(current, 'pnpm-workspace.yaml'))) {
+      return current;
+    }
+    current = path.dirname(current);
+  }
+
+  throw new Error('Unable to locate package root for model pricing config.');
+}
+
+function getPricingConfigPath() {
+  return path.join(resolvePackageRoot(), 'config', 'codex-model-pricing.json');
+}
+
+function isPositiveNumber(value: unknown) {
+  return typeof value === 'number' && Number.isFinite(value) && value >= 0;
+}
+
+function parsePricingConfig(raw: unknown): PricingConfig {
+  if (!raw || typeof raw !== 'object') {
+    throw new Error('Pricing config must be a JSON object.');
+  }
+
+  const config = raw as {
+    currency?: unknown;
+    tiers?: unknown;
+    models?: unknown;
+  };
+
+  if (config.currency !== 'USD') {
+    throw new Error('Pricing config currency must be "USD".');
+  }
+
+  if (!config.tiers || typeof config.tiers !== 'object') {
+    throw new Error('Pricing config must include a "tiers" object.');
+  }
+  if (!config.models || typeof config.models !== 'object') {
+    throw new Error('Pricing config must include a "models" object.');
+  }
+
+  const tiersSource = config.tiers as Record<string, unknown>;
+  const modelsSource = config.models as Record<string, unknown>;
+
+  const tiers: Record<PricingTierKey, PricingTierConfig> = {
+    standard: {
+      multiplier: 1,
+    },
+    fast: {
+      multiplier: 1,
+    },
+  };
+
+  for (const tierKey of ['standard', 'fast'] as const) {
+    const value = tiersSource[tierKey];
+    if (!value || typeof value !== 'object') {
+      throw new Error(`Pricing config tier "${tierKey}" is missing or invalid.`);
+    }
+
+    const multiplier = (value as { multiplier?: unknown }).multiplier;
+    if (!isPositiveNumber(multiplier)) {
+      throw new Error(`Pricing config tier "${tierKey}" multiplier must be a non-negative number.`);
+    }
+
+    tiers[tierKey] = {
+      multiplier: multiplier as number,
+    };
+  }
+
+  const models: Record<string, ModelPricingEntry> = {};
+  for (const [modelKey, value] of Object.entries(modelsSource)) {
+    if (!value || typeof value !== 'object') {
+      throw new Error(`Pricing config model "${modelKey}" is invalid.`);
+    }
+
+    const entry = value as {
+      inputUsdPerMillion?: unknown;
+      cachedInputUsdPerMillion?: unknown;
+      outputUsdPerMillion?: unknown;
+      supportsFastMode?: unknown;
+      fastMultiplier?: unknown;
+      contextWindowTokens?: unknown;
+    };
+
+    if (
+      !isPositiveNumber(entry.inputUsdPerMillion) ||
+      !isPositiveNumber(entry.cachedInputUsdPerMillion) ||
+      !isPositiveNumber(entry.outputUsdPerMillion) ||
+      typeof entry.supportsFastMode !== 'boolean'
+    ) {
+      throw new Error(`Pricing config model "${modelKey}" has invalid fields.`);
+    }
+    if (
+      entry.fastMultiplier !== undefined &&
+      !isPositiveNumber(entry.fastMultiplier)
+    ) {
+      throw new Error(`Pricing config model "${modelKey}" fastMultiplier must be a non-negative number.`);
+    }
+    if (
+      entry.contextWindowTokens !== undefined &&
+      !isPositiveNumber(entry.contextWindowTokens)
+    ) {
+      throw new Error(`Pricing config model "${modelKey}" contextWindowTokens must be a non-negative number.`);
+    }
+
+    models[modelKey] = {
+      inputUsdPerMillion: entry.inputUsdPerMillion as number,
+      cachedInputUsdPerMillion: entry.cachedInputUsdPerMillion as number,
+      outputUsdPerMillion: entry.outputUsdPerMillion as number,
+      supportsFastMode: entry.supportsFastMode,
+      ...(entry.fastMultiplier !== undefined
+        ? { fastMultiplier: entry.fastMultiplier as number }
+        : {}),
+      ...(entry.contextWindowTokens !== undefined
+        ? { contextWindowTokens: entry.contextWindowTokens as number }
+        : {}),
+    };
+  }
+
+  return {
+    currency: 'USD',
+    tiers,
+    models,
+  };
+}
+
+function getPricingConfig() {
+  if (cachedPricingConfig) {
+    return cachedPricingConfig;
+  }
+
+  const configPath = getPricingConfigPath();
+  const content = fs.readFileSync(configPath, 'utf8');
+  cachedPricingConfig = parsePricingConfig(JSON.parse(content) as unknown);
+  return cachedPricingConfig;
+}
+
+export function resetPricingConfigCacheForTest() {
+  cachedPricingConfig = null;
+}
+
+export function pricingTierForFastMode(fastMode: boolean): PricingTierKey {
+  return fastMode ? 'fast' : 'standard';
+}
+
+function pricingModelKeyForModel(model: string | null | undefined) {
+  const modelKey = model?.trim();
+  if (!modelKey) {
+    return null;
+  }
+
+  const models = getPricingConfig().models;
+  if (models[modelKey]) {
+    return modelKey;
+  }
+
+  const claudeDateSuffixMatch = modelKey.match(/^(claude-[a-z]+-\d+(?:-\d+)?)-20\d{6}$/);
+  if (claudeDateSuffixMatch?.[1] && models[claudeDateSuffixMatch[1]]) {
+    return claudeDateSuffixMatch[1];
+  }
+
+  return modelKey;
+}
+
+export function supportsFastMode(model: string | null | undefined) {
+  const pricingModelKey = pricingModelKeyForModel(model);
+  if (!pricingModelKey) {
+    return false;
+  }
+
+  return getPricingConfig().models[pricingModelKey]?.supportsFastMode === true;
+}
+
+export function contextWindowForModel(model: string | null | undefined) {
+  const pricingModelKey = pricingModelKeyForModel(model);
+  if (!pricingModelKey) {
+    return null;
+  }
+
+  const contextWindow = getPricingConfig().models[pricingModelKey]?.contextWindowTokens;
+  return typeof contextWindow === 'number' && contextWindow > 0
+    ? contextWindow
+    : null;
+}
+
+export function buildTurnPricingSnapshot(
+  model: string | null | undefined,
+  fastMode: boolean,
+): TurnPricingSnapshot | null {
+  const pricingModelKey = pricingModelKeyForModel(model);
+  if (!pricingModelKey) {
+    return null;
+  }
+
+  return {
+    pricingModelKey,
+    pricingTierKey: pricingTierForFastMode(fastMode),
+  };
+}
+
+export function estimateTurnPrice(
+  usage: ThreadTurnTokenUsageDto | null | undefined,
+  snapshot:
+    | {
+        pricingModelKey: string | null | undefined;
+        pricingTierKey: PricingTierKey | string | null | undefined;
+      }
+    | null
+    | undefined,
+): ThreadTurnPriceEstimateDto | null {
+  if (!usage?.total) {
+    return null;
+  }
+
+  const pricingModelKey = pricingModelKeyForModel(snapshot?.pricingModelKey);
+  if (!pricingModelKey) {
+    return null;
+  }
+
+  const pricingConfig = getPricingConfig();
+  const modelPricing = pricingConfig.models[pricingModelKey];
+  if (!modelPricing) {
+    return null;
+  }
+
+  const tierKey =
+    snapshot?.pricingTierKey === 'fast' ? 'fast' : snapshot?.pricingTierKey === 'standard'
+      ? 'standard'
+      : null;
+  if (!tierKey) {
+    return null;
+  }
+
+  const tier = pricingConfig.tiers[tierKey];
+  if (!tier) {
+    return null;
+  }
+
+  const nonCachedInputTokens = Math.max(
+    usage.total.inputTokens - usage.total.cachedInputTokens,
+    0,
+  );
+  const cachedInputTokens = Math.max(usage.total.cachedInputTokens, 0);
+  const outputTokens = Math.max(usage.total.outputTokens, 0);
+  const multiplier =
+    tierKey === 'fast' && modelPricing.fastMultiplier !== undefined
+      ? modelPricing.fastMultiplier
+      : tier.multiplier;
+
+  const inputUsd =
+    (nonCachedInputTokens * modelPricing.inputUsdPerMillion * multiplier) /
+    TOKEN_PRICE_DENOMINATOR;
+  const cachedInputUsd =
+    (cachedInputTokens * modelPricing.cachedInputUsdPerMillion * multiplier) /
+    TOKEN_PRICE_DENOMINATOR;
+  const outputUsd =
+    (outputTokens * modelPricing.outputUsdPerMillion * multiplier) /
+    TOKEN_PRICE_DENOMINATOR;
+
+  return {
+    pricingModelKey,
+    pricingTierKey: tierKey,
+    currency: pricingConfig.currency,
+    inputUsd,
+    cachedInputUsd,
+    outputUsd,
+    totalUsd: inputUsd + cachedInputUsd + outputUsd,
+  };
+}

package/packages/agent-runtime/src/registry.ts

@@ -1,3 +1,6 @@
+import {
+  defaultAgentBackendId,
+} from '../../shared/src/index';
 import {
   AgentProviderId,
   AgentRuntime,
@@ -7,7 +10,10 @@ import {
 export class AgentRuntimeRegistry {
   private readonly runtimes = new Map<AgentProviderId, AgentRuntime>();
 
-  constructor(runtimes: AgentRuntime[]) {
+  constructor(
+    runtimes: AgentRuntime[],
+    private readonly defaultProvider: AgentProviderId = defaultAgentBackendId,
+  ) {
     for (const runtime of runtimes) {
       this.runtimes.set(runtime.provider, runtime);
     }
@@ -30,15 +36,24 @@ export class AgentRuntimeRegistry {
   }
 
   list(): AgentRuntimeDescriptor[] {
-    return this.all().map((runtime, index) => ({
+    return this.all().map((runtime) => ({
       provider: runtime.provider,
       displayName: runtime.displayName,
       description: runtime.description,
-      enabled: true,
-      isDefault: index === 0,
+      enabled: isAgentRuntimeEnabled(runtime),
+      isDefault: runtime.provider === this.defaultProvider,
       status: runtime.getStatus(),
       capabilities: runtime.capabilities,
       managementSchema: runtime.managementSchema,
+      installation: runtime.installation,
     }));
   }
 }
+
+export function isAgentRuntimeEnabled(runtime: Pick<AgentRuntime, 'capabilities' | 'installation'>) {
+  return (
+    runtime.installation.installed &&
+    runtime.capabilities.sessions.resume &&
+    runtime.capabilities.turns.start
+  );
+}

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

@@ -0,0 +1,97 @@
+import { AgentRuntimeError } from './types';
+
+export type TurnSteerRace =
+  | { type: 'missing' }
+  | { type: 'turnIdMismatch'; actualTurnId: string };
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function stringField(value: unknown, key: string) {
+  return isRecord(value) && typeof value[key] === 'string' ? value[key] : null;
+}
+
+function remoteErrorMessage(error: unknown) {
+  if (error instanceof AgentRuntimeError) {
+    return error.message;
+  }
+  return error instanceof Error ? error.message : null;
+}
+
+export function parseTurnSteerRace(error: unknown): TurnSteerRace | null {
+  if (error instanceof AgentRuntimeError) {
+    const raceType = stringField(error.details, 'turnSteerRace');
+    if (raceType === 'missing') {
+      return { type: 'missing' };
+    }
+    if (raceType === 'turnIdMismatch') {
+      const actualTurnId = stringField(error.details, 'actualTurnId');
+      if (actualTurnId) {
+        return { type: 'turnIdMismatch', actualTurnId };
+      }
+    }
+  }
+
+  const message = remoteErrorMessage(error);
+  if (!message) {
+    return null;
+  }
+
+  if (message === 'no active turn to steer') {
+    return { type: 'missing' };
+  }
+
+  const mismatchPrefix = 'expected active turn id `';
+  const mismatchSeparator = '` but found `';
+  if (!message.startsWith(mismatchPrefix)) {
+    return null;
+  }
+
+  const actualTurnId = message
+    .slice(mismatchPrefix.length)
+    .split(mismatchSeparator)[1]
+    ?.replace(/`$/, '');
+
+  if (!actualTurnId) {
+    return null;
+  }
+
+  return {
+    type: 'turnIdMismatch',
+    actualTurnId,
+  };
+}
+
+export function isRuntimeRequestError(error: unknown) {
+  return error instanceof AgentRuntimeError;
+}
+
+export function isRemoteThreadBootstrapError(error: unknown) {
+  if (!(error instanceof AgentRuntimeError)) {
+    return false;
+  }
+
+  return (
+    error.message.includes('includeTurns is unavailable before first user message') ||
+    error.message.includes('is not materialized yet') ||
+    error.message.includes('no rollout found for thread id') ||
+    error.message.includes('failed to load rollout') ||
+    (error.message.includes('rollout at') && error.message.includes('is empty'))
+  );
+}
+
+export function isUnsupportedHooksListError(error: unknown) {
+  if (!(error instanceof AgentRuntimeError)) {
+    return false;
+  }
+
+  const remoteCode = isRecord(error.details) ? error.details.code : null;
+  const message = error.message.toLowerCase();
+  return (
+    remoteCode === -32601 ||
+    message.includes('endpoint not found') ||
+    message.includes('method not found') ||
+    (message.includes('hooks/list') && message.includes('not found'))
+  );
+}

package/packages/agent-runtime/src/types.ts

@@ -1,7 +1,15 @@
 import { EventEmitter } from 'node:events';
-import type { ThreadHistoryItemDto } from '../../shared/src/index';
+import type {
+  AgentBackendIdDto,
+  AgentBackendInstallationDto,
+  ThreadHistoryItemDto,
+} from '../../shared/src/index';
 
-export type AgentProviderId = 'codex' | 'claude';
+export const transientAgentHistoryItemSymbol: unique symbol = Symbol(
+  'remoteCodex.transientAgentHistoryItem',
+);
+
+export type AgentProviderId = AgentBackendIdDto;
 
 export type AgentRuntimeErrorCode =
   | 'provider_unavailable'
@@ -84,6 +92,7 @@ export interface AgentRuntimeDescriptor {
   status: AgentRuntimeStatus;
   capabilities: AgentProviderCapabilities;
   managementSchema: AgentRuntimeManagementSchema;
+  installation: AgentBackendInstallationDto;
 }
 
 export interface AgentRuntimeConfigFileSchema {
@@ -142,6 +151,7 @@ export interface AgentModel {
   description: string;
   isDefault: boolean;
   hidden: boolean;
+  supportsPerformanceMode?: boolean;
   supportedReasoningEfforts: Array<{
     reasoningEffort: string;
     description: string;
@@ -169,13 +179,33 @@ export interface AgentSessionSummary {
   rawSession?: unknown;
 }
 
-export type AgentHistoryItem = ThreadHistoryItemDto;
+export type AgentHistoryItem = ThreadHistoryItemDto & {
+  [transientAgentHistoryItemSymbol]?: true;
+};
+
+export function markTransientAgentHistoryItem<T extends ThreadHistoryItemDto>(
+  item: T,
+): T & AgentHistoryItem {
+  Object.defineProperty(item, transientAgentHistoryItemSymbol, {
+    value: true,
+    enumerable: false,
+    configurable: true,
+  });
+  return item as T & AgentHistoryItem;
+}
+
+export function isTransientAgentHistoryItem(
+  item: ThreadHistoryItemDto,
+): item is AgentHistoryItem & { [transientAgentHistoryItemSymbol]: true } {
+  return Boolean((item as AgentHistoryItem)[transientAgentHistoryItemSymbol]);
+}
 
 export type AgentTurnItem = AgentHistoryItem;
 
 export interface AgentTurn {
   providerTurnId: string;
   rawTurnId?: string;
+  startedAt?: string | null;
   status: 'completed' | 'interrupted' | 'failed' | 'inProgress';
   error: { message?: string } | null;
   items: AgentHistoryItem[];
@@ -184,6 +214,14 @@ export interface AgentTurn {
 
 export interface AgentSessionDetail extends AgentSessionSummary {
   turns: AgentTurn[];
+  totalTurnCount?: number | null;
+}
+
+export interface ReadAgentSessionOptions {
+  limit?: number;
+  beforeTurnId?: string | null;
+  localThreadId?: string;
+  workspacePath?: string;
 }
 
 export interface StartAgentSessionInput {
@@ -214,12 +252,15 @@ export interface ResumeAgentSessionInput {
 export interface StartAgentTurnInput {
   providerSessionId: string;
   prompt: string;
+  displayPrompt?: string | null;
   model?: string | null;
   reasoningEffort?: string | null;
   collaborationMode?: 'default' | 'plan' | null;
   sandboxMode?: 'read-only' | 'workspace-write' | 'danger-full-access' | null;
   workspacePath?: string | null;
   performanceMode?: 'standard' | 'fast' | null;
+  hidden?: boolean;
+  displayTurnId?: string | null;
 }
 
 export interface SendAgentInputInput {
@@ -455,6 +496,7 @@ export interface AgentActionQuestion {
   id: string;
   header: string;
   question: string;
+  multiSelect?: boolean;
   isOther: boolean;
   isSecret: boolean;
   options: AgentActionQuestionOption[] | null;
@@ -495,6 +537,7 @@ export interface AgentRuntime extends EventEmitter {
   readonly description: string;
   readonly capabilities: AgentProviderCapabilities;
   readonly managementSchema: AgentRuntimeManagementSchema;
+  readonly installation: AgentBackendInstallationDto;
 
   getStatus(): AgentRuntimeStatus;
   start(): Promise<void>;
@@ -503,7 +546,10 @@ export interface AgentRuntime extends EventEmitter {
   listModels(): Promise<AgentModel[]>;
   listSessions(): Promise<AgentSessionSummary[]>;
   listLoadedSessions(): Promise<string[]>;
-  readSession(providerSessionId: string): Promise<AgentSessionDetail>;
+  readSession(
+    providerSessionId: string,
+    options?: ReadAgentSessionOptions,
+  ): Promise<AgentSessionDetail>;
   startSession(input: StartAgentSessionInput): Promise<StartAgentSessionResult>;
   resumeSession(input: ResumeAgentSessionInput): Promise<StartAgentSessionResult>;