circuschief 0.5.0 → 0.7.0

package/packages/server/src/services/streamEventCallbacks.js

@@ -3,71 +3,102 @@ import { broadcastToSession } from '../websocket.js';
 import { WS_MESSAGE_TYPES } from '../../../shared/src/index.js';
 import * as summaryService from './summaryService.js';
 import * as kanbanService from './kanbanService.js';
+import { createVisibleFinalErrorMessage } from './visibleFinalErrorMessage.js';
 import {
   lastMessageIds,
   activeSessions,
   activeConversationIds,
+  finalErrorSessionIds,
   associateAndBroadcastWorkLogs,
   broadcastSessionStatus,
   broadcastChangesUpdate,
 } from './streamEventHandler.js';
 
 /**
- * Handle post-turn completion logic (after stream loop ends successfully)
- * Encapsulates the duplicated completion block from runSession/continueSession/continueSessionWithExistingMessage
+ * Associate work logs with the last message and clean up tracking state.
  * @param {string} sessionId
- * @param {string} workingDirectory
- * @param {{ handleTemplateTriggerIfNeeded?: Function, checkProactiveReschedule?: Function, handleAutoSendIfNeeded?: Function }} callbacks
  */
-export async function handleTurnCompletion(sessionId, workingDirectory, callbacks = {}) {
-  const { handleTemplateTriggerIfNeeded, checkProactiveReschedule: _checkProactiveReschedule, handleAutoSendIfNeeded } = callbacks;
-  // Associate work logs with the last message now that the turn is complete
+function associateAndCleanupWorkLogs(sessionId) {
   const lastMessageId = lastMessageIds.get(sessionId);
   if (lastMessageId) {
     associateAndBroadcastWorkLogs(sessionId, lastMessageId);
     lastMessageIds.delete(sessionId);
   }
+}
 
-  // Session ready for follow-up - set to waiting instead of completed
-  const activeSession = activeSessions.get(sessionId);
-  if (activeSession && !activeSession.controller?.signal?.aborted) {
-    sessions.update(sessionId, { status: 'waiting' });
-    broadcastSessionStatus(sessionId, 'waiting');
-
-    // Check if session should be proactively rescheduled based on token threshold
-    if (_checkProactiveReschedule) {
-      const wasRescheduled = await _checkProactiveReschedule(sessionId);
-      if (wasRescheduled) {
-        return true; // Session was rescheduled, don't continue with normal completion
-      }
+/**
+ * Handle post-turn activities for a session that's ready for follow-up.
+ * @param {string} sessionId
+ * @param {string} workingDirectory
+ * @param {{ checkProactiveReschedule?: Function, handleAutoSendIfNeeded?: Function, handleTemplateTriggerIfNeeded?: Function }} callbacks
+ * @returns {Promise<boolean>} True if rescheduled, false otherwise
+ */
+async function handleActiveSessionCompletion(sessionId, workingDirectory, callbacks) {
+  sessions.update(sessionId, { status: 'waiting', error: null });
+  broadcastSessionStatus(sessionId, 'waiting');
+
+  // Check if session should be proactively rescheduled based on token threshold
+  const { checkProactiveReschedule } = callbacks;
+  if (checkProactiveReschedule) {
+    const wasRescheduled = await checkProactiveReschedule(sessionId);
+    if (wasRescheduled) {
+      return true; // Session was rescheduled, don't continue with normal completion
     }
+  }
 
-    // Extract PR URL immediately (lightweight, no API call)
-    summaryService.extractPrUrlIfNeeded(sessionId);
-    // Trigger debounced summary generation on turn completion (not complete yet)
-    summaryService.onSessionActivity(sessionId);
+  // Extract PR URL immediately (lightweight, no API call)
+  summaryService.extractPrUrlIfNeeded(sessionId);
+  // Trigger debounced summary generation on turn completion (not complete yet)
+  summaryService.onSessionActivity(sessionId);
 
-    // Broadcast changes update when turn completes (real-time indicator)
-    const currentSession = sessions.getById(sessionId);
-    if (currentSession) {
-      await broadcastChangesUpdate(sessionId, currentSession.projectId, workingDirectory);
-    }
+  // Broadcast changes update when turn completes (real-time indicator)
+  const currentSession = sessions.getById(sessionId);
+  if (currentSession) {
+    await broadcastChangesUpdate(sessionId, currentSession.projectId, workingDirectory);
+  }
 
-    // Handle kanban lane movements based on targetLaneId
-    await kanbanService.handleTurnCompletion(sessionId);
+  // Handle kanban lane movements based on targetLaneId
+  await kanbanService.handleTurnCompletion(sessionId);
 
-    // Auto-send queued prompt if enabled (runs BEFORE template trigger)
-    let autoSendFired = false;
-    if (handleAutoSendIfNeeded) {
-      autoSendFired = await handleAutoSendIfNeeded(sessionId);
-    }
+  // Auto-send queued prompt if enabled (runs BEFORE template trigger)
+  const { handleAutoSendIfNeeded, handleTemplateTriggerIfNeeded } = callbacks;
+  let autoSendFired = false;
+  if (handleAutoSendIfNeeded) {
+    autoSendFired = await handleAutoSendIfNeeded(sessionId);
+  }
 
-    // Only trigger next template if auto-send did NOT fire
-    // (if auto-send fired, template will trigger after that turn completes)
-    if (!autoSendFired && handleTemplateTriggerIfNeeded) {
-      await handleTemplateTriggerIfNeeded(sessionId);
-    }
+  // Only trigger next template if auto-send did NOT fire
+  // (if auto-send fired, template will trigger after that turn completes)
+  if (!autoSendFired && handleTemplateTriggerIfNeeded) {
+    await handleTemplateTriggerIfNeeded(sessionId);
   }
+
+  return false;
+}
+
+/**
+ * Handle post-turn completion logic (after stream loop ends successfully)
+ * Encapsulates the duplicated completion block from runSession/continueSession/continueSessionWithExistingMessage
+ * @param {string} sessionId
+ * @param {string} workingDirectory
+ * @param {{ handleTemplateTriggerIfNeeded?: Function, checkProactiveReschedule?: Function, handleAutoSendIfNeeded?: Function }} callbacks
+ */
+export async function handleTurnCompletion(sessionId, workingDirectory, callbacks = {}) {
+  // Associate work logs with the last message now that the turn is complete
+  associateAndCleanupWorkLogs(sessionId);
+
+  // Sessions with final errors should not transition to waiting
+  if (finalErrorSessionIds.has(sessionId)) {
+    finalErrorSessionIds.delete(sessionId);
+    return false;
+  }
+
+  // Session ready for follow-up - set to waiting instead of completed
+  const activeSession = activeSessions.get(sessionId);
+  if (activeSession && !activeSession.controller?.signal?.aborted) {
+    return handleActiveSessionCompletion(sessionId, workingDirectory, callbacks);
+  }
+
   return false;
 }
 
@@ -149,6 +180,7 @@ export async function handleSessionError(sessionId, error, options = {}) {
 
   // Normal error handling (no reschedule or reschedule limits reached)
   sessions.update(sessionId, { status: 'error', error: error.message });
+  createVisibleFinalErrorMessage(sessionId, error, activeConversationIds);
   broadcastToSession(sessionId, WS_MESSAGE_TYPES.SESSION_ERROR, { sessionId, error: error.message });
 
   // Optionally broadcast final conversation state (continueSession does this)

package/packages/server/src/services/streamEventHandler.js

@@ -10,6 +10,10 @@ import {
   handleTextDelta as _handleTextDelta,
   handleResultUsage,
 } from './streamUsageHandler.js';
+import {
+  createVisibleFinalErrorMessage,
+  normalizeFinalErrorMessage,
+} from './visibleFinalErrorMessage.js';
 
 // ── Shared module-level state ──────────────────────────────────────────────
 
@@ -34,6 +38,9 @@ export const currentModels = new Map();
 /** @type {Map<string, Set<string>>} Track tool_use IDs that have already been logged per session */
 export const loggedToolUseIds = new Map();
 
+/** @type {Set<string>} Track sessions that received a final result.error event */
+export const finalErrorSessionIds = new Set();
+
 // ── Helper functions ───────────────────────────────────────────────────────
 
 /**
@@ -206,6 +213,9 @@ function handleAssistantTextContent(sessionId, textContent, toolUseBlocks) {
   const currentModel = currentModels.get(sessionId) || null;
   const message = messages.create(sessionId, 'assistant', textContent, { toolUse, conversationId, model: currentModel });
 
+  // Touch the session to update its updated_at timestamp so it sorts to the top
+  sessions.touch(sessionId);
+
   // Associate pending work logs with this message immediately
   // This ensures work logs are attached to the correct message, not just the last one
   associateAndBroadcastWorkLogs(sessionId, message.id);
@@ -401,8 +411,11 @@ function handleResultEvent(sessionId, event) {
  * @param {Object} event
  */
 function handleResultError(sessionId, event) {
-  sessions.update(sessionId, { status: 'error', error: event.error });
-  broadcastToSession(sessionId, WS_MESSAGE_TYPES.SESSION_ERROR, { sessionId, error: event.error });
+  const errorMessage = normalizeFinalErrorMessage(event.error);
+  finalErrorSessionIds.add(sessionId);
+  sessions.update(sessionId, { status: 'error', error: errorMessage });
+  createVisibleFinalErrorMessage(sessionId, errorMessage, activeConversationIds);
+  broadcastToSession(sessionId, WS_MESSAGE_TYPES.SESSION_ERROR, { sessionId, error: errorMessage });
   // Broadcast error status to project subscribers for session list updates
   broadcastSessionStatus(sessionId, 'error');
   // Extract PR URL before generating summary (PR may have been created before error)
@@ -478,6 +491,7 @@ export function cleanupSessionState(sessionId, includeConversationId = false) {
   thinkingAccumulators.delete(sessionId);
   currentModels.delete(sessionId);
   loggedToolUseIds.delete(sessionId);
+  finalErrorSessionIds.delete(sessionId);
   activeSessions.delete(sessionId);
   if (includeConversationId) {
     activeConversationIds.delete(sessionId);

package/packages/server/src/services/streamUsageHandler.js

@@ -74,6 +74,7 @@ export function handleTextDelta(sessionId, delta, textAccumulators) {
   const turnData = currentTurnUsage.get(conversationId) || {
     inputTokens: 0,
     outputTokens: 0,
+    thinkingTokens: 0,
     lastMessageOutput: 0,
     cacheReadInputTokens: 0,
     cacheCreationInputTokens: 0,
@@ -83,6 +84,7 @@ export function handleTextDelta(sessionId, delta, textAccumulators) {
   const broadcastUsage = {
     inputTokens: turnData.inputTokens,
     outputTokens: turnData.outputTokens + Math.max(turnData.lastMessageOutput, newEstimate),
+    thinkingTokens: turnData.thinkingTokens,
     cacheReadInputTokens: turnData.cacheReadInputTokens,
     cacheCreationInputTokens: turnData.cacheCreationInputTokens,
   };
@@ -123,6 +125,7 @@ export function extractTurnUsage(sessionId, event) {
   return {
     inputTokens: resolveTokenField(modelUsageEntry, event.usage, { camel: 'inputTokens', snake: 'input_tokens' }),
     outputTokens: resolveTokenField(modelUsageEntry, event.usage, { camel: 'outputTokens', snake: 'output_tokens' }),
+    thinkingTokens: resolveTokenField(modelUsageEntry, event.usage, { camel: 'thinkingTokens', snake: 'thinking_tokens' }),
     cacheReadInputTokens: resolveTokenField(modelUsageEntry, event.usage, { camel: 'cacheReadInputTokens', snake: 'cache_read_input_tokens' }),
     cacheCreationInputTokens: resolveTokenField(modelUsageEntry, event.usage, { camel: 'cacheCreationInputTokens', snake: 'cache_creation_input_tokens' }),
     webSearchRequests: modelUsageEntry?.webSearchRequests || 0,
@@ -142,6 +145,7 @@ export function buildCumulativeSessionUsage(sessionId, turnUsage) {
   return {
     inputTokens: (currentSession.inputTokens || 0) + turnUsage.inputTokens,
     outputTokens: (currentSession.outputTokens || 0) + turnUsage.outputTokens,
+    thinkingTokens: (currentSession.thinkingTokens || 0) + turnUsage.thinkingTokens,
     cacheReadInputTokens: (currentSession.cacheReadInputTokens || 0) + turnUsage.cacheReadInputTokens,
     cacheCreationInputTokens: (currentSession.cacheCreationInputTokens || 0) + turnUsage.cacheCreationInputTokens,
     webSearchRequests: (currentSession.webSearchRequests || 0) + turnUsage.webSearchRequests,
@@ -162,6 +166,7 @@ export function updateConversationUsage(conversationId, currentConversation, tur
   const cumulativeConversationUsage = {
     inputTokens: (currentConversation.inputTokens || 0) + turnUsage.inputTokens,
     outputTokens: (currentConversation.outputTokens || 0) + turnUsage.outputTokens,
+    thinkingTokens: (currentConversation.thinkingTokens || 0) + turnUsage.thinkingTokens,
     cacheReadInputTokens: (currentConversation.cacheReadInputTokens || 0) + turnUsage.cacheReadInputTokens,
     cacheCreationInputTokens: (currentConversation.cacheCreationInputTokens || 0) + turnUsage.cacheCreationInputTokens,
     webSearchRequests: (currentConversation.webSearchRequests || 0) + turnUsage.webSearchRequests,
@@ -197,6 +202,7 @@ export function handleResultUsage(sessionId, event) {
     usage: updatedConversation ? {
       inputTokens: updatedConversation.inputTokens,
       outputTokens: updatedConversation.outputTokens,
+      thinkingTokens: updatedConversation.thinkingTokens,
       cacheReadInputTokens: updatedConversation.cacheReadInputTokens,
       cacheCreationInputTokens: updatedConversation.cacheCreationInputTokens,
       webSearchRequests: updatedConversation.webSearchRequests,

package/packages/server/src/services/summaryClaudeClient.js

@@ -49,11 +49,16 @@ function logResultUsage(callId, event) {
 /**
  * Build the query parameters for the Claude SDK call.
  * @param {string} prompt - The prompt to send
- * @param {{ systemPrompt?: string, jsonSchema?: Object }} options
+ * @param {{ systemPrompt?: string, jsonSchema?: Object, model?: string, env?: Object }} options
  * @returns {Object} queryParams ready for the SDK query function
  */
 function buildClaudeRequest(prompt, options) {
-  const { systemPrompt = null, jsonSchema = null } = options || {};
+  const {
+    systemPrompt = null,
+    jsonSchema = null,
+    model = 'claude-haiku-4-5-20251001',
+    env = null,
+  } = options || {};
   const schema = jsonSchema || SESSION_SUMMARY_SCHEMA;
 
   return {
@@ -62,7 +67,8 @@ function buildClaudeRequest(prompt, options) {
       cwd: process.cwd(),
       permissionMode: 'bypassPermissions',
       maxTurns: 1,
-      model: 'claude-haiku-4-5-20251001',
+      model,
+      ...(env && { env }),
       ...(systemPrompt && { systemPrompt }),
       outputFormat: {
         type: 'json_schema',
@@ -108,6 +114,21 @@ async function handleClaudeResponse(eventStream, callId) {
   return state.responseText;
 }
 
+function buildSummaryCallMetadata({ logMeta, model, providerId, selectionReason, promptLength }) {
+  return {
+    sessionId: logMeta.sessionId,
+    conversationId: logMeta.conversationId || null,
+    agentType: 'summary',
+    model,
+    callType: logMeta.callType,
+    promptLength,
+    metadata: {
+      ...(providerId ? { providerId } : {}),
+      ...(selectionReason ? { selectionReason } : {}),
+    },
+  };
+}
+
 export const SESSION_SUMMARY_SCHEMA = {
   type: 'object',
   properties: {
@@ -130,11 +151,16 @@ export const SESSION_SUMMARY_SCHEMA = {
  * @param {string} prompt - The prompt to send
  * @param {Array} recentMessages - Messages (for mock mode context)
  * @param {string} sessionStatus - Session status (for mock mode context)
- * @param {{ logMeta?: Object, systemPrompt?: string, jsonSchema?: Object }} options - Optional parameters
+ * @param {{ logMeta?: Object, systemPrompt?: string, jsonSchema?: Object, model?: string, env?: Object, providerId?: string|null, selectionReason?: string }} options - Optional parameters
  * @returns {Promise<string>} The text response (JSON string)
  */
 export async function callClaude(prompt, recentMessages, sessionStatus, options = {}) {
-  const { logMeta = null } = options || {};
+  const {
+    logMeta = null,
+    model = 'claude-haiku-4-5-20251001',
+    providerId = null,
+    selectionReason = null,
+  } = options || {};
   // Build stable key for VCR cassette (session prompts are hardcoded strings in E2E tests)
   let keyHint = null;
   if (process.env.VCR_MODE && logMeta?.sessionId) {
@@ -151,14 +177,13 @@ export async function callClaude(prompt, recentMessages, sessionStatus, options
   // Start logging if metadata provided
   let callId = null;
   if (logMeta) {
-    callId = agentCallLogger.startCall({
-      sessionId: logMeta.sessionId,
-      conversationId: logMeta.conversationId || null,
-      agentType: 'summary',
-      model: 'claude-haiku-4-5-20251001',
-      callType: logMeta.callType,
+    callId = agentCallLogger.startCall(buildSummaryCallMetadata({
+      logMeta,
+      model,
+      providerId,
+      selectionReason,
       promptLength: prompt.length,
-    });
+    }));
   }
 
   try {

package/packages/server/src/services/summaryModelClient.js

@@ -0,0 +1,154 @@
+import OpenAI from 'openai';
+import { callClaude, SESSION_SUMMARY_SCHEMA } from './summaryClaudeClient.js';
+import { agentCallLogger } from './agentCallLogger.js';
+import { buildProviderEnv } from './sessionProvider.js';
+import { resolveSummaryModel } from './summaryModelResolver.js';
+
+export { SESSION_SUMMARY_SCHEMA };
+
+export async function callSummaryModel(prompt, recentMessages, sessionStatus, options = {}) {
+  const resolution = options.resolvedModel || resolveSummaryModel(options.summarySettings || {});
+  if (resolution.kind === 'openai') {
+    return callOpenAISummaryModel(prompt, resolution, options);
+  }
+  return callAnthropicSummaryModel({ prompt, recentMessages, sessionStatus, resolution, options });
+}
+
+function callAnthropicSummaryModel({ prompt, recentMessages, sessionStatus, resolution, options }) {
+  const providerEnv = resolution.provider && !resolution.provider.isBuiltIn
+    ? { ...process.env, ...buildProviderEnv(resolution.provider) }
+    : null;
+
+  return callClaude(prompt, recentMessages, sessionStatus, {
+    ...options,
+    model: resolution.model,
+    providerId: resolution.providerId,
+    selectionReason: resolution.selectionReason,
+    ...(providerEnv ? { env: providerEnv } : {}),
+  });
+}
+
+async function callOpenAISummaryModel(prompt, resolution, options) {
+  const { logMeta = null, systemPrompt = null, jsonSchema = null } = options || {};
+  const schema = jsonSchema || SESSION_SUMMARY_SCHEMA;
+  const provider = resolution.provider;
+  const client = createOpenAIClient(provider);
+
+  const callId = startOpenAISummaryLog(logMeta, resolution, prompt.length);
+
+  try {
+    const response = await createOpenAIChatCompletion(client, {
+      model: resolution.model,
+      prompt,
+      systemPrompt,
+      schema,
+      structured: true,
+    }).catch(async (error) => {
+      if (!isStructuredOutputUnsupported(error)) throw error;
+      return createOpenAIChatCompletion(client, {
+        model: resolution.model,
+        prompt: withJsonOnlyInstruction(prompt, schema),
+        systemPrompt,
+        schema,
+        structured: false,
+      });
+    });
+
+    logOpenAIUsage(callId, response.usage);
+
+    if (callId) {
+      agentCallLogger.completeCall(callId, { success: true });
+    }
+    return extractOpenAIContent(response);
+  } catch (error) {
+    if (callId) {
+      agentCallLogger.completeCall(callId, { success: false, error });
+    }
+    throw error;
+  }
+}
+
+function startOpenAISummaryLog(logMeta, resolution, promptLength) {
+  if (!logMeta) return null;
+  return agentCallLogger.startCall({
+    sessionId: logMeta.sessionId,
+    conversationId: logMeta.conversationId || null,
+    agentType: 'summary',
+    model: resolution.model,
+    callType: logMeta.callType,
+    promptLength,
+    metadata: {
+      ...(resolution.providerId ? { providerId: resolution.providerId } : {}),
+      ...(resolution.selectionReason ? { selectionReason: resolution.selectionReason } : {}),
+    },
+  });
+}
+
+function logOpenAIUsage(callId, usage) {
+  if (!callId || !usage) return;
+  agentCallLogger.updateUsage(callId, {
+    inputTokens: usage.prompt_tokens || 0,
+    outputTokens: usage.completion_tokens || 0,
+    thinkingTokens: 0,
+    cacheReadInputTokens: 0,
+    cacheCreationInputTokens: 0,
+  });
+}
+
+function createOpenAIClient(provider) {
+  const options = {
+    apiKey: provider?.authToken || process.env.OPENAI_API_KEY || 'missing',
+  };
+  if (provider?.baseUrl) options.baseURL = provider.baseUrl;
+  if (provider?.apiTimeoutMs) options.timeout = provider.apiTimeoutMs;
+  return new OpenAI(options);
+}
+
+function createOpenAIChatCompletion(client, { model, prompt, systemPrompt, schema, structured }) {
+  const messages = [];
+  if (systemPrompt) messages.push({ role: 'system', content: systemPrompt });
+  messages.push({ role: 'user', content: prompt });
+
+  const request = {
+    model,
+    messages,
+    temperature: 0,
+  };
+
+  if (structured) {
+    request.response_format = {
+      type: 'json_schema',
+      json_schema: {
+        name: 'session_summary',
+        schema,
+        strict: false,
+      },
+    };
+  } else {
+    request.response_format = { type: 'json_object' };
+  }
+
+  return client.chat.completions.create(request);
+}
+
+function extractOpenAIContent(response) {
+  const content = response?.choices?.[0]?.message?.content;
+  if (Array.isArray(content)) {
+    return content
+      .map((part) => part?.text || part?.content || '')
+      .join('');
+  }
+  return content || '';
+}
+
+function isStructuredOutputUnsupported(error) {
+  const message = `${error?.message || ''} ${error?.code || ''} ${error?.type || ''}`.toLowerCase();
+  return [400, 404, 422].includes(error?.status)
+    || message.includes('response_format')
+    || message.includes('json_schema')
+    || message.includes('unsupported');
+}
+
+function withJsonOnlyInstruction(prompt, schema) {
+  return `${prompt}\n\nReturn only a valid JSON object matching this JSON Schema:\n${JSON.stringify(schema)}`;
+}

package/packages/server/src/services/summaryModelResolver.js

@@ -0,0 +1,148 @@
+import { modelProviders, sessions } from '../database.js';
+import { ACTIVITY_FIELDS_SQL } from '../db/session-helpers.js';
+
+export const DEFAULT_ANTHROPIC_SUMMARY_MODEL = 'claude-haiku-4-5-20251001';
+export const DEFAULT_OPENAI_SUMMARY_MODEL = 'gpt-5.4-mini';
+export const BUILT_IN_ANTHROPIC_PROVIDER_ID = 'anthropic-default';
+export const BUILT_IN_OPENAI_PROVIDER_ID = 'openai-default';
+
+export const CHEAPEST_SUMMARY_MODEL_BY_BUILT_IN_PROVIDER = Object.freeze({
+  [BUILT_IN_ANTHROPIC_PROVIDER_ID]: DEFAULT_ANTHROPIC_SUMMARY_MODEL,
+  [BUILT_IN_OPENAI_PROVIDER_ID]: DEFAULT_OPENAI_SUMMARY_MODEL,
+});
+
+const ANTHROPIC_TIER_NAMES = new Set(['sonnet', 'opus', 'haiku']);
+
+export function isKnownBuiltInAnthropicModel(modelId) {
+  if (!modelId || typeof modelId !== 'string') return false;
+  if (ANTHROPIC_TIER_NAMES.has(modelId.toLowerCase())) return true;
+  if (modelId === DEFAULT_ANTHROPIC_SUMMARY_MODEL) return true;
+
+  const anthropicProvider = modelProviders.getById(BUILT_IN_ANTHROPIC_PROVIDER_ID);
+  return Boolean(
+    anthropicProvider?.models?.some((model) => model.modelId === modelId)
+      || modelId.startsWith('claude-')
+  );
+}
+
+export function resolveSummaryModel(summarySettings = {}) {
+  const summaryModel = summarySettings?.summaryModel || '';
+  const summaryProviderId = summarySettings?.summaryProviderId || null;
+
+  if (summaryModel) {
+    return resolveExplicitSummaryModel(summaryModel, summaryProviderId);
+  }
+  if (summaryProviderId) {
+    throw new Error('summaryModel is required when summaryProviderId is set');
+  }
+
+  const recentFamily = findRecentBuiltInProviderFamily();
+  if (recentFamily === BUILT_IN_OPENAI_PROVIDER_ID) {
+    return {
+      model: DEFAULT_OPENAI_SUMMARY_MODEL,
+      provider: modelProviders.getById(BUILT_IN_OPENAI_PROVIDER_ID),
+      providerId: BUILT_IN_OPENAI_PROVIDER_ID,
+      kind: 'openai',
+      isDefault: true,
+      selectionReason: 'recent-built-in-provider',
+    };
+  }
+
+  if (recentFamily === BUILT_IN_ANTHROPIC_PROVIDER_ID) {
+    return defaultAnthropicResolution('recent-built-in-provider');
+  }
+
+  return defaultAnthropicResolution('fallback');
+}
+
+function resolveExplicitSummaryModel(summaryModel, summaryProviderId) {
+  if (!summaryProviderId) {
+    throw new Error('summaryProviderId is required when summaryModel is set');
+  }
+
+  const provider = modelProviders.getById(summaryProviderId);
+  if (!provider) {
+    throw new Error(`Summary provider not found: ${summaryProviderId}`);
+  }
+
+  const ownsModel = provider.models?.some((model) => model.modelId === summaryModel);
+  if (!ownsModel) {
+    throw new Error(`Summary provider ${summaryProviderId} does not own model ${summaryModel}`);
+  }
+  return providerResolution(summaryModel, provider, 'explicit');
+}
+
+function providerResolution(model, provider, selectionReason) {
+  const kind = provider.kind || 'anthropic';
+  return {
+    model,
+    provider,
+    providerId: provider.id,
+    kind,
+    isDefault: false,
+    selectionReason,
+  };
+}
+
+function defaultAnthropicResolution(selectionReason) {
+  return {
+    model: DEFAULT_ANTHROPIC_SUMMARY_MODEL,
+    provider: null,
+    providerId: null,
+    kind: 'anthropic',
+    isDefault: true,
+    selectionReason,
+  };
+}
+
+function findRecentBuiltInProviderFamily() {
+  for (const usage of getRecentSessionModelUsage()) {
+    const providerId = usage.providerId || null;
+    if (providerId) {
+      const provider = modelProviders.getById(providerId);
+      const family = builtInFamilyForProvider(provider);
+      if (family) return family;
+      continue;
+    }
+
+    const model = usage.model || null;
+    if (!model) continue;
+
+    const provider = modelProviders.getProviderByModelId(model);
+    const family = builtInFamilyForProvider(provider);
+    if (family) return family;
+
+    if (!provider && isKnownBuiltInAnthropicModel(model)) {
+      return BUILT_IN_ANTHROPIC_PROVIDER_ID;
+    }
+  }
+  return null;
+}
+
+function builtInFamilyForProvider(provider) {
+  if (!provider?.isBuiltIn) return null;
+  if (provider.id === BUILT_IN_OPENAI_PROVIDER_ID || provider.kind === 'openai') return BUILT_IN_OPENAI_PROVIDER_ID;
+  if (provider.id === BUILT_IN_ANTHROPIC_PROVIDER_ID || (provider.kind || 'anthropic') === 'anthropic') {
+    return BUILT_IN_ANTHROPIC_PROVIDER_ID;
+  }
+  return null;
+}
+
+export function getRecentSessionModelUsage(limit = 50) {
+  const rows = sessions.db
+    .prepare(
+      `SELECT s.model, s.provider_id, ${ACTIVITY_FIELDS_SQL}
+       FROM sessions s
+       ORDER BY COALESCE(last_activity_at, s.updated_at, s.created_at) DESC,
+                s.updated_at DESC,
+                s.created_at DESC,
+                s.rowid DESC
+       LIMIT ?`
+    )
+    .all(limit);
+
+  return rows.map((row) => ({
+    model: row.model || null,
+    providerId: row.provider_id || null,
+  }));
+}

package/packages/server/src/services/summaryService.js

@@ -13,7 +13,7 @@
 
 import { sessions, messages, sessionSummaries, projects, settings } from '../database.js';
 import { createConcurrencyGuard } from './withConcurrencyGuard.js';
-import { callClaude } from './summaryClaudeClient.js';
+import { callSummaryModel } from './summaryModelClient.js';
 import {
   MAX_MESSAGES,
   MIN_MESSAGES_FOR_SUMMARY,
@@ -299,10 +299,11 @@ async function _doGenerateSummary(sessionId, retryCount = 0, force = false, user
     // Build conversation context and prompt
     const { prompt } = fetchConversationContext(sessionId, { existingSummary, recentMessages, session, globalSettings });
 
-    // Call Claude via SDK
-    const responseText = await callClaude(prompt, recentMessages, session.status, {
+    // Call the configured summary model.
+    const responseText = await callSummaryModel(prompt, recentMessages, session.status, {
       logMeta: { sessionId, callType: 'generateSessionSummary' },
       systemPrompt: SUMMARY_SYSTEM_PROMPT,
+      summarySettings: globalSettings,
     });
 
     // Parse response and retry if needed
@@ -536,7 +537,8 @@ export {
   SUMMARY_SYSTEM_PROMPT, formatMessages, buildIncrementalPrompt, parseSummaryResponse,
   stripMarkdownCodeBlock as _stripMarkdownCodeBlock, trackMessageMetadata as _trackMessageMetadata,
 };
-export { callClaude };
+export { callSummaryModel };
+export { callClaude } from './summaryClaudeClient.js';
 export { parsePrUrl, validatePrUrl, extractPrUrlIfNeeded, enrichPrData as _enrichPrData };
 export { getChildSessions, buildChildSessionContext, aggregateFilesModified };