fix: pass appSessionId to resolveResumeModel in all provider runtimes

The /active-model endpoint stores model changes keyed by app session ID,
but provider runtimes called resolveResumeModel with only the provider-
native session ID, so the stored override was never found.

- Update resolveResumeModel to accept optional appSessionId parameter
- Pass appSessionId from handleChatSend to all provider runtimes
- Strip ANTHROPIC_MODEL env vars so explicit model option takes precedence
- Add test verifying appSessionId-based model resolution

Fixes #981 (runtime part)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: Kennems

server/claude-sdk.js

@@ -164,7 +164,9 @@ function mapCliOptionsToSDK(options = {}) {
 
   // Forward all host env vars (e.g. ANTHROPIC_BASE_URL) to the subprocess.
   // Since SDK 0.2.113, options.env replaces process.env instead of overlaying it.
-  sdkOptions.env = { ...process.env };
+  // Remove model-related env vars so the explicit model option takes precedence.
+  const { ANTHROPIC_MODEL: _m, ANTHROPIC_DEFAULT_OPUS_MODEL: _o, ANTHROPIC_DEFAULT_SONNET_MODEL: _s, ANTHROPIC_DEFAULT_HAIKU_MODEL: _h, ...envClean } = process.env;
+  sdkOptions.env = envClean;
 
   // Resolve the executable eagerly on Windows because the SDK uses raw child_process.spawn,
   // which does not reliably follow npm's shell wrappers like cross-spawn does.
@@ -475,6 +477,7 @@ async function queryClaudeSDK(command, options = {}, ws) {
       'claude',
       sessionId,
       options.model,
+      options.appSessionId,
     );
     let effortModels = CLAUDE_FALLBACK_MODELS;
     try {

server/cursor-cli.js

@@ -31,7 +31,7 @@ function isWorkspaceTrustPrompt(text = '') {
 async function spawnCursor(command, options = {}, ws) {
   return new Promise(async (resolve, reject) => {
     const { sessionId, projectPath, cwd, toolsSettings, skipPermissions, model, sessionSummary, images } = options;
-    const resolvedModel = await providerModelsService.resolveResumeModel('cursor', sessionId, model);
+    const resolvedModel = await providerModelsService.resolveResumeModel('cursor', sessionId, model, options.appSessionId);
     let capturedSessionId = sessionId; // Track session ID throughout the process
     let sessionCreatedSent = false; // Track if we've already sent session-created event
     let hasRetriedWithTrust = false;

server/modules/providers/services/provider-models.service.ts

@@ -324,15 +324,21 @@ export const createProviderModelsService = (dependencies: ProviderModelsServiceD
     provider: LLMProvider,
     sessionId: string | undefined,
     requestedModel?: string | null,
+    appSessionId?: string | null,
   ): Promise<string | undefined> => {
     const normalizedRequestedModel = typeof requestedModel === 'string' ? requestedModel.trim() : '';
-    if (!sessionId?.trim()) {
+    if (!sessionId?.trim() && !appSessionId?.trim()) {
       return normalizedRequestedModel || undefined;
     }
 
-    const changedModel = await getChangedActiveModel(provider, sessionId);
-    if (changedModel.supported && changedModel.changed && changedModel.model?.trim()) {
-      return changedModel.model.trim();
+    // Prefer appSessionId for looking up per-session model overrides,
+    // since that's what the /active-model endpoint stores against.
+    const lookupId = appSessionId?.trim() || sessionId?.trim();
+    if (lookupId) {
+      const changedModel = await getChangedActiveModel(provider, lookupId);
+      if (changedModel.supported && changedModel.changed && changedModel.model?.trim()) {
+        return changedModel.model.trim();
+      }
     }
 
     return normalizedRequestedModel || undefined;

server/modules/providers/tests/provider-models.service.test.ts

@@ -347,3 +347,46 @@ test('resolveResumeModel prefers a stored changed model over the requested one',
     await rm(tempRoot, { recursive: true, force: true });
   }
 });
+
+/**
+ * This test verifies that resolveResumeModel uses the appSessionId parameter
+ * to look up per-session model overrides, since the /active-model endpoint
+ * stores changes against the app session ID, not the provider-native session ID.
+ */
+test('resolveResumeModel uses appSessionId for model override lookup', async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'provider-model-appsession-'));
+  const activeModelChangesPath = path.join(tempRoot, 'session-model-changes.json');
+
+  try {
+    const service = createProviderModelsService({
+      activeModelChangesPath,
+      resolveProvider: (provider) => ({
+        models: {
+          getSupportedModels: async () => createModels(`${provider}-models`),
+          getCurrentActiveModel: async () => createCurrentActiveModel(`${provider}-active`),
+          changeActiveModel: async (input) => createSessionActiveModelChange(provider, input),
+        },
+      }),
+    });
+
+    // Store model change using app session ID (what the /active-model endpoint does)
+    await writeProviderSessionActiveModelChange('claude', {
+      sessionId: 'app-session-abc',
+      model: 'claude-opus-4-6',
+    }, {
+      filePath: activeModelChangesPath,
+    });
+
+    // When provider-native session ID differs from app session ID,
+    // resolveResumeModel should use appSessionId to find the override
+    const model = await service.resolveResumeModel(
+      'claude',
+      'provider-native-session-xyz', // different from app session ID
+      'claude-sonnet-4-6',
+      'app-session-abc', // app session ID where the change was stored
+    );
+    assert.equal(model, 'claude-opus-4-6');
+  } finally {
+    await rm(tempRoot, { recursive: true, force: true });
+  }
+});

server/modules/websocket/services/chat-websocket.service.ts

@@ -202,6 +202,9 @@ async function handleChatSend(
     resume: Boolean(session.provider_session_id),
     cwd: clientOptions.cwd ?? session.project_path ?? undefined,
     projectPath: session.project_path ?? clientOptions.projectPath,
+    // Pass the app-level session id so provider runtimes can resolve
+    // per-session model overrides stored by the /active-model endpoint.
+    appSessionId: sessionId,
   };
 
   try {

server/openai-codex.js

@@ -238,6 +238,7 @@ export async function queryCodex(command, options = {}, ws) {
     'codex',
     sessionId,
     model,
+    options.appSessionId,
   );
 
   const workingDirectory = cwd || projectPath || process.cwd();

server/opencode-cli.js

@@ -232,7 +232,7 @@ async function spawnOpenCode(command, options = {}, ws) {
       }
     };
 
-    void providerModelsService.resolveResumeModel('opencode', sessionId, model).then(async (resolvedModel) => {
+    void providerModelsService.resolveResumeModel('opencode', sessionId, model, options.appSessionId).then(async (resolvedModel) => {
       let effortModels = null;
       try {
         effortModels = (await providerModelsService.getProviderModels('opencode')).models;