@jingyi0605/codingns 0.9.5 → 0.9.7

package/dist/server/modules/sessions/session-history-service.js

@@ -1,4 +1,5 @@
-import { existsSync, readFileSync, statSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
 import { CapabilityService, ClaudeCodeAdapter, CodexAdapter, GeminiAdapter, KimiAdapter, LegnaCodeAdapter, OpenCodeAdapter, ProviderRegistry, SessionSyncService } from "@codingns/session-sync-core";
 import { AppError } from "../../shared/errors/app-error.js";
 import { hashContent } from "../../shared/utils/hash.js";
@@ -21,6 +22,7 @@ import { ProviderRuntimeStateService } from "../provider/provider-runtime-state-
 import { createTaskManager } from "../tasks/task-manager.js";
 import { HOST_TASK_TYPES } from "../tasks/task-types.js";
 import { CodexAppServerHelperClient } from "./codex-app-server-helper-client.js";
+import { CodexSessionTitleGenerator } from "./codex-session-title-generator.js";
 import { CodingnsProviderSessionDeleteCli } from "./provider-session-delete-cli.js";
 const RECONSTRUCTED_FORK_TARGET_PROVIDERS = new Set(["codex", "claude-code", "opencode"]);
 const FORK_RECONSTRUCTION_PAGE_SIZE = 200;
@@ -79,6 +81,7 @@ export class SessionHistoryService {
     providerDiscoveryHelperClient = getSharedProviderDiscoveryHelperClient();
     providerSessionDiscoveryConfig;
     providerRuntimeStateService;
+    codexSessionTitleGenerator;
     sessionProviderConfigService;
     providerControlRepository;
     taskManager;
@@ -112,6 +115,10 @@ export class SessionHistoryService {
         this.sessionProviderConfigService = sessionProviderConfigService;
         this.providerRuntimeStateService = providerRuntimeStateService
             ?? new ProviderRuntimeStateService(config);
+        this.codexSessionTitleGenerator = new CodexSessionTitleGenerator({
+            hostDataRootDir: dirname(config.databasePath),
+            codexHomeDir: config.codexHomeDir
+        });
         this.providerControlRepository = providerControlRepository ?? {
             get: (providerId) => ({
                 providerId: providerId.trim(),
@@ -227,6 +234,14 @@ export class SessionHistoryService {
                 }
             });
         }
+        if (!this.taskManager.has(HOST_TASK_TYPES.sessionCodexTitleGenerate)) {
+            this.taskManager.register({
+                taskType: HOST_TASK_TYPES.sessionCodexTitleGenerate,
+                executionLane: "external_process",
+                timeoutMs: 45_000,
+                run: async ({ sessionId }, context) => this.runCodexSessionTitleGeneration(sessionId, context.signal)
+            });
+        }
     }
     async discoverWorkspaceSessions(workspaceId, userId, options) {
         const maxAgeMs = options?.maxAgeMs ?? 0;
@@ -314,6 +329,7 @@ export class SessionHistoryService {
             binding = await this.repairCodexDirtyBindingBeforeHistoryRead(resolvedSessionId, userId, binding);
             repairBindingMs = Date.now() - repairStartedAt;
         }
+        binding = this.repairClaudeEmptyBindingBeforeHistoryRead(resolvedSessionId, binding);
         const current = this.sessionStatusSnapshotRepository.findBySessionId(resolvedSessionId);
         const safeLimit = clampLimit(limit);
         const knownTotalLookupStartedAt = Date.now();
@@ -445,6 +461,7 @@ export class SessionHistoryService {
     async syncSessionTitle(sessionId, signal) {
         const binding = this.getBindingOrThrow(sessionId);
         await this.syncSessionTitleFromProvider(sessionId, binding, signal);
+        this.requestCodexTitleGenerationIfNeeded(sessionId, "session_history.sync_session_title");
     }
     async syncWorkspaceSessionTitles(workspaceId, userId, concurrency = 1, signal) {
         const sessions = this.sessionIndexRepository.listByWorkspace(workspaceId, userId);
@@ -495,8 +512,8 @@ export class SessionHistoryService {
             throw mapSessionProviderError(error);
         }
     }
-    async getSessionCapabilities(sessionId) {
-        const binding = this.getBindingOrThrow(sessionId);
+    async getSessionCapabilities(sessionId, userId) {
+        const binding = this.getBindingForUserOrThrow(sessionId, userId);
         const workspace = this.getWorkspaceOrThrow(binding.workspaceId);
         const workspacePath = workspace.path;
         return this.capabilityService
@@ -632,8 +649,8 @@ export class SessionHistoryService {
             throw mapSessionProviderError(error);
         }
     }
-    async resumeSession(sessionId) {
-        const binding = this.getBindingOrThrow(sessionId);
+    async resumeSession(sessionId, userId) {
+        const binding = this.getBindingForUserOrThrow(sessionId, userId);
         this.assertProviderCapabilityEnabled(binding.provider, "canResumeSession", "当前 provider 不支持继续会话");
         try {
             const result = await this.sessionSyncService.resumeSession(binding.provider, binding.providerSessionId, binding.rawStoreRef);
@@ -670,7 +687,7 @@ export class SessionHistoryService {
         return this.startSessionDirect(input);
     }
     async startSessionDirect(input) {
-        const workspace = this.getWorkspaceOrThrow(input.workspaceId);
+        const workspace = this.getWorkspaceForUserOrThrow(input.workspaceId, input.userId);
         this.assertProviderCapabilityEnabled(input.provider, "canStartSession", "当前 provider 不支持创建会话");
         const sessionId = createId();
         const providerBinding = this.prepareDirectSessionBinding({
@@ -687,6 +704,7 @@ export class SessionHistoryService {
             const persist = this.db.transaction(() => {
                 this.sessionBindingRepository.upsert({
                     sessionId,
+                    userId: input.userId,
                     workspaceId: workspace.id,
                     provider: result.session.provider,
                     providerSessionId: result.session.providerSessionId,
@@ -745,9 +763,9 @@ export class SessionHistoryService {
         }
     }
     async forkSession(input) {
-        const binding = this.getBindingOrThrow(input.sessionId);
+        const binding = this.getBindingForUserOrThrow(input.sessionId, input.userId);
         const targetWorkspaceId = input.targetWorkspaceId?.trim() || binding.workspaceId;
-        const workspace = this.getWorkspaceOrThrow(targetWorkspaceId);
+        const workspace = this.getWorkspaceForUserOrThrow(targetWorkspaceId, input.userId);
         const targetProvider = input.targetProvider?.trim() || binding.provider;
         this.assertProviderCapabilityEnabled(targetProvider, "canStartSession", "当前 provider 不支持 fork 创建会话");
         const sourceMessageId = input.sourceType === "message"
@@ -789,6 +807,7 @@ export class SessionHistoryService {
             this.db.transaction(() => {
                 this.sessionBindingRepository.upsert({
                     sessionId,
+                    userId: input.userId,
                     workspaceId: workspace.id,
                     provider: result.session.provider,
                     providerSessionId: result.session.providerSessionId,
@@ -1037,8 +1056,8 @@ export class SessionHistoryService {
         }
         return depth;
     }
-    async sendMessage(sessionId, content, clientRequestId, permissionMode = null) {
-        const binding = this.getBindingOrThrow(sessionId);
+    async sendMessage(sessionId, userId, content, clientRequestId, permissionMode = null) {
+        const binding = this.getBindingForUserOrThrow(sessionId, userId);
         this.assertProviderSendEnabled(binding.provider, "sessionId", "当前 provider 不支持继续发送消息");
         const result = await this.sessionSyncService
             .sendMessage(binding.provider, binding.providerSessionId, binding.rawStoreRef, content, clientRequestId, permissionMode)
@@ -1148,6 +1167,7 @@ export class SessionHistoryService {
             return null;
         }
         await this.syncSessionTitleFromProvider(sessionId, binding);
+        this.requestCodexTitleGenerationIfNeeded(sessionId, "session_history.read_recent_history");
         const snapshot = this.sessionStatusSnapshotRepository.findBySessionId(sessionId);
         this.upsertSnapshot(sessionId, {
             syncStatus: "idle",
@@ -1235,6 +1255,7 @@ export class SessionHistoryService {
             });
             this.sessionBindingRepository.upsert({
                 ...binding,
+                userId: input.userId,
                 rawStoreRef: result.rawStoreRef,
                 updatedAt: timestamp
             });
@@ -1365,6 +1386,10 @@ export class SessionHistoryService {
                     const currentIndex = this.sessionIndexRepository.findIndexRecordBySessionId(sessionId);
                     this.sessionBindingRepository.upsert({
                         sessionId,
+                        userId: snapshot.userId
+                            ?? currentBinding?.userId
+                            ?? duplicateBinding?.userId
+                            ?? this.resolveWorkspaceOwnerUserId(workspaceId),
                         workspaceId,
                         provider: resolvedSnapshot.provider,
                         providerSessionId: resolvedSnapshot.providerSessionId,
@@ -1402,7 +1427,7 @@ export class SessionHistoryService {
     async runDiscoverWorkspaceSessions(workspaceId, userId, refreshStateMode = "inline", signal) {
         const startedAt = Date.now();
         const debugStartedAtMs = terminalDebugNowMs();
-        const workspace = this.getWorkspaceOrThrow(workspaceId);
+        const workspace = this.getWorkspaceForUserOrThrow(workspaceId, userId);
         let discoverDurationMs = 0;
         let persistDurationMs = 0;
         let persistPass1DurationMs = 0;
@@ -1470,6 +1495,7 @@ export class SessionHistoryService {
                         : null;
                     const nextBinding = {
                         sessionId,
+                        userId,
                         workspaceId: workspace.id,
                         provider: session.provider,
                         providerSessionId: session.providerSessionId,
@@ -1614,6 +1640,10 @@ export class SessionHistoryService {
                 cleanupDurationMs = Date.now() - cleanupStartedAt;
             }
             this.workspaceSessionRelations.set(workspaceId, relationMap);
+            this.observeDiscoveredProviderActivity(sessions, discoveredSessionIds, userId, timestamp);
+            for (const persisted of persistedSessions) {
+                this.requestCodexTitleGenerationIfNeeded(persisted.sessionId, "session_history.discover_workspace_sessions.codex_title");
+            }
             const listItemsStartedAt = Date.now();
             const items = this.sessionIndexRepository.listByWorkspace(workspaceId, userId);
             listItemsDurationMs = Date.now() - listItemsStartedAt;
@@ -1901,6 +1931,72 @@ export class SessionHistoryService {
         }
         return relationMap;
     }
+    observeDiscoveredProviderActivity(sessions, discoveredSessionIds, userId, timestamp) {
+        for (const session of sessions) {
+            const providerObservation = session.activityObservation ?? null;
+            if (!providerObservation) {
+                continue;
+            }
+            const sessionId = discoveredSessionIds.get(buildProviderSessionKey(session.provider, session.providerSessionId));
+            if (!sessionId) {
+                continue;
+            }
+            const observedAt = providerObservation.observedAt ?? timestamp;
+            const resolution = this.sessionActivityAuthorityService.observe({
+                sessionId,
+                runId: providerObservation.runId ?? null,
+                runningState: providerObservation.runningState,
+                source: "authoritative_provider_event",
+                confidence: providerObservation.confidence,
+                detail: providerObservation.detail ?? null,
+                interruptSource: providerObservation.runningState === "interrupted" ? "runtime" : null,
+                errorCode: providerObservation.errorCode ?? null,
+                observedAt
+            });
+            const current = this.sessionStateRepository.findBySessionAndUser(sessionId, userId);
+            this.sessionStateRepository.upsert({
+                sessionId,
+                userId,
+                runningState: mapResolvedRunningStateToStored(resolution.runningState, current),
+                activitySource: "runtime",
+                favorite: current?.favorite ?? false,
+                lastEventAt: resolution.lastObservedAt ?? current?.lastEventAt ?? null,
+                completedAt: isTerminalResolvedRunningState(resolution.runningState)
+                    ? resolution.terminalAt ?? current?.completedAt ?? observedAt
+                    : null,
+                lastSeenAt: current?.lastSeenAt ?? null,
+                updatedAt: timestamp
+            });
+            const currentSnapshot = this.sessionStatusSnapshotRepository.findBySessionId(sessionId);
+            const shouldClearFailure = currentSnapshot?.syncStatus === "error"
+                && providerObservation.runningState !== "failed";
+            this.sessionStatusSnapshotRepository.upsert({
+                sessionId,
+                syncStatus: providerObservation.runningState === "failed"
+                    ? "error"
+                    : shouldClearFailure
+                        ? "idle"
+                        : currentSnapshot?.syncStatus ?? "idle",
+                syncCursor: currentSnapshot?.syncCursor ?? null,
+                lastSyncAt: resolution.lastObservedAt
+                    ?? resolution.terminalAt
+                    ?? currentSnapshot?.lastSyncAt
+                    ?? null,
+                lastErrorCode: providerObservation.runningState === "failed"
+                    ? providerObservation.errorCode ?? "CODEX_PROVIDER_EVENT_FAILED"
+                    : shouldClearFailure
+                        ? null
+                        : currentSnapshot?.lastErrorCode ?? null,
+                lastErrorDetail: providerObservation.runningState === "failed"
+                    ? providerObservation.detail ?? "Provider reported session failure"
+                    : shouldClearFailure
+                        ? null
+                        : currentSnapshot?.lastErrorDetail ?? null,
+                resumedAt: currentSnapshot?.resumedAt ?? null,
+                updatedAt: timestamp
+            });
+        }
+    }
     enrichSessionItems(workspaceId, items) {
         const relationMap = this.workspaceSessionRelations.get(workspaceId);
         const projectionBySessionId = this.buildParallelProjectionBySessionId(items);
@@ -2125,6 +2221,7 @@ export class SessionHistoryService {
             return;
         }
         await this.syncSessionTitleFromProvider(sessionId, binding);
+        this.requestCodexTitleGenerationIfNeeded(sessionId, "session_history.publish_history_envelope");
         const snapshot = this.sessionStatusSnapshotRepository.findBySessionId(sessionId);
         this.upsertSnapshot(sessionId, {
             syncStatus: "idle",
@@ -2177,6 +2274,83 @@ export class SessionHistoryService {
             updatedAt: nowIso()
         });
     }
+    requestCodexTitleGenerationIfNeeded(sessionId, source) {
+        if (!this.shouldRequestCodexTitleGeneration(sessionId)) {
+            return;
+        }
+        const handle = this.taskManager.enqueue(HOST_TASK_TYPES.sessionCodexTitleGenerate, {
+            key: sessionId,
+            source,
+            input: {
+                sessionId
+            }
+        });
+        if (handle.deduped) {
+            return;
+        }
+        void handle.promise.catch((error) => {
+            logPerformance("session.codex_title_generate.background_failed", 0, {
+                sessionId,
+                error: error instanceof Error ? error.message : "unknown"
+            }, {
+                thresholdMs: 0,
+                force: true
+            });
+        });
+    }
+    shouldRequestCodexTitleGeneration(sessionId) {
+        const binding = this.sessionBindingRepository.findBySessionId(sessionId);
+        const index = this.sessionIndexRepository.findIndexRecordBySessionId(sessionId);
+        if (!binding || !index || binding.provider !== "codex") {
+            return false;
+        }
+        if (isPendingBindingValue(binding.providerSessionId) || isPendingBindingValue(binding.rawStoreRef)) {
+            return false;
+        }
+        if (index.messageCount <= 0) {
+            return false;
+        }
+        return true;
+    }
+    async runCodexSessionTitleGeneration(sessionId, signal) {
+        const binding = this.sessionBindingRepository.findBySessionId(sessionId);
+        const index = this.sessionIndexRepository.findIndexRecordBySessionId(sessionId);
+        if (!binding || !index || binding.provider !== "codex") {
+            return { title: null };
+        }
+        if (isPendingBindingValue(binding.providerSessionId) || isPendingBindingValue(binding.rawStoreRef)) {
+            return { title: null };
+        }
+        const page = await this.sessionSyncService.readHistory(binding.provider, binding.providerSessionId, binding.rawStoreRef, null, 16, "forward").catch(() => null);
+        if (!page) {
+            return { title: null };
+        }
+        const firstUserMessage = page.messages.find((message) => message.role === "user")?.content ?? null;
+        if (!shouldGenerateCodexSessionTitle(index.title, firstUserMessage)) {
+            return { title: null };
+        }
+        const title = await this.codexSessionTitleGenerator.generate({
+            currentTitle: index.title,
+            messages: page.messages.map((message) => ({
+                role: message.role,
+                content: message.content
+            })),
+            signal
+        });
+        if (!title || !shouldApplyGeneratedCodexSessionTitle(title, firstUserMessage)) {
+            return { title: null };
+        }
+        await this.sessionSyncService.renameSessionTitle(binding.provider, binding.providerSessionId, binding.rawStoreRef, title);
+        const latestIndex = this.sessionIndexRepository.findIndexRecordBySessionId(sessionId);
+        if (latestIndex && shouldGenerateCodexSessionTitle(latestIndex.title, firstUserMessage)) {
+            this.sessionIndexRepository.upsert({
+                ...latestIndex,
+                title,
+                updatedAt: nowIso()
+            });
+        }
+        return { title };
+    }
     async readFirstUserMessageTitleForSync(binding) {
         const pageSize = 20;
         const maxPages = 3;
@@ -2241,6 +2415,31 @@ export class SessionHistoryService {
         }
         return workspace;
     }
+    getWorkspaceForUserOrThrow(workspaceId, userId) {
+        const workspace = this.getWorkspaceOrThrow(workspaceId);
+        if (workspace.ownerUserId !== userId) {
+            throw new AppError({
+                statusCode: 404,
+                errorCode: "WORKSPACE_NOT_FOUND",
+                detail: "工作区不存在"
+            });
+        }
+        return workspace;
+    }
+    getBindingForUserOrThrow(sessionId, userId) {
+        const binding = this.sessionBindingRepository.findBySessionIdForUser(sessionId, userId);
+        if (!binding) {
+            throw new AppError({
+                statusCode: 404,
+                errorCode: "SESSION_NOT_FOUND",
+                detail: "session 不存在"
+            });
+        }
+        return this.resolvePendingSessionAliasBinding(binding) ?? binding;
+    }
+    resolveWorkspaceOwnerUserId(workspaceId) {
+        return this.workspaceRepository.findById(workspaceId)?.ownerUserId ?? null;
+    }
     getSessionListItemOrThrow(sessionId, userId) {
         const canonicalSessionId = this.resolveCanonicalSessionId(sessionId, userId);
         const item = this.findSessionListItem(canonicalSessionId, sessionId, userId)
@@ -2614,6 +2813,7 @@ export class SessionHistoryService {
         if (!targetBinding) {
             this.sessionBindingRepository.upsert({
                 sessionId: input.targetSessionId,
+                userId: sourceBinding.userId ?? this.resolveWorkspaceOwnerUserId(input.workspaceId),
                 workspaceId: input.workspaceId,
                 provider: input.provider,
                 providerSessionId: buildPendingBindingValue(input.provider, input.targetSessionId),
@@ -2698,6 +2898,7 @@ export class SessionHistoryService {
         // 保留旧 session_id 作为 alias，避免前端或 Butler 还拿着旧 id 时直接炸成 SESSION_NOT_FOUND。
         this.sessionBindingRepository.upsert({
             sessionId: input.sourceSessionId,
+            userId: sourceBinding.userId ?? this.resolveWorkspaceOwnerUserId(sourceBinding.workspaceId),
             workspaceId: sourceBinding.workspaceId,
             provider: sourceBinding.provider,
             providerSessionId: buildAliasBindingValue(input.provider, input.targetSessionId, input.sourceSessionId),
@@ -3101,6 +3302,21 @@ export class SessionHistoryService {
             this.codexDirtyBindingRepairStates.set(sessionId, currentState);
         });
     }
+    repairClaudeEmptyBindingBeforeHistoryRead(sessionId, binding) {
+        if (!shouldRepairClaudeEmptyHistoryBinding(binding)) {
+            return binding;
+        }
+        const repairedRawStoreRef = findBestClaudeHistoryFileNearBinding(binding);
+        if (!repairedRawStoreRef || repairedRawStoreRef === binding.rawStoreRef) {
+            return binding;
+        }
+        this.persistSessionBinding(sessionId, binding.workspaceId, {
+            provider: binding.provider,
+            providerSessionId: binding.providerSessionId,
+            rawStoreRef: repairedRawStoreRef
+        });
+        return this.getBindingOrThrow(sessionId);
+    }
     resolveLiveActivityObservation(sessionId) {
         for (const resolver of this.liveActivityObservationResolvers) {
             const observation = resolver(sessionId);
@@ -3596,6 +3812,69 @@ function shouldSkipClaudePendingBinding(binding) {
 function isPendingBindingValue(value) {
     return value.trim().toLowerCase().startsWith("pending://");
 }
+function shouldRepairClaudeEmptyHistoryBinding(binding) {
+    if (binding.provider !== "claude-code") {
+        return false;
+    }
+    if (isPendingBindingValue(binding.providerSessionId) || isPendingBindingValue(binding.rawStoreRef)) {
+        return false;
+    }
+    const currentStats = safeStat(binding.rawStoreRef);
+    return !currentStats || currentStats.size === 0;
+}
+function findBestClaudeHistoryFileNearBinding(binding) {
+    const providerSessionId = binding.providerSessionId.trim();
+    if (!providerSessionId || isPendingBindingValue(providerSessionId)) {
+        return null;
+    }
+    const candidates = new Set();
+    for (const projectsRoot of collectClaudeProjectsRootsNearBinding(binding)) {
+        for (const candidate of listClaudeSessionCandidates(projectsRoot, providerSessionId)) {
+            candidates.add(candidate);
+        }
+    }
+    const nonEmptyCandidates = Array.from(candidates)
+        .map((filePath) => ({
+        filePath,
+        stats: safeStat(filePath)
+    }))
+        .filter((candidate) => Boolean(candidate.stats && candidate.stats.size > 0))
+        .sort((left, right) => {
+        if (right.stats.size !== left.stats.size) {
+            return right.stats.size - left.stats.size;
+        }
+        return right.stats.mtimeMs - left.stats.mtimeMs;
+    });
+    return nonEmptyCandidates[0]?.filePath ?? null;
+}
+function collectClaudeProjectsRootsNearBinding(binding) {
+    const roots = new Set();
+    const rawStoreRef = binding.rawStoreRef.trim();
+    if (rawStoreRef && !isPendingBindingValue(rawStoreRef)) {
+        // rawStoreRef 通常是 <home>/projects/<workspace-slug>/<session>.jsonl。
+        // 即使 <workspace-slug> 算错了，向上两级仍然能拿到正确的 projects 根。
+        roots.add(dirname(dirname(rawStoreRef)));
+    }
+    const runtimeHomeDir = binding.runtimeHomeDir?.trim() ?? "";
+    if (runtimeHomeDir) {
+        roots.add(join(runtimeHomeDir, "projects"));
+    }
+    return Array.from(roots);
+}
+function listClaudeSessionCandidates(projectsRoot, providerSessionId) {
+    if (!projectsRoot || !existsSync(projectsRoot)) {
+        return [];
+    }
+    try {
+        return readdirSync(projectsRoot, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => join(projectsRoot, entry.name, `${providerSessionId}.jsonl`))
+            .filter((filePath) => existsSync(filePath));
+    }
+    catch {
+        return [];
+    }
+}
 function isSessionBindingProviderUniqueConflict(error) {
     if (!(error instanceof Error)) {
         return false;
@@ -4080,6 +4359,25 @@ function shouldSyncSessionTitleFromProvider(provider, currentTitle, firstUserMes
     }
     return false;
 }
+function shouldGenerateCodexSessionTitle(currentTitle, firstUserMessage) {
+    const normalizedTitle = currentTitle?.trim() ?? "";
+    if (!normalizedTitle) {
+        return true;
+    }
+    if (looksLikeGeneratedSessionTitle(normalizedTitle) || isSyntheticCodexSessionTitle(normalizedTitle)) {
+        return true;
+    }
+    const firstUserTitle = normalizeRuntimePromptTitle(firstUserMessage);
+    return Boolean(firstUserTitle && normalizedTitle === firstUserTitle);
+}
+function shouldApplyGeneratedCodexSessionTitle(generatedTitle, firstUserMessage) {
+    const normalizedTitle = generatedTitle.trim();
+    const firstUserTitle = normalizeRuntimePromptTitle(firstUserMessage);
+    if (!normalizedTitle) {
+        return false;
+    }
+    return !firstUserTitle || normalizedTitle !== firstUserTitle;
+}
 function looksLikeSyntheticTitleSourceMessage(provider, content) {
     const normalizedProvider = provider.trim().toLowerCase();
     if (normalizedProvider === "codex") {