kanna-code 0.32.3 → 0.33.0

package/src/server/codex-app-server.test.ts

@@ -120,6 +120,38 @@ describe("CodexAppServerManager", () => {
     ])
   })
 
+  test("forks a thread when a pending fork session token is provided", async () => {
+    const process = new FakeCodexProcess((message, child) => {
+      if (message.method === "initialize") {
+        child.writeServerMessage({ id: message.id, result: { userAgent: "codex-test" } })
+      } else if (message.method === "thread/fork") {
+        child.writeServerMessage({
+          id: message.id,
+          result: { thread: { id: "thread-fork-1" }, model: "gpt-5.4", reasoningEffort: "high" },
+        })
+      }
+    })
+
+    const manager = new CodexAppServerManager({
+      spawnProcess: () => process as never,
+    })
+
+    const sessionToken = await manager.startSession({
+      chatId: "chat-1",
+      cwd: "/tmp/project",
+      model: "gpt-5.4",
+      sessionToken: null,
+      pendingForkSessionToken: "thread-source",
+    })
+
+    expect(sessionToken).toBe("thread-fork-1")
+    expect(process.messages.map((message: any) => message.method)).toEqual([
+      "initialize",
+      "initialized",
+      "thread/fork",
+    ])
+  })
+
   test("maps fast mode and reasoning into app-server params", async () => {
     const process = new FakeCodexProcess((message, child) => {
       if (message.method === "initialize") {

package/src/server/codex-app-server.ts

@@ -34,6 +34,8 @@ import {
   type ThreadItem,
   type ThreadResumeParams,
   type ThreadResumeResponse,
+  type ThreadForkParams,
+  type ThreadForkResponse,
   type ThreadStartParams,
   type ThreadStartResponse,
   type ThreadTokenUsageUpdatedNotification,
@@ -118,6 +120,7 @@ export interface StartCodexSessionArgs {
   model: string
   serviceTier?: ServiceTier
   sessionToken: string | null
+  pendingForkSessionToken?: string | null
 }
 
 export interface StartCodexTurnArgs {
@@ -745,7 +748,7 @@ export class CodexAppServerManager {
 
   async startSession(args: StartCodexSessionArgs) {
     const existing = this.sessions.get(args.chatId)
-    if (existing && !existing.closed && existing.cwd === args.cwd) {
+    if (existing && !existing.closed && existing.cwd === args.cwd && !args.pendingForkSessionToken) {
       return
     }
 
@@ -791,8 +794,18 @@ export class CodexAppServerManager {
       persistExtendedHistory: false,
     } satisfies ThreadStartParams
 
-    let response: ThreadStartResponse | ThreadResumeResponse
-    if (args.sessionToken) {
+    let response: ThreadStartResponse | ThreadResumeResponse | ThreadForkResponse
+    if (args.pendingForkSessionToken) {
+      response = await this.sendRequest<ThreadForkResponse>(context, "thread/fork", {
+        threadId: args.pendingForkSessionToken,
+        model: args.model,
+        cwd: args.cwd,
+        serviceTier: args.serviceTier,
+        approvalPolicy: "never",
+        sandbox: "danger-full-access",
+        persistExtendedHistory: false,
+      } satisfies ThreadForkParams)
+    } else if (args.sessionToken) {
       try {
         response = await this.sendRequest<ThreadResumeResponse>(context, "thread/resume", {
           threadId: args.sessionToken,
@@ -815,6 +828,7 @@ export class CodexAppServerManager {
     }
 
     context.sessionToken = response.thread.id
+    return context.sessionToken
   }
 
   async startTurn(args: StartCodexTurnArgs): Promise<HarnessTurn> {

package/src/server/diff-store.ts

@@ -121,15 +121,6 @@ type SelectedBranch =
       remoteRef?: string
     }
 
-async function fileExists(filePath: string) {
-  try {
-    await stat(filePath)
-    return true
-  } catch {
-    return false
-  }
-}
-
 async function runGit(args: string[], cwd: string) {
   const process = Bun.spawn(["git", "-C", cwd, ...args], {
     stdout: "pipe",

package/src/server/event-store.test.ts

@@ -354,13 +354,85 @@ describe("EventStore", () => {
     const second = await store.openProject("/tmp/project-b")
 
     await store.setSidebarProjectOrder([second.id, first.id])
-    expect(store.state.sidebarProjectOrder).toEqual([second.id, first.id])
+    expect(store.getSidebarProjectOrder()).toEqual([second.id, first.id])
+    expect(JSON.parse(await readFile(join(dataDir, "sidebar-order.json"), "utf8"))).toEqual([second.id, first.id])
 
     await store.compact()
 
+    const snapshot = JSON.parse(await readFile(join(dataDir, "snapshot.json"), "utf8")) as SnapshotFile
+    expect(snapshot.sidebarProjectOrder).toBeUndefined()
+
     const reloaded = new EventStore(dataDir)
     await reloaded.initialize()
-    expect(reloaded.state.sidebarProjectOrder).toEqual([second.id, first.id])
+    expect(reloaded.getSidebarProjectOrder()).toEqual([second.id, first.id])
+  })
+
+  test("migrates legacy sidebar project order from existing snapshots and project logs", async () => {
+    const dataDir = await createTempDataDir()
+    const snapshotPath = join(dataDir, "snapshot.json")
+    const projectsLogPath = join(dataDir, "projects.jsonl")
+
+    const snapshot: SnapshotFile = {
+      v: 2,
+      generatedAt: 10,
+      projects: [
+        {
+          id: "project-1",
+          localPath: "/tmp/project-a",
+          title: "Project A",
+          createdAt: 1,
+          updatedAt: 1,
+        },
+        {
+          id: "project-2",
+          localPath: "/tmp/project-b",
+          title: "Project B",
+          createdAt: 2,
+          updatedAt: 2,
+        },
+      ],
+      chats: [],
+      sidebarProjectOrder: ["project-1"],
+    }
+
+    await writeFile(snapshotPath, JSON.stringify(snapshot, null, 2), "utf8")
+    await writeFile(projectsLogPath, [
+      JSON.stringify({
+        v: 2,
+        type: "sidebar_project_order_set",
+        timestamp: 20,
+        projectIds: ["project-2", "project-1"],
+      }),
+      "",
+    ].join("\n"), "utf8")
+
+    const store = new EventStore(dataDir)
+    await store.initialize()
+
+    expect(store.getSidebarProjectOrder()).toEqual(["project-2", "project-1"])
+    expect(JSON.parse(await readFile(join(dataDir, "sidebar-order.json"), "utf8"))).toEqual(["project-2", "project-1"])
+  })
+
+  test("ignores an invalid sidebar order file without resetting store state", async () => {
+    const dataDir = await createTempDataDir()
+    await writeFile(join(dataDir, "sidebar-order.json"), "{not-json", "utf8")
+
+    const originalWarn = console.warn
+    console.warn = () => {}
+    try {
+      const store = new EventStore(dataDir)
+      await store.initialize()
+
+      const project = await store.openProject("/tmp/project")
+
+      const reloaded = new EventStore(dataDir)
+      await reloaded.initialize()
+
+      expect(reloaded.getProject(project.id)?.localPath).toBe("/tmp/project")
+      expect(reloaded.getSidebarProjectOrder()).toEqual([])
+    } finally {
+      console.warn = originalWarn
+    }
   })
 
   test("prunes stale empty chats after thirty minutes", async () => {
@@ -439,4 +511,30 @@ describe("EventStore", () => {
     expect(pruned).toEqual([])
     expect(store.getChat(chat.id)?.id).toBe(chat.id)
   })
+
+  test("forks a chat with copied transcript and pending fork session token", async () => {
+    const dataDir = await createTempDataDir()
+    const store = new EventStore(dataDir)
+    await store.initialize()
+
+    const project = await store.openProject("/tmp/project")
+    const source = await store.createChat(project.id)
+    await store.setChatProvider(source.id, "claude")
+    await store.setPlanMode(source.id, true)
+    await store.setSessionToken(source.id, "session-1")
+    await store.appendMessage(source.id, entry("user_prompt", source.createdAt + 1, { content: "analyze this" }))
+    await store.appendMessage(source.id, entry("assistant_text", source.createdAt + 2, { text: "done" }))
+
+    const forked = await store.forkChat(source.id)
+
+    expect(forked.id).not.toBe(source.id)
+    expect(forked.title).toBe("Fork: New Chat")
+    expect(forked.provider).toBe("claude")
+    expect(forked.planMode).toBe(true)
+    expect(forked.sessionToken).toBeNull()
+    expect(forked.pendingForkSessionToken).toBe("session-1")
+    expect(forked.lastTurnOutcome).toBeNull()
+    expect(forked.lastMessageAt).toBeUndefined()
+    expect(store.getMessages(forked.id)).toEqual(store.getMessages(source.id))
+  })
 })

package/src/server/event-store.ts

@@ -20,6 +20,25 @@ import { resolveLocalPath } from "./paths"
 
 const COMPACTION_THRESHOLD_BYTES = 2 * 1024 * 1024
 const STALE_EMPTY_CHAT_MAX_AGE_MS = 30 * 60 * 1000
+const SIDEBAR_PROJECT_ORDER_FILE = "sidebar-order.json"
+
+function normalizeSidebarProjectOrder(value: unknown) {
+  if (!Array.isArray(value)) {
+    return []
+  }
+
+  const seen = new Set<string>()
+  const projectIds: string[] = []
+  for (const entry of value) {
+    if (typeof entry !== "string") continue
+    const projectId = entry.trim()
+    if (!projectId || seen.has(projectId)) continue
+    seen.add(projectId)
+    projectIds.push(projectId)
+  }
+
+  return projectIds
+}
 
 function isSendToStartingProfilingEnabled() {
   return process.env.KANNA_PROFILE_SEND_TO_STARTING === "1"
@@ -59,7 +78,6 @@ function getReplayEventPriority(event: StoreEvent) {
   switch (event.type) {
     case "project_opened":
     case "project_removed":
-    case "sidebar_project_order_set":
       return 0
     case "chat_created":
       return 1
@@ -76,6 +94,8 @@ function getReplayEventPriority(event: StoreEvent) {
       return 5
     case "session_token_set":
       return 6
+    case "pending_fork_session_token_set":
+      return 6
     case "turn_cancelled":
       return 7
     case "turn_finished":
@@ -112,6 +132,12 @@ function getHistorySnapshot(page: TranscriptPageResult, recentLimit: number): Ch
   }
 }
 
+function getForkedChatTitle(title: string) {
+  const trimmed = title.trim()
+  if (!trimmed) return "Fork: New Chat"
+  return trimmed.startsWith("Fork: ") ? trimmed : `Fork: ${trimmed}`
+}
+
 export class EventStore {
   readonly dataDir: string
   readonly state: StoreState = createEmptyState()
@@ -124,7 +150,10 @@ export class EventStore {
   private readonly queuedMessagesLogPath: string
   private readonly turnsLogPath: string
   private readonly transcriptsDir: string
+  private readonly sidebarProjectOrderPath: string
   private legacyMessagesByChatId = new Map<string, TranscriptEntry[]>()
+  private legacySidebarProjectOrder: string[] = []
+  private sidebarProjectOrder: string[] = []
   private snapshotHasLegacyMessages = false
   private cachedTranscript: { chatId: string; entries: TranscriptEntry[] } | null = null
 
@@ -137,6 +166,7 @@ export class EventStore {
     this.queuedMessagesLogPath = path.join(this.dataDir, "queued-messages.jsonl")
     this.turnsLogPath = path.join(this.dataDir, "turns.jsonl")
     this.transcriptsDir = path.join(this.dataDir, "transcripts")
+    this.sidebarProjectOrderPath = path.join(this.dataDir, SIDEBAR_PROJECT_ORDER_FILE)
   }
 
   async initialize() {
@@ -149,6 +179,7 @@ export class EventStore {
     await this.ensureFile(this.turnsLogPath)
     await this.loadSnapshot()
     await this.replayLogs()
+    await this.loadSidebarProjectOrder()
     if (!(await this.hasLegacyTranscriptData()) && await this.shouldCompact()) {
       await this.compact()
     }
@@ -197,9 +228,10 @@ export class EventStore {
         this.state.chatsById.set(chat.id, {
           ...chat,
           unread: chat.unread ?? false,
+          pendingForkSessionToken: chat.pendingForkSessionToken ?? null,
         })
       }
-      this.state.sidebarProjectOrder = [...(parsed.sidebarProjectOrder ?? [])]
+      this.legacySidebarProjectOrder = normalizeSidebarProjectOrder(parsed.sidebarProjectOrder)
       if (parsed.queuedMessages?.length) {
         for (const queuedSet of parsed.queuedMessages) {
           this.state.queuedMessagesByChatId.set(queuedSet.chatId, queuedSet.entries.map((entry) => ({
@@ -225,7 +257,8 @@ export class EventStore {
     this.state.projectIdsByPath.clear()
     this.state.chatsById.clear()
     this.state.queuedMessagesByChatId.clear()
-    this.state.sidebarProjectOrder = []
+    this.sidebarProjectOrder = []
+    this.legacySidebarProjectOrder = []
     this.cachedTranscript = null
   }
 
@@ -234,6 +267,86 @@ export class EventStore {
     this.snapshotHasLegacyMessages = false
   }
 
+  private async loadSidebarProjectOrder() {
+    const file = Bun.file(this.sidebarProjectOrderPath)
+    if (await file.exists()) {
+      try {
+        const text = await file.text()
+        if (!text.trim()) {
+          this.sidebarProjectOrder = []
+          return
+        }
+        this.sidebarProjectOrder = normalizeSidebarProjectOrder(JSON.parse(text))
+      } catch (error) {
+        console.warn(`${LOG_PREFIX} Failed to load ${SIDEBAR_PROJECT_ORDER_FILE}, ignoring saved order:`, error)
+        this.sidebarProjectOrder = []
+      }
+      return
+    }
+
+    const legacySidebarProjectOrder = await this.loadLegacySidebarProjectOrder()
+    this.sidebarProjectOrder = legacySidebarProjectOrder
+    if (legacySidebarProjectOrder.length > 0) {
+      await this.writeSidebarProjectOrderFile(legacySidebarProjectOrder)
+    }
+  }
+
+  private async loadLegacySidebarProjectOrder() {
+    const fromProjectsLog = await this.readLegacySidebarProjectOrderFromProjectsLog()
+    if (fromProjectsLog.length > 0) {
+      return fromProjectsLog
+    }
+    return [...this.legacySidebarProjectOrder]
+  }
+
+  private async readLegacySidebarProjectOrderFromProjectsLog() {
+    const file = Bun.file(this.projectsLogPath)
+    if (!(await file.exists())) return []
+
+    const text = await file.text()
+    if (!text.trim()) return []
+
+    const lines = text.split("\n")
+    let lastNonEmpty = -1
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+      if (lines[index].trim()) {
+        lastNonEmpty = index
+        break
+      }
+    }
+
+    let projectIds: string[] = []
+    for (let index = 0; index < lines.length; index += 1) {
+      const line = lines[index].trim()
+      if (!line) continue
+      try {
+        const event = JSON.parse(line) as {
+          v?: number
+          type?: string
+          projectIds?: unknown
+        }
+        if (event.v !== STORE_VERSION || event.type !== "sidebar_project_order_set") {
+          continue
+        }
+        projectIds = normalizeSidebarProjectOrder(event.projectIds)
+      } catch (error) {
+        if (index === lastNonEmpty) {
+          console.warn(`${LOG_PREFIX} Ignoring corrupt trailing line in ${path.basename(this.projectsLogPath)} while migrating sidebar order`)
+          return projectIds
+        }
+        console.warn(`${LOG_PREFIX} Failed to migrate sidebar order from ${path.basename(this.projectsLogPath)}:`, error)
+        return []
+      }
+    }
+
+    return projectIds
+  }
+
+  private async writeSidebarProjectOrderFile(projectIds: string[]) {
+    await mkdir(this.dataDir, { recursive: true })
+    await writeFile(this.sidebarProjectOrderPath, `${JSON.stringify(projectIds, null, 2)}\n`, "utf8")
+  }
+
   private async replayLogs() {
     if (this.storageReset) return
     const replayEvents = [
@@ -283,6 +396,9 @@ export class EventStore {
           await this.clearStorage()
           return []
         }
+        if ((event as { type?: unknown }).type === "sidebar_project_order_set") {
+          continue
+        }
         parsedEvents.push({
           event: event as StoreEvent,
           sourceIndex,
@@ -325,10 +441,6 @@ export class EventStore {
         this.state.projectIdsByPath.delete(project.localPath)
         break
       }
-      case "sidebar_project_order_set": {
-        this.state.sidebarProjectOrder = [...event.projectIds]
-        break
-      }
       case "chat_created": {
       const chat = {
           id: event.chatId,
@@ -340,6 +452,7 @@ export class EventStore {
           provider: null,
           planMode: false,
           sessionToken: null,
+          pendingForkSessionToken: null,
           hasMessages: false,
           lastTurnOutcome: null,
         }
@@ -452,6 +565,13 @@ export class EventStore {
         chat.updatedAt = event.timestamp
         break
       }
+      case "pending_fork_session_token_set": {
+        const chat = this.state.chatsById.get(event.chatId)
+        if (!chat) break
+        chat.pendingForkSessionToken = event.pendingForkSessionToken
+        chat.updatedAt = event.timestamp
+        break
+      }
     }
   }
 
@@ -541,7 +661,7 @@ export class EventStore {
     })
 
     const uniqueProjectIds = [...new Set(validProjectIds)]
-    const current = this.state.sidebarProjectOrder
+    const current = this.sidebarProjectOrder
     if (
       uniqueProjectIds.length === current.length
       && uniqueProjectIds.every((projectId, index) => current[index] === projectId)
@@ -549,13 +669,11 @@ export class EventStore {
       return
     }
 
-    const event: ProjectEvent = {
-      v: STORE_VERSION,
-      type: "sidebar_project_order_set",
-      timestamp: Date.now(),
-      projectIds: uniqueProjectIds,
-    }
-    await this.append(this.projectsLogPath, event)
+    this.writeChain = this.writeChain.then(async () => {
+      await this.writeSidebarProjectOrderFile(uniqueProjectIds)
+      this.sidebarProjectOrder = [...uniqueProjectIds]
+    })
+    return this.writeChain
   }
 
   async createChat(projectId: string) {
@@ -576,6 +694,50 @@ export class EventStore {
     return this.state.chatsById.get(chatId)!
   }
 
+  async forkChat(sourceChatId: string) {
+    const sourceChat = this.requireChat(sourceChatId)
+    const sourceSessionToken = sourceChat.sessionToken ?? sourceChat.pendingForkSessionToken ?? null
+    if (!sourceChat.provider || !sourceSessionToken) {
+      throw new Error("Chat cannot be forked")
+    }
+
+    const chatId = crypto.randomUUID()
+    const createdAt = Date.now()
+    const createEvent: ChatEvent = {
+      v: STORE_VERSION,
+      type: "chat_created",
+      timestamp: createdAt,
+      chatId,
+      projectId: sourceChat.projectId,
+      title: getForkedChatTitle(sourceChat.title),
+    }
+    await this.append(this.chatsLogPath, createEvent)
+    await this.setChatProvider(chatId, sourceChat.provider)
+    await this.setPlanMode(chatId, sourceChat.planMode)
+    await this.setPendingForkSessionToken(chatId, sourceSessionToken)
+
+    const sourceEntries = this.getMessages(sourceChatId)
+    if (sourceEntries.length > 0) {
+      const transcriptPath = this.transcriptPath(chatId)
+      const payload = sourceEntries.map((entry) => JSON.stringify(entry)).join("\n")
+      this.writeChain = this.writeChain.then(async () => {
+        await mkdir(this.transcriptsDir, { recursive: true })
+        await writeFile(transcriptPath, `${payload}\n`, "utf8")
+        const chat = this.state.chatsById.get(chatId)
+        if (chat) {
+          chat.hasMessages = true
+          chat.updatedAt = Math.max(chat.updatedAt, createdAt)
+        }
+        if (this.cachedTranscript?.chatId === chatId) {
+          this.cachedTranscript = { chatId, entries: cloneTranscriptEntries(sourceEntries) }
+        }
+      })
+      await this.writeChain
+    }
+
+    return this.state.chatsById.get(chatId)!
+  }
+
   async renameChat(chatId: string, title: string) {
     const trimmed = title.trim()
     if (!trimmed) return
@@ -810,6 +972,19 @@ export class EventStore {
     await this.append(this.turnsLogPath, event)
   }
 
+  async setPendingForkSessionToken(chatId: string, pendingForkSessionToken: string | null) {
+    const chat = this.requireChat(chatId)
+    if ((chat.pendingForkSessionToken ?? null) === pendingForkSessionToken) return
+    const event: TurnEvent = {
+      v: STORE_VERSION,
+      type: "pending_fork_session_token_set",
+      timestamp: Date.now(),
+      chatId,
+      pendingForkSessionToken,
+    }
+    await this.append(this.turnsLogPath, event)
+  }
+
   getProject(projectId: string) {
     const project = this.state.projectsById.get(projectId)
     if (!project || project.deletedAt) return null
@@ -830,6 +1005,10 @@ export class EventStore {
     return chat
   }
 
+  getSidebarProjectOrder() {
+    return [...this.sidebarProjectOrder]
+  }
+
   private getMessagesPageFromEntries(entries: TranscriptEntry[], limit: number, beforeIndex?: number): TranscriptPageResult {
     if (entries.length === 0) {
       return { entries: [], hasOlder: false, olderCursor: null }
@@ -961,7 +1140,6 @@ export class EventStore {
       v: STORE_VERSION,
       generatedAt: Date.now(),
       projects: this.listProjects().map((project) => ({ ...project })),
-      sidebarProjectOrder: [...this.state.sidebarProjectOrder],
       chats: [...this.state.chatsById.values()]
         .filter((chat) => !chat.deletedAt)
         .map((chat) => ({ ...chat })),

package/src/server/events.ts

@@ -15,6 +15,7 @@ export interface ChatRecord {
   provider: AgentProvider | null
   planMode: boolean
   sessionToken: string | null
+  pendingForkSessionToken?: string | null
   hasMessages?: boolean
   lastMessageAt?: number
   lastTurnOutcome: "success" | "failed" | "cancelled" | null
@@ -25,7 +26,6 @@ export interface StoreState {
   projectIdsByPath: Map<string, string>
   chatsById: Map<string, ChatRecord>
   queuedMessagesByChatId: Map<string, QueuedChatMessage[]>
-  sidebarProjectOrder: string[]
 }
 
 export interface SnapshotFile {
@@ -50,11 +50,6 @@ export type ProjectEvent = {
   type: "project_removed"
   timestamp: number
   projectId: string
-} | {
-  v: 2
-  type: "sidebar_project_order_set"
-  timestamp: number
-  projectIds: string[]
 }
 
 export type ChatEvent =
@@ -158,6 +153,13 @@ export type TurnEvent =
       chatId: string
       sessionToken: string | null
     }
+  | {
+      v: 2
+      type: "pending_fork_session_token_set"
+      timestamp: number
+      chatId: string
+      pendingForkSessionToken: string | null
+    }
 
 export type StoreEvent = ProjectEvent | ChatEvent | MessageEvent | QueuedMessageEvent | TurnEvent
 
@@ -167,7 +169,6 @@ export function createEmptyState(): StoreState {
     projectIdsByPath: new Map(),
     chatsById: new Map(),
     queuedMessagesByChatId: new Map(),
-    sidebarProjectOrder: [],
   }
 }
 

package/src/server/provider-catalog.test.ts

@@ -3,6 +3,7 @@ import {
   codexServiceTierFromModelOptions,
   normalizeClaudeModelOptions,
   normalizeCodexModelOptions,
+  normalizeServerModel,
 } from "./provider-catalog"
 import { resolveClaudeApiModelId } from "../shared/types"
 
@@ -55,6 +56,11 @@ describe("provider catalog normalization", () => {
     expect(codexServiceTierFromModelOptions(normalized)).toBe("fast")
   })
 
+  test("normalizes server model ids through the shared alias catalog", () => {
+    expect(normalizeServerModel("claude", "opus")).toBe("claude-opus-4-7")
+    expect(normalizeServerModel("codex", "gpt-5-codex")).toBe("gpt-5.3-codex")
+  })
+
   test("resolves Claude API model ids for 1m context window", () => {
     expect(resolveClaudeApiModelId("claude-opus-4-7", "1m")).toBe("claude-opus-4-7[1m]")
     expect(resolveClaudeApiModelId("claude-sonnet-4-6", "200k")).toBe("claude-sonnet-4-6")

package/src/server/provider-catalog.ts

@@ -13,6 +13,7 @@ import {
   DEFAULT_CODEX_MODEL_OPTIONS,
   PROVIDERS,
   normalizeClaudeContextWindow,
+  normalizeProviderModelId,
   isClaudeReasoningEffort,
   isCodexReasoningEffort,
 } from "../shared/types"
@@ -43,8 +44,9 @@ export function getServerProviderCatalog(provider: AgentProvider): ProviderCatal
 
 export function normalizeServerModel(provider: AgentProvider, model?: string): string {
   const catalog = getServerProviderCatalog(provider)
-  if (model && catalog.models.some((candidate) => candidate.id === model)) {
-    return model
+  const normalizedModel = normalizeProviderModelId(provider, model, catalog.defaultModel)
+  if (catalog.models.some((candidate) => candidate.id === normalizedModel)) {
+    return normalizedModel
   }
   return catalog.defaultModel
 }