@gkorepanov/ccodex 0.4.18 → 0.4.20

package/dist/claude/service.js

@@ -14,16 +14,17 @@ import { SdkTranscriptBrancher, } from "./transcriptBrancher.js";
 import { ClaudeRateLimitCoordinator, } from "./rateLimits.js";
 import { isClaudeStatusCommand } from "./statusCommand.js";
 import { systemNoticeText } from "../gateway/transientNotice.js";
-import { claudeCatalogId, normalizeClaudeModelIdentifier, normalizeClaudeServiceTier, resolveClaudeModel, } from "./modelSelection.js";
+import { claudeCatalogId, normalizeClaudeModelIdentifier, normalizeClaudeServiceTier, pickClaudeModelReplacement, resolveClaudeModel, } from "./modelSelection.js";
 import { ClaudeOutputAdapter } from "./session/outputAdapter.js";
 import { branchRevision, ClaudeSessionRepository } from "./session/repository.js";
-import { ClaudeSession } from "./session/session.js";
+import { ActiveClaudeTurnError, ClaudeSession } from "./session/session.js";
 import { ShellRunner } from "./session/shellRunner.js";
 import { ClaudeSessionRegistry } from "./sessionRegistry.js";
 import { validateResponseItems } from "./responseItemValidation.js";
 import { providerUnavailableMessage, } from "../runtime/providerAvailability.js";
 import { isCCodexStateCommand, stateModelName, } from "../state/stateCommand.js";
 import { syncedCollaborationMode, threadSettings } from "./threadSettings.js";
+import { claudeDeveloperInstructions } from "./developerInstructions.js";
 function recordValue(value) {
     return value && typeof value === "object" ? value : undefined;
 }
@@ -158,7 +159,9 @@ function threadResponse(record, includeTurns) {
         ...settings,
         thread: {
             ...record.thread,
-            isPinned: record.thread.isPinned ?? false,
+            section: record.thread.section ?? null,
+            sectionEnteredAt: record.thread.sectionEnteredAt ?? null,
+            projectId: record.thread.projectId ?? null,
             canAcceptDirectInput: record.thread.parentThreadId ? false : true,
             turns: includeTurns ? record.thread.turns : [],
         },
@@ -302,10 +305,12 @@ export class ClaudeService {
             interactiveQuestions: this.config.features?.interactiveQuestions ?? true,
             resolveChildModel: (model) => {
                 const value = normalizeClaudeModelIdentifier(model);
-                const modelPickerId = this.modelCatalog?.cachedPickerId?.(value)
-                    ?? (value.startsWith(this.config.modelPrefix) ? value : `${this.config.modelPrefix}${value}`);
+                const modelPickerId = value.startsWith(this.config.modelPrefix) ? value : `${this.config.modelPrefix}${value}`;
                 const claudeModelValue = resolveClaudeModel(this.config, modelPickerId);
-                return claudeModelValue ? { modelPickerId, claudeModelValue } : undefined;
+                if (!claudeModelValue)
+                    return undefined;
+                const lookup = this.cachedCatalogLookup(claudeModelValue);
+                return lookup ? this.catalogSelection(modelPickerId, claudeModelValue, lookup) : { modelPickerId, claudeModelValue };
             },
         }));
         const records = this.store.allThreadRecords();
@@ -417,11 +422,47 @@ export class ClaudeService {
         return threadSettings(this.withCatalogModel(this.requireRecord(threadId, false)));
     }
     withCatalogModel(record) {
-        const modelPickerId = this.modelCatalog?.cachedPickerId?.(record.resolvedModel ?? record.claudeModelValue);
-        if (!modelPickerId || modelPickerId === record.modelPickerId)
+        const lookup = this.cachedCatalogLookup(record.resolvedModel ?? record.claudeModelValue);
+        if (!lookup)
             return record;
-        const claudeModelValue = resolveClaudeModel(this.config, modelPickerId);
-        return claudeModelValue ? { ...record, modelPickerId, claudeModelValue } : record;
+        const selection = this.catalogSelection(record.modelPickerId, record.claudeModelValue, lookup);
+        return selection.modelPickerId === record.modelPickerId ? record : { ...record, ...selection };
+    }
+    /** Finds the catalog entry for a Claude model value, migrating retired ids onto the closest current model. */
+    catalogLookup(models, claudeModelValue) {
+        const catalog = this.modelCatalog;
+        const cached = catalog.cachedPickerId?.(claudeModelValue);
+        if (cached)
+            return { id: cached, model: models.find((candidate) => candidate.id === cached), reason: "exact" };
+        const prefix = this.config.modelPrefix;
+        const strip = (id) => id.slice(prefix.length);
+        const defaultId = catalog.defaultModelId?.();
+        const replacement = pickClaudeModelReplacement(claudeModelValue, models.map((candidate) => strip(candidate.id)), defaultId && strip(defaultId));
+        const model = replacement && models.find((candidate) => strip(candidate.id) === replacement.value);
+        return model ? { id: model.id, model, reason: replacement.reason } : undefined;
+    }
+    cachedCatalogLookup(claudeModelValue) {
+        return this.modelCatalog && this.catalogLookup(this.modelCatalog.cachedModels?.() ?? [], claudeModelValue);
+    }
+    catalogSelection(modelPickerId, claudeModelValue, lookup) {
+        const prefix = this.config.modelPrefix;
+        if (lookup.id === `${prefix}${claudeModelValue}` || lookup.id === claudeCatalogId(this.config, modelPickerId))
+            return { modelPickerId, claudeModelValue };
+        this.logger.warn("claude.model.migrated", { from: modelPickerId, to: lookup.id, reason: lookup.reason });
+        return { modelPickerId: lookup.id, claudeModelValue: lookup.id.slice(prefix.length) };
+    }
+    /** Persists a catalog migration for a stored thread so its runtime starts on a model the account still has. */
+    async migrateStoredModel(threadId) {
+        if (!this.modelCatalog)
+            return;
+        const record = this.requireRecord(threadId, false);
+        const models = await this.modelCatalog.list().catch(() => undefined);
+        const lookup = models && this.catalogLookup(models, record.claudeModelValue);
+        if (!lookup)
+            return;
+        const selection = this.catalogSelection(record.modelPickerId, record.claudeModelValue, lookup);
+        if (selection.modelPickerId !== record.modelPickerId)
+            await this.applySettings({ threadId, model: selection.modelPickerId });
     }
     sideSnapshot(sourceThreadId, targetThreadId, visibleForkedFromId) {
         const record = this.requireRecord(sourceThreadId, false);
@@ -530,6 +571,7 @@ export class ClaudeService {
                     : {}),
             });
         }
+        await this.migrateStoredModel(threadId);
         await (await this.sessions.getOrCreate(threadId)).materializeRuntime();
         record = await this.sessions.submit(threadId, { type: "readThread", includeTurns: true });
         record = this.withCatalogModel(record);
@@ -629,6 +671,39 @@ export class ClaudeService {
             throw error;
         }
     }
+    async prepareAppTurn(params) {
+        try {
+            return await this.prepareTurn(params);
+        }
+        catch (error) {
+            if (!(error instanceof ActiveClaudeTurnError))
+                throw error;
+            const { turnId } = await this.steerTurn({
+                threadId: params.threadId,
+                input: params.input,
+                expectedTurnId: error.turnId,
+                ...(params.clientUserMessageId === undefined
+                    ? {}
+                    : { clientUserMessageId: params.clientUserMessageId }),
+                ...(params.responsesapiClientMetadata === undefined
+                    ? {}
+                    : { responsesapiClientMetadata: params.responsesapiClientMetadata }),
+                ...(params.additionalContext === undefined
+                    ? {}
+                    : { additionalContext: params.additionalContext }),
+            });
+            const turn = this.requireRecord(params.threadId, true).thread.turns
+                .find((candidate) => candidate.id === turnId);
+            if (!turn)
+                throw new Error(`Active Claude turn '${turnId}' disappeared after steering.`);
+            return {
+                response: { turn },
+                announce: () => Promise.resolve(),
+                start: () => undefined,
+                startAndWait: () => Promise.resolve(),
+            };
+        }
+    }
     async prepareStatusTurn(params, render) {
         this.requireIndependentThread(params.threadId, "start a status turn in");
         if (!isClaudeStatusCommand(params.input))
@@ -933,9 +1008,20 @@ export class ClaudeService {
     }
     updateThreadMetadata(params) {
         this.requireIndependentThread(params.threadId, "update metadata for");
+        if (params.projectId !== undefined && params.projectId !== null && params.projectId !== "") {
+            throw invalidParams("Projects are not supported for Claude threads.");
+        }
         return this.sessions.submit(params.threadId, {
             type: "threadAdmin",
-            command: { kind: "metadata", gitInfo: params.gitInfo, isPinned: params.isPinned },
+            command: { kind: "metadata", gitInfo: params.gitInfo },
+        });
+    }
+    /** Section registry stays stock-owned; CCodex records only the membership. */
+    setThreadSection(threadId, section) {
+        this.requireIndependentThread(threadId, "move into a section");
+        return this.sessions.submit(threadId, {
+            type: "threadAdmin",
+            command: { kind: "metadata", gitInfo: undefined, section },
         });
     }
     async archiveThread(threadId) {
@@ -1115,9 +1201,8 @@ export class ClaudeService {
         if (sourceRecord.thread.ephemeral && !sidePromotion) {
             throw invalidParams("Forking this ephemeral Claude source thread is not supported.");
         }
-        const modelPickerId = params.model ?? sourceRecord.modelPickerId;
-        const claudeModelValue = resolveClaudeModel(this.config, modelPickerId);
-        if (!claudeModelValue)
+        const requestedModel = params.model ?? sourceRecord.modelPickerId;
+        if (!resolveClaudeModel(this.config, requestedModel))
             throw invalidParams("Cannot fork a Claude thread to a Codex model.");
         const activeSideFork = Boolean(params.ephemeral === true && params.excludeTurns === true
             && params.threadSource === "user" && !params.lastTurnId && !params.beforeTurnId);
@@ -1161,8 +1246,10 @@ export class ClaudeService {
         const sourceBoundaries = source.boundaries.filter((entry) => stableSelectedIds.has(entry.turnId));
         const revisionTurns = sourceTurns.filter((turn) => stableSelectedIds.has(turn.id));
         const revision = branchRevision(sourceRecord, sourceBoundaries, revisionTurns);
-        const serviceTier = normalizeClaudeServiceTier(this.config, modelPickerId, params.serviceTier === undefined ? sourceRecord.serviceTier : params.serviceTier);
-        await this.validateModelSettings(modelPickerId, sourceRecord.reasoningEffort, serviceTier);
+        const requestedServiceTier = normalizeClaudeServiceTier(this.config, requestedModel, params.serviceTier === undefined ? sourceRecord.serviceTier : params.serviceTier);
+        const { modelPickerId, claudeModelValue, reasoningEffort, serviceTier } = await this.resolveModelSettings(requestedModel, sourceRecord.reasoningEffort, requestedServiceTier);
+        if (serviceTier !== requestedServiceTier)
+            throw invalidParams(`Claude model '${requestedModel}' does not support the fast service tier.`);
         const boundary = selectedBoundary?.messageUuid ?? sourceBoundaries.at(-1)?.messageUuid;
         const branch = boundary
             ? await this.transcripts.forkWithProvenance(sourceRecord.claudeSessionId, boundary, sourceRecord.thread.cwd, sourceBoundaries.map((entry) => entry.messageUuid), boundaryCorrelations(this.store, sourceRecord, sourceBoundaries))
@@ -1186,7 +1273,8 @@ export class ClaudeService {
         });
         const threadId = uuidv7();
         const thread = {
-            ...sourceRecord.thread, id: threadId, ephemeral: params.ephemeral ?? false, isPinned: false,
+            ...sourceRecord.thread, id: threadId, ephemeral: params.ephemeral ?? false,
+            section: null, sectionEnteredAt: null, projectId: null,
             sessionId: threadId, forkedFromId: visibleForkedFromId,
             cwd, modelProvider: "claude", createdAt, updatedAt: createdAt, recencyAt: createdAt,
             status: params.ephemeral ? { type: "idle" } : { type: "notLoaded" },
@@ -1199,7 +1287,7 @@ export class ClaudeService {
         const copiedTurns = sourceTurns.map((turn) => forkProjection(turn, thread.id));
         const record = {
             ...sourceRecord, thread, runtimeWorkspaceRoots,
-            claudeSessionId: branch.sessionId, modelPickerId, claudeModelValue, serviceTier,
+            claudeSessionId: branch.sessionId, modelPickerId, claudeModelValue, serviceTier, reasoningEffort,
             approvalPolicy: params.approvalPolicy ?? sourceRecord.approvalPolicy,
             approvalsReviewer: approvalsReviewer(params.approvalsReviewer, sourceRecord.approvalsReviewer),
             sandboxPolicy: params.permissions
@@ -1208,8 +1296,8 @@ export class ClaudeService {
                     ? sandboxPolicy(params.sandbox, cwd, runtimeWorkspaceRoots)
                     : inheritedSandboxPolicy(sourceRecord.sandboxPolicy, cwd, runtimeWorkspaceRoots),
             baseInstructions: params.baseInstructions === undefined ? sourceRecord.baseInstructions : params.baseInstructions,
-            developerInstructions: params.developerInstructions === undefined
-                ? sourceRecord.developerInstructions : params.developerInstructions,
+            developerInstructions: claudeDeveloperInstructions(params.developerInstructions === undefined
+                ? sourceRecord.developerInstructions : params.developerInstructions),
             lastClaudeMessageUuid: null, lastCompletedTurnId: null,
         };
         let responseRecord;
@@ -1247,21 +1335,42 @@ export class ClaudeService {
         return threadResponse(responseRecord, !params.excludeTurns);
     }
     async rollbackThread(params) {
-        this.requireIndependentThread(params.threadId, "roll back");
-        const source = await this.sessions.submit(params.threadId, { type: "snapshotBranch" });
-        const sourceRecord = source.record;
-        if (sourceRecord.thread.ephemeral)
-            throw invalidParams("Rolling back an ephemeral Claude thread is not supported.");
+        const source = await this.truncationSource(params.threadId, "roll back");
         if (!Number.isInteger(params.numTurns) || params.numTurns < 1)
             throw invalidParams("numTurns must be at least 1.");
-        if (params.numTurns > sourceRecord.thread.turns.length)
+        if (params.numTurns > source.record.thread.turns.length)
             throw invalidParams("Cannot remove more turns than the Claude thread contains.");
-        const sourceSession = await this.sessions.getOrCreate(params.threadId);
-        if ((await sourceSession.runtimeInspection())?.quiescent === false)
-            throw invalidParams("Cannot roll back a Claude thread with an active turn.");
-        const keepCount = sourceRecord.thread.turns.length - params.numTurns;
-        const retained = sourceRecord.thread.turns.slice(0, keepCount);
-        const retainedIds = new Set(retained.map((turn) => turn.id));
+        const committed = await this.truncateThread(source, source.record.thread.turns.length - params.numTurns);
+        return { thread: committed.thread };
+    }
+    /** `thread/revert`: drops `beforeTurnId` and every later turn; the App hydrates retained history via the cursors. */
+    async revertThread(params) {
+        const source = await this.truncationSource(params.threadId, "revert");
+        const keepCount = source.record.thread.turns.findIndex((turn) => turn.id === params.beforeTurnId);
+        if (keepCount === -1)
+            throw invalidParams(`Unknown Claude turn '${params.beforeTurnId}'.`);
+        const retained = (await this.truncateThread(source, keepCount)).thread;
+        return {
+            thread: { ...retained, turns: [] },
+            turnsBackwardsCursor: retained.turns.length ? turnCursor(retained.turns.at(-1).id, true) : null,
+            itemsBackwardsCursor: retained.turns.some((turn) => turn.items.length) ? "hyb-item:0" : null,
+        };
+    }
+    async truncationSource(threadId, verb) {
+        this.requireIndependentThread(threadId, verb);
+        const snapshot = await this.sessions.submit(threadId, { type: "snapshotBranch" });
+        if (snapshot.record.thread.ephemeral)
+            throw invalidParams(`Cannot ${verb} an ephemeral Claude thread.`);
+        const session = await this.sessions.getOrCreate(threadId);
+        if ((await session.runtimeInspection())?.quiescent === false)
+            throw invalidParams(`Cannot ${verb} a Claude thread with an active turn.`);
+        return { ...snapshot, session };
+    }
+    /** Keeps the first `keepCount` turns by forking the transcript at the last retained provider boundary. */
+    async truncateThread(source, keepCount) {
+        const sourceRecord = source.record;
+        const threadId = sourceRecord.thread.id;
+        const retainedIds = new Set(sourceRecord.thread.turns.slice(0, keepCount).map((turn) => turn.id));
         const sourceBoundaries = source.boundaries.filter((entry) => retainedIds.has(entry.turnId));
         const boundary = sourceBoundaries.at(-1)?.messageUuid;
         const branch = boundary
@@ -1269,7 +1378,7 @@ export class ClaudeService {
             : { sessionId: uuidv7(), uuidMap: new Map() };
         let committed;
         try {
-            committed = await this.sessions.submit(params.threadId, {
+            committed = await this.sessions.submit(threadId, {
                 type: "commitRollback", expectedRevision: source.revision, replacementSessionId: branch.sessionId,
                 keepCount, sourceBoundaries, uuidMap: [...branch.uuidMap],
             });
@@ -1278,13 +1387,13 @@ export class ClaudeService {
             await this.transcripts.delete(branch.sessionId, sourceRecord.thread.cwd).catch(() => undefined);
             throw error;
         }
-        if (sourceSession.isLoaded) {
-            await sourceSession.retireRuntimeSilently().catch((error) => {
-                this.logger.warn("claude.rollback.old-runtime-retire-failed", { threadId: params.threadId, error: String(error) });
+        if (source.session.isLoaded) {
+            await source.session.retireRuntimeSilently().catch((error) => {
+                this.logger.warn("claude.rollback.old-runtime-retire-failed", { threadId, error: String(error) });
             });
         }
-        await this.transcripts.delete(sourceRecord.claudeSessionId, sourceRecord.thread.cwd).catch((error) => this.logger.warn("claude.rollback.old-session-delete-failed", { threadId: params.threadId, error: String(error) }));
-        return { thread: committed.thread };
+        await this.transcripts.delete(sourceRecord.claudeSessionId, sourceRecord.thread.cwd).catch((error) => this.logger.warn("claude.rollback.old-session-delete-failed", { threadId, error: String(error) }));
+        return committed;
     }
     prepareGoalSet(params) {
         this.requireIndependentThread(params.threadId, "set a goal on");
@@ -1603,7 +1712,9 @@ export class ClaudeService {
         if (!native)
             return {
                 ...record.thread,
-                isPinned: record.thread.isPinned ?? false,
+                section: record.thread.section ?? null,
+                sectionEnteredAt: record.thread.sectionEnteredAt ?? null,
+                projectId: record.thread.projectId ?? null,
                 canAcceptDirectInput: record.thread.parentThreadId ? false : true,
             };
         const createdAt = native.createdAt === undefined
@@ -1612,7 +1723,9 @@ export class ClaudeService {
         const updatedAt = Math.floor(native.lastModified / 1_000);
         return {
             ...record.thread,
-            isPinned: record.thread.isPinned ?? false,
+            section: record.thread.section ?? null,
+            sectionEnteredAt: record.thread.sectionEnteredAt ?? null,
+            projectId: record.thread.projectId ?? null,
             canAcceptDirectInput: record.thread.parentThreadId ? false : true,
             name: record.thread.name || native.customTitle || native.summary,
             preview: native.firstPrompt ?? record.thread.preview,
@@ -1670,17 +1783,15 @@ export class ClaudeService {
         return undefined;
     }
     async newThreadRecord(params, settings) {
-        const modelPickerId = params.model;
-        const claudeModelValue = modelPickerId && resolveClaudeModel(this.config, modelPickerId);
-        if (!modelPickerId || !claudeModelValue)
+        const requestedModel = params.model;
+        if (!requestedModel || !resolveClaudeModel(this.config, requestedModel))
             throw invalidParams("Claude thread requires a configured Claude model or alias.");
         if (params.permissions && params.sandbox)
             throw invalidParams("Claude thread start cannot combine permissions with sandbox.");
-        const requestedServiceTier = normalizeClaudeServiceTier(this.config, modelPickerId, params.serviceTier);
+        const requestedServiceTier = normalizeClaudeServiceTier(this.config, requestedModel, params.serviceTier);
         if (requestedServiceTier !== null && requestedServiceTier !== "default" && requestedServiceTier !== "fast")
             throw invalidParams(`Unsupported Claude service tier '${requestedServiceTier}'.`);
-        const reasoningEffort = settings?.effort ?? null;
-        const serviceTier = await this.validatedServiceTier(modelPickerId, reasoningEffort, requestedServiceTier);
+        const { modelPickerId, claudeModelValue, reasoningEffort, serviceTier } = await this.resolveModelSettings(requestedModel, settings?.effort ?? null, requestedServiceTier);
         const createdAt = nowSeconds();
         const workspace = workspaceSelection(params);
         const { cwd, runtimeWorkspaceRoots } = workspace;
@@ -1693,7 +1804,9 @@ export class ClaudeService {
                 parentThreadId: null,
                 preview: "",
                 ephemeral: params.ephemeral ?? false,
-                isPinned: false,
+                section: null,
+                sectionEnteredAt: null,
+                projectId: null,
                 historyMode: params.historyMode ?? "legacy",
                 modelProvider: "claude",
                 createdAt,
@@ -1723,7 +1836,7 @@ export class ClaudeService {
                 ? permissionProfileSandboxPolicy(params.permissions, cwd, runtimeWorkspaceRoots)
                 : sandboxPolicy(params.sandbox, cwd, runtimeWorkspaceRoots),
             baseInstructions: params.baseInstructions ?? null,
-            developerInstructions: params.developerInstructions ?? null,
+            developerInstructions: claudeDeveloperInstructions(params.developerInstructions),
             personality: settings?.personality ?? params.personality ?? null,
             resolvedModel: null,
             lastClaudeMessageUuid: null,
@@ -1769,11 +1882,10 @@ export class ClaudeService {
         const session = await this.sessions.getOrCreate(params.threadId);
         for (;;) {
             const before = await this.sessions.submit(params.threadId, { type: "readThread", includeTurns: false });
-            const modelPickerId = params.model ?? before.modelPickerId;
-            const claudeModelValue = resolveClaudeModel(this.config, modelPickerId);
-            if (!claudeModelValue)
+            const requestedModel = params.model ?? before.modelPickerId;
+            if (!resolveClaudeModel(this.config, requestedModel))
                 throw invalidParams("Cannot switch a Claude thread to a Codex model.");
-            const requestedServiceTier = normalizeClaudeServiceTier(this.config, modelPickerId, params.serviceTier === undefined ? before.serviceTier : params.serviceTier);
+            const requestedServiceTier = normalizeClaudeServiceTier(this.config, requestedModel, params.serviceTier === undefined ? before.serviceTier : params.serviceTier);
             if (requestedServiceTier !== null && requestedServiceTier !== "default" && requestedServiceTier !== "fast")
                 throw invalidParams(`Unsupported Claude service tier '${requestedServiceTier}'.`);
             const { cwd, runtimeWorkspaceRoots } = workspaceSelection(params, {
@@ -1783,8 +1895,7 @@ export class ClaudeService {
             const workspaceChanged = cwd !== before.thread.cwd
                 || runtimeWorkspaceRoots.length !== storedWorkspaceRoots(before).length
                 || runtimeWorkspaceRoots.some((root, index) => root !== storedWorkspaceRoots(before)[index]);
-            const reasoningEffort = params.effort === undefined ? before.reasoningEffort : params.effort;
-            const serviceTier = await this.validatedServiceTier(modelPickerId, reasoningEffort, requestedServiceTier);
+            const { modelPickerId, claudeModelValue, reasoningEffort, serviceTier } = await this.resolveModelSettings(requestedModel, params.effort === undefined ? before.reasoningEffort : params.effort, requestedServiceTier, params.effort !== undefined);
             syncCanonicalSettings = requestedServiceTier === "fast" && serviceTier !== "fast";
             const collaborationMode = params.collaborationMode === undefined
                 ? before.collaborationMode
@@ -1839,24 +1950,30 @@ export class ClaudeService {
             }
         }
     }
-    async validatedServiceTier(modelId, effort, serviceTier) {
+    /**
+     * Resolves requested model settings against the account catalog. A model id the catalog no longer
+     * lists is migrated onto its closest current entry instead of failing the request, and an effort the
+     * target model does not support is coerced to that model's default unless it was requested explicitly.
+     */
+    async resolveModelSettings(modelPickerId, effort, serviceTier, explicitEffort = false) {
+        const claudeModelValue = resolveClaudeModel(this.config, modelPickerId);
         if (!this.modelCatalog)
-            return serviceTier;
-        const catalogId = claudeCatalogId(this.config, modelId);
-        const model = (await this.modelCatalog.list()).find((candidate) => candidate.id === catalogId);
-        if (!model)
-            throw invalidParams(`Claude model '${modelId}' is not present in the current account catalog.`);
-        if (effort && !model.supportedReasoningEfforts.some((level) => level.reasoningEffort === effort)) {
-            throw invalidParams(`Claude model '${modelId}' does not support effort '${effort}'.`);
-        }
-        return serviceTier === "fast" && !model.serviceTiers.some((tier) => tier.id === "fast")
-            ? null
-            : serviceTier;
-    }
-    async validateModelSettings(modelId, effort, serviceTier) {
-        if (await this.validatedServiceTier(modelId, effort, serviceTier) !== serviceTier) {
-            throw invalidParams(`Claude model '${modelId}' does not support the fast service tier.`);
-        }
+            return { modelPickerId, claudeModelValue, reasoningEffort: effort, serviceTier };
+        const lookup = this.catalogLookup(await this.modelCatalog.list(), claudeModelValue);
+        const model = lookup?.model;
+        if (!lookup || !model)
+            throw invalidParams(`Claude model '${modelPickerId}' is not present in the current account catalog.`);
+        const selection = this.catalogSelection(modelPickerId, claudeModelValue, lookup);
+        const effortSupported = !effort || model.supportedReasoningEfforts.some((level) => level.reasoningEffort === effort);
+        if (!effortSupported && explicitEffort && selection.modelPickerId === modelPickerId)
+            throw invalidParams(`Claude model '${modelPickerId}' does not support effort '${effort}'.`);
+        if (!effortSupported)
+            this.logger.warn("claude.effort.coerced", { model: model.id, from: effort, to: model.defaultReasoningEffort });
+        return {
+            ...selection,
+            reasoningEffort: effortSupported ? effort : model.supportedReasoningEfforts.length ? model.defaultReasoningEffort : null,
+            serviceTier: serviceTier === "fast" && !model.serviceTiers.some((tier) => tier.id === "fast") ? null : serviceTier,
+        };
     }
     async readStandaloneRateLimitStatus() {
         const abort = new AbortController();