remote-codex 0.11.42 → 0.11.44

package/apps/supervisor-web/dist/index.html

@@ -10,13 +10,13 @@
     <link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon.png" />
     <link rel="manifest" href="/site.webmanifest" />
     <title>Remote Codex</title>
-    <script type="module" crossorigin src="/assets/index-BvxWpPKW.js"></script>
+    <script type="module" crossorigin src="/assets/index-CO8cU7a0.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/react-vendor-Dfg_6BLf.js">
     <link rel="modulepreload" crossorigin href="/assets/ui-vendor-CuR8GHb0.js">
     <link rel="modulepreload" crossorigin href="/assets/graph-vendor-DVQUpZ8C.js">
     <link rel="modulepreload" crossorigin href="/assets/terminal-vendor-C5bTa-Ka.js">
     <link rel="modulepreload" crossorigin href="/assets/markdown-vendor-RZk8L7-L.js">
-    <link rel="modulepreload" crossorigin href="/assets/thread-ui-BLThton-.js">
+    <link rel="modulepreload" crossorigin href="/assets/thread-ui-Dmrigdek.js">
     <link rel="stylesheet" crossorigin href="/assets/graph-vendor-C5ap-Sga.css">
     <link rel="stylesheet" crossorigin href="/assets/terminal-vendor-Beg8tuEN.css">
     <link rel="stylesheet" crossorigin href="/assets/index-BcCLYWAf.css">

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "remote-codex",
-  "version": "0.11.42",
+  "version": "0.11.44",
   "description": "Local web supervisor for Codex workspaces and threads.",
   "license": "MIT",
   "type": "module",

package/packages/claude/src/runtimeAdapter.test.ts

@@ -88,11 +88,28 @@ class FakeQuery implements Query {
     return [
       {
         value: 'claude-sonnet-4-5',
+        resolvedModel: 'claude-sonnet-4-5-20250929',
         displayName: 'Claude Sonnet 4.5',
         description: 'Test model',
         supportsEffort: true,
         supportedEffortLevels: ['low', 'medium', 'high'],
       },
+      {
+        value: 'claude-fable-5[1m]',
+        resolvedModel: 'claude-fable-5',
+        displayName: 'Fable',
+        description: 'Fable 5 test model',
+        supportsEffort: true,
+        supportedEffortLevels: ['low', 'medium', 'high', 'xhigh', 'max'],
+      },
+      {
+        value: 'opus[1m]',
+        resolvedModel: 'claude-opus-5[1m]',
+        displayName: 'Opus (1M context)',
+        description: 'Opus 5 test model',
+        supportsEffort: true,
+        supportedEffortLevels: ['low', 'medium', 'high', 'xhigh', 'max'],
+      },
     ];
   }
   async supportedAgents(): Promise<any[]> {
@@ -801,14 +818,17 @@ describe('ClaudeRuntimeAdapter', () => {
     await expect(adapter.listLoadedSessions()).resolves.toEqual(['claude-session-1']);
   });
 
-  it('exposes Claude Code model aliases and enables the 1M context beta', async () => {
+  it('discovers versioned Claude Code model labels while idle and enables the 1M context beta', async () => {
     const sdkOptions: Record<string, unknown>[] = [];
+    const queries: FakeQuery[] = [];
     const adapter = new ClaudeRuntimeAdapter({
       home: '/tmp/claude-home',
       command: 'claude',
       query: ((params: { prompt: string; options: Record<string, unknown> }) => {
         sdkOptions.push(params.options);
-        return new FakeQuery([systemInit(), result()]);
+        const query = new FakeQuery([systemInit(), result()]);
+        queries.push(query);
+        return query;
       }) as any,
       listSessions: (async () => [] satisfies SDKSessionInfo[]) as any,
       getSessionInfo: (async () => null) as any,
@@ -819,23 +839,38 @@ describe('ClaudeRuntimeAdapter', () => {
       expect.arrayContaining([
         expect.objectContaining({
           model: 'sonnet',
-          displayName: 'Claude Sonnet',
+          displayName: 'Sonnet · 4.5',
           isDefault: true,
         }),
         expect.objectContaining({
           model: 'sonnet[1m]',
-          displayName: 'Claude Sonnet 1M',
+          displayName: 'Sonnet · 4.5 (1M context)',
         }),
         expect.objectContaining({
           model: 'fable',
-          displayName: 'Claude Fable',
+          displayName: 'Fable · 5',
           defaultReasoningEffort: 'medium',
           supportedReasoningEfforts: expect.arrayContaining([
             expect.objectContaining({ reasoningEffort: 'max' }),
           ]),
         }),
+        expect.objectContaining({
+          model: 'opus',
+          displayName: 'Opus · 5',
+        }),
+        expect.objectContaining({
+          model: 'opus[1m]',
+          displayName: 'Opus · 5 (1M context)',
+        }),
+      ]),
+    );
+    await expect(adapter.listModels()).resolves.not.toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ model: 'claude-fable-5[1m]' }),
       ]),
     );
+    expect(queries[0]?.closed).toBe(true);
+    expect(queries).toHaveLength(1);
 
     await adapter.startSession({
       cwd: '/tmp/workspace',
@@ -844,7 +879,7 @@ describe('ClaudeRuntimeAdapter', () => {
       sandboxMode: 'workspace-write',
     });
 
-    expect(sdkOptions[0]).toMatchObject({
+    expect(sdkOptions.at(-1)).toMatchObject({
       model: 'sonnet',
       betas: ['context-1m-2025-08-07'],
     });

package/packages/claude/src/runtimeAdapter.ts

@@ -177,6 +177,7 @@ interface SDKSessionInfo {
 type SessionMessage = SDKMessage;
 interface ModelInfo {
   value: string;
+  resolvedModel?: string;
   displayName: string;
   description: string;
   supportedEffortLevels?: string[];
@@ -711,7 +712,7 @@ function mapModelInfo(model: ModelInfo, index: number): AgentModel {
   return {
     id: model.value,
     model: model.value,
-    displayName: model.displayName,
+    displayName: versionedClaudeModelDisplayName(model),
     description: model.description,
     isDefault: index === 0,
     hidden: false,
@@ -723,11 +724,56 @@ function mapModelInfo(model: ModelInfo, index: number): AgentModel {
   };
 }
 
+function versionedClaudeModelDisplayName(model: ModelInfo) {
+  const resolved = model.resolvedModel?.match(
+    /^claude-(sonnet|opus|haiku|fable)-(\d+)(?:-(\d+))?(?:-|\[|$)/i,
+  );
+  if (!resolved) {
+    return model.displayName;
+  }
+
+  const family = `${resolved[1]![0]!.toUpperCase()}${resolved[1]!.slice(1).toLowerCase()}`;
+  const version = resolved[3] ? `${resolved[2]}.${resolved[3]}` : resolved[2]!;
+  if (model.value === 'default') {
+    return `Default · ${family} ${version}`;
+  }
+
+  const qualifier = model.displayName.match(/\s*(\([^)]+\))\s*$/)?.[1];
+  return `${family} · ${version}${qualifier ? ` ${qualifier}` : ''}`;
+}
+
+function versionedAlias(
+  alias: AgentModel,
+  discovered: AgentModel | undefined,
+  qualifier?: string,
+) {
+  if (!discovered) {
+    return alias;
+  }
+  return {
+    ...alias,
+    displayName: `${discovered.displayName.replace(/\s+\([^)]+\)\s*$/, '')}${qualifier ?? ''}`,
+    description: discovered.description,
+    supportedReasoningEfforts: discovered.supportedReasoningEfforts,
+    defaultReasoningEffort: discovered.defaultReasoningEffort,
+  };
+}
+
 function withClaudeCodeModelAliases(models: AgentModel[]) {
-  const output = [...models];
-  const defaultSonnet = DEFAULT_CLAUDE_MODELS[0]!;
-  const oneMillionSonnet = DEFAULT_CLAUDE_MODELS[1]!;
-  const fable = DEFAULT_CLAUDE_MODELS[2]!;
+  const discoveredSonnet = models.find((model) => /^Sonnet · /.test(model.displayName));
+  const discoveredFable = models.find((model) => /^Fable · /.test(model.displayName));
+  const discoveredOpus = models.find((model) => /^Opus · /.test(model.displayName));
+  const output = models.filter(
+    (model) => model !== discoveredFable || discoveredFable.model === 'fable',
+  );
+  const defaultSonnet = versionedAlias(DEFAULT_CLAUDE_MODELS[0]!, discoveredSonnet);
+  const oneMillionSonnet = versionedAlias(
+    DEFAULT_CLAUDE_MODELS[1]!,
+    discoveredSonnet,
+    ' (1M context)',
+  );
+  const fable = versionedAlias(DEFAULT_CLAUDE_MODELS[2]!, discoveredFable);
+  const opus = versionedAlias(DEFAULT_CLAUDE_MODELS[3]!, discoveredOpus);
   const hasSonnetAlias = output.some((model) => model.model === 'sonnet');
   if (!hasSonnetAlias) {
     output.unshift(defaultSonnet);
@@ -738,6 +784,10 @@ function withClaudeCodeModelAliases(models: AgentModel[]) {
   if (!output.some((model) => model.model === 'fable')) {
     output.splice(2, 0, fable);
   }
+  if (!output.some((model) => model.model === 'opus')) {
+    const discoveredOpusIndex = output.findIndex((model) => /^Opus · /.test(model.displayName));
+    output.splice(discoveredOpusIndex >= 0 ? discoveredOpusIndex : output.length, 0, opus);
+  }
   return output.map((model, index) => ({
     ...model,
     isDefault: index === 0,
@@ -1344,6 +1394,7 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
   >();
   private subscriptionAuthKind: 'subscription' | 'apiKey' | 'unknown' = 'unknown';
   private subscriptionUsageObservedAt: string | null = null;
+  private modelOptionsCache: AgentModel[] | null = null;
   private readonly historicalTurnIdAliases = new Map<string, Map<string, string>>();
   private readonly clientApp: string;
   private sdkLoadError: string | null = null;
@@ -1509,15 +1560,35 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
 
   async listModels(): Promise<AgentModel[]> {
     const active = [...this.activeTurns.values()][0];
-    if (!active) {
-      return DEFAULT_CLAUDE_MODELS;
+    if (!active && this.modelOptionsCache) {
+      return this.modelOptionsCache;
     }
 
+    let query = active?.query ?? null;
+
     try {
-      const models = await active.query.supportedModels();
-      return withClaudeCodeModelAliases(models.map(mapModelInfo));
+      query ??= this.queryFactory({
+        prompt: '',
+        options: queryOptionsForRuntime({
+          home: this.options.home,
+          command: this.options.command,
+          clientApp: this.clientApp,
+          approvalMode: 'guarded',
+          includePartialMessages: false,
+          tools: [],
+          maxTurns: 1,
+        }),
+      });
+      const models = await query.supportedModels();
+      const mapped = withClaudeCodeModelAliases(models.map(mapModelInfo));
+      this.modelOptionsCache = mapped;
+      return mapped;
     } catch {
-      return DEFAULT_CLAUDE_MODELS;
+      return this.modelOptionsCache ?? DEFAULT_CLAUDE_MODELS;
+    } finally {
+      if (!active && query) {
+        query.close();
+      }
     }
   }