circuschief 0.5.0 → 0.7.0

package/packages/server/src/db/migrations/sessionsMigrations.js

@@ -32,6 +32,7 @@ const SESSIONS_BASE_COLUMNS = `
     parent_session_id TEXT REFERENCES sessions(id) ON DELETE SET NULL,
     input_tokens INTEGER DEFAULT 0,
     output_tokens INTEGER DEFAULT 0,
+    thinking_tokens INTEGER DEFAULT 0,
     cache_read_input_tokens INTEGER DEFAULT 0,
     cache_creation_input_tokens INTEGER DEFAULT 0,
     web_search_requests INTEGER DEFAULT 0,
@@ -59,7 +60,7 @@ const SESSIONS_ALL_COLUMNS = [
   'id', 'project_id', 'name', 'status', 'mode', 'thinking_enabled',
   'git_branch', 'git_worktree', 'pr_url', 'error', 'effort_level',
   'cost_usd', 'claude_session_id', 'model', 'next_template_id',
-  'parent_session_id', 'input_tokens', 'output_tokens',
+  'parent_session_id', 'input_tokens', 'output_tokens', 'thinking_tokens',
   'cache_read_input_tokens', 'cache_creation_input_tokens',
   'web_search_requests', 'context_window', 'archived', 'starred',
   'manually_named', 'scheduled_at', 'reschedule_delay_minutes',
@@ -211,6 +212,10 @@ export const sessionsMigrations = [
     name: 'sessions-add-output_tokens',
     up(db) { addColumnIfMissing(db, TABLE_SESSIONS, 'output_tokens', COL_INTEGER_DEFAULT_0); },
   },
+  {
+    name: 'sessions-add-thinking_tokens',
+    up(db) { addColumnIfMissing(db, TABLE_SESSIONS, 'thinking_tokens', COL_INTEGER_DEFAULT_0); },
+  },
   {
     name: 'sessions-add-cache_read_input_tokens',
     up(db) { addColumnIfMissing(db, TABLE_SESSIONS, 'cache_read_input_tokens', COL_INTEGER_DEFAULT_0); },

package/packages/server/src/db/session-helpers.js

@@ -24,6 +24,7 @@ export function mapTokenUsage(row) {
   return {
     inputTokens: row.input_tokens || 0,
     outputTokens: row.output_tokens || 0,
+    thinkingTokens: row.thinking_tokens || 0,
     cacheReadInputTokens: row.cache_read_input_tokens || 0,
     cacheCreationInputTokens: row.cache_creation_input_tokens || 0,
     webSearchRequests: row.web_search_requests || 0,
@@ -58,7 +59,12 @@ const CONFIG_DEFAULTS = {
   parentSessionId: null,
   status: 'starting',
   model: null,
+  providerId: null,
   effortLevel: null,
+  // Agent runtime for the session: 'claude-code' (default) or 'codex'.
+  // Defaults to null so SessionRepository.create() can resolve it from the model.
+  // Explicit values from callers are preserved as-is.
+  agentType: null,
 };
 
 function buildConfig(src) {
@@ -96,6 +102,7 @@ export const DIRECT_FIELD_MAP = {
   costUsd: 'cost_usd',
   claudeSessionId: 'claude_session_id',
   model: 'model',
+  providerId: 'provider_id',
   nextTemplateId: 'next_template_id',
   parentSessionId: 'parent_session_id',
   scheduledAt: 'scheduled_at',
@@ -109,6 +116,7 @@ export const DIRECT_FIELD_MAP = {
   effortLevel: 'effort_level',
   targetLaneId: 'target_lane_id',
   laneTriggerDepth: 'lane_trigger_depth',
+  agentType: 'agent_type',
 };
 
 /** camelCase -> snake_case column mapping for boolean fields (converted to 1/0) */

package/packages/server/src/schema.sql

@@ -48,6 +48,13 @@ CREATE TABLE IF NOT EXISTS sessions (
   claude_session_id TEXT,
   next_template_id TEXT REFERENCES session_templates(id) ON DELETE SET NULL,
   parent_session_id TEXT REFERENCES sessions(id) ON DELETE SET NULL,
+  input_tokens INTEGER DEFAULT 0,
+  output_tokens INTEGER DEFAULT 0,
+  thinking_tokens INTEGER DEFAULT 0,
+  cache_read_input_tokens INTEGER DEFAULT 0,
+  cache_creation_input_tokens INTEGER DEFAULT 0,
+  web_search_requests INTEGER DEFAULT 0,
+  context_window INTEGER DEFAULT 200000,
   created_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
   updated_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
 );
@@ -64,6 +71,7 @@ CREATE TABLE IF NOT EXISTS conversations (
   -- Token usage fields (per-conversation tracking)
   input_tokens INTEGER DEFAULT 0,
   output_tokens INTEGER DEFAULT 0,
+  thinking_tokens INTEGER DEFAULT 0,
   cache_read_input_tokens INTEGER DEFAULT 0,
   cache_creation_input_tokens INTEGER DEFAULT 0,
   web_search_requests INTEGER DEFAULT 0,
@@ -233,6 +241,7 @@ CREATE TABLE IF NOT EXISTS providers (
   api_timeout_ms INTEGER,
   additional_env_vars TEXT,
   is_built_in INTEGER NOT NULL DEFAULT 0,
+  kind TEXT NOT NULL DEFAULT 'anthropic' CHECK(kind IN ('anthropic','openai')),
   created_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
   updated_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
 );

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

@@ -20,7 +20,7 @@ export class AgentCallLogger {
     const callId = nanoid();
 
     // Build metadata object - only include keys with defined values
-    const metadata = {};
+    const metadata = { ...(meta.metadata || {}) };
     if (meta.effortLevel !== undefined && meta.effortLevel !== null) {
       metadata.effortLevel = meta.effortLevel;
     }

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

@@ -0,0 +1,37 @@
+import { spawn } from 'child_process';
+import { createRobustEnv } from './nodeSpawnHelper.js';
+
+/**
+ * Create a custom spawn function for the Codex CLI.
+ *
+ * Mirrors {@link createClaudeCodeSpawner} but keeps stderr piped (the Codex
+ * adapter surfaces stderr bytes as error events rather than silently ignoring
+ * them).
+ *
+ * As with the Claude helper:
+ *   - The command 'node' is replaced with {@link process.execPath} so child
+ *     processes use the same Node binary that's running the app (important
+ *     for nvm/fnm/volta users).
+ *   - `createRobustEnv` guarantees the Node bin directory is on PATH.
+ *
+ * @returns {Function} Spawn function of shape (options) => childProcess
+ */
+export function createCodexSpawner() {
+  return (options) => {
+    const { command, args, cwd, env, signal } = options;
+
+    // Replace 'node' with the absolute path to the current Node executable
+    const actualCommand = command === 'node' ? process.execPath : command;
+
+    // Ensure PATH includes the directory containing Node
+    const robustEnv = createRobustEnv(env);
+
+    return spawn(actualCommand, args, {
+      cwd,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      signal,
+      env: robustEnv,
+      windowsHide: true,
+    });
+  };
+}

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

@@ -0,0 +1,48 @@
+import { commandButtons } from '../database.js';
+
+/**
+ * Build Command Button API instructions for system prompt if the project has command buttons.
+ * @param {string} apiUrl - Base API URL
+ * @param {string} sessionId - Current session ID
+ * @param {string} projectId - Current project ID
+ * @returns {string} Command button instructions or empty string if no buttons configured
+ */
+export function buildCommandButtonApiInstructions(apiUrl, sessionId, projectId) {
+  const buttons = commandButtons.getByProjectId(projectId);
+  if (!buttons || buttons.length === 0) {
+    return '';
+  }
+
+  return `## Command Buttons API
+
+This project has command buttons configured - reusable shell commands you can execute. Use the Bash tool to run these curl commands.
+
+### List Available Buttons
+\`\`\`bash
+curl ${apiUrl}/api/projects/${projectId}/command-buttons
+\`\`\`
+
+### Run a Button
+\`\`\`bash
+curl -X POST ${apiUrl}/api/sessions/${sessionId}/command-buttons/<button_id>/run
+\`\`\`
+
+Response: { runId, buttonId, status: "running", output: "" }
+
+### Check Run Status & Output
+\`\`\`bash
+curl ${apiUrl}/api/sessions/${sessionId}/command-buttons/runs/<run_id>
+\`\`\`
+
+Response: { runId, buttonId, status, exitCode, output, startedAt, completedAt }
+
+### List All Runs for This Session
+\`\`\`bash
+curl ${apiUrl}/api/sessions/${sessionId}/command-buttons/runs
+\`\`\`
+
+### Kill a Running Command
+\`\`\`bash
+curl -X POST ${apiUrl}/api/sessions/${sessionId}/command-buttons/runs/<run_id>/kill
+\`\`\``;
+}

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

@@ -70,3 +70,30 @@ ${transcript}
 
 `;
 }
+
+/**
+ * Build context for a continuation where the adapter cannot resume.
+ * This is the generic case for any non-resumable adapter (Codex, future adapters).
+ * @param {string} conversationId
+ * @returns {string}
+ */
+export function buildConversationContextForContinuation(conversationId) {
+  const conversationMessages = messages.getByConversationId(conversationId);
+
+  // Don't include the last user message (that's the current prompt)
+  const previousMessages = conversationMessages.slice(0, -1);
+
+  if (previousMessages.length === 0) {
+    return '';
+  }
+
+  const transcript = formatConversationHistory(previousMessages);
+
+  return `<conversation_history>
+The following is the conversation history from this session so far. Continue naturally from where the conversation left off.
+
+${transcript}
+</conversation_history>
+
+`;
+}

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

@@ -2,6 +2,7 @@ import { sessions, messages, projects, conversations, attachments } from '../dat
 import { broadcastToSession, broadcastToProject } from '../websocket.js';
 import { WS_MESSAGE_TYPES } from '../../../shared/src/index.js';
 import * as slashCommandService from './slashCommandService.js';
+import { resolveAgentTypeFromModel } from './sessionProvider.js';
 
 /**
  * Validates that a session is a draft (waiting status with no assistant messages).
@@ -111,6 +112,7 @@ function getOrCreateInitialMessage(session, options) {
  * @param {object} options
  * @param {string} [options.prompt] - Optional new prompt to use/override
  * @param {string} [options.model] - Optional model override
+ * @param {string|null} [options.providerId] - Optional provider override
  * @returns {Promise<object>} The updated session
  */
 export async function startDraft(session, options = {}) {
@@ -125,6 +127,11 @@ export async function startDraft(session, options = {}) {
   // Model to use for this session (optional - SDK will use default if not provided)
   const model = options.model || session.pendingModel || session.model || null;
 
+  // Resolve the agent type from the selected model before launching.
+  // Draft sessions have no assistant messages yet, so the session is still
+  // choosing its initial runtime – the selected model determines agentType.
+  const agentType = model ? resolveAgentTypeFromModel(model) : session.agentType;
+
   // Get or create the initial user message
   const initialMessage = getOrCreateInitialMessage(session, options);
   const finalPrompt = initialMessage.content;
@@ -132,8 +139,14 @@ export async function startDraft(session, options = {}) {
   // Get session attachments for context
   const sessionAttachments = attachments.getBySessionId(session.id);
 
-  // Update session status to starting and clear pendingModel (mirrors pendingPrompt cleanup above)
-  sessions.update(session.id, { status: 'starting', pendingModel: null });
+  // Update session status to starting, clear pendingModel, and persist the
+  // resolved model + agentType BEFORE runSession() reads them from storage.
+  sessions.update(session.id, {
+    status: 'starting',
+    pendingModel: null,
+    ...(model ? { model, agentType } : {}),
+    ...(options.providerId !== undefined ? { providerId: options.providerId } : {}),
+  });
 
   // Resolve skill/command invocations so skill body goes into system prompt
   const resolved = await slashCommandService.resolvePromptSkillOrCommand(

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

@@ -9,6 +9,7 @@ import { WS_MESSAGE_TYPES } from '../../../shared/src/index.js';
 import { renderTemplatePrompt, getRootSession } from './templateTriggerService.js';
 import { setupGitForSession } from './gitSessionSetup.js';
 import { runSession } from './sessionManager.js';
+import { resolveAgentTypeFromModel } from './sessionProvider.js';
 
 // Maximum depth for recursive lane-entry template triggers
 export const MAX_LANE_TRIGGER_DEPTH = 5;
@@ -147,6 +148,7 @@ async function buildChildSessionFromTemplate(template, session, lane, depth) {
     gitBranch: settings.gitBranch,
     status: 'starting',
     model: settings.model,
+    agentType: resolveAgentTypeFromModel(settings.model),
   });
 
   // Configure session
@@ -240,6 +242,7 @@ async function buildChildSessionFromPrompt(lane, session, depth) {
   const newSession = sessions.create(session.projectId, `Lane prompt (lane: ${lane.name})`, renderedPrompt, {
     ...settings,
     status: 'starting',
+    agentType: resolveAgentTypeFromModel(settings.model),
   });
 
   // Configure session

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

@@ -1,35 +1,53 @@
 import Anthropic from '@anthropic-ai/sdk';
+import OpenAI from 'openai';
 
 /**
- * Test a provider configuration by making a minimal API call
- * @param {Object} config - Provider configuration to test
+ * Test a provider configuration by making a minimal API call.
+ * Branches on `kind`:
+ *   - 'anthropic' → send a tiny `messages.create` via `@anthropic-ai/sdk`.
+ *   - 'openai'    → prefer `models.list()` via `openai`; fall back to a
+ *                   `chat.completions.create({ max_tokens: 1 })` if
+ *                   `models.list` is not supported (chat-only endpoints).
+ *
+ * Both branches return the same response shape:
+ *   - Success: { success: true, message, details: { model, usage? } }
+ *   - Failure: { success: false, message, details: { code, type } }
+ * This function never throws. Errors are mapped to the failure shape above.
+ *
+ * @param {Object} config
+ * @param {'anthropic'|'openai'} [config.kind='anthropic'] - Provider kind
  * @param {string} [config.baseUrl] - Base URL for the provider
  * @param {string} [config.authToken] - Auth token for the provider
- * @param {string} [config.defaultSonnetModel] - Default Sonnet model ID
+ * @param {string} [config.defaultSonnetModel] - For anthropic: model to test against
  * @param {number} [config.apiTimeoutMs] - API timeout in milliseconds
  * @returns {Promise<{success: boolean, message: string, details?: Object}>}
  */
 export async function testProviderConnection(config) {
+  const { kind = 'anthropic' } = config || {};
+  if (kind === 'openai') {
+    return testOpenAIConnection(config);
+  }
+  return testAnthropicConnection(config);
+}
+
+/**
+ * Anthropic-kind connection test (unchanged from pre-kind behavior).
+ * @private
+ */
+async function testAnthropicConnection(config) {
   const { baseUrl, authToken, defaultSonnetModel, apiTimeoutMs } = config;
 
   try {
-    // Build client options
     const clientOptions = {};
 
-    if (baseUrl) {
-      clientOptions.baseURL = baseUrl;
-    }
-    if (authToken) {
-      clientOptions.apiKey = authToken;
-    }
-    if (apiTimeoutMs) {
-      clientOptions.timeout = apiTimeoutMs;
-    }
+    if (baseUrl) clientOptions.baseURL = baseUrl;
+    if (authToken) clientOptions.apiKey = authToken;
+    if (apiTimeoutMs) clientOptions.timeout = apiTimeoutMs;
 
     const client = new Anthropic(clientOptions);
 
-    // Use a minimal message to test connectivity
-    // This verifies: network, auth, and model availability
+    // Use a minimal message to test connectivity.
+    // This verifies: network, auth, and model availability.
     const testModel = defaultSonnetModel || 'claude-sonnet-4-20250514';
 
     const response = await client.messages.create({
@@ -58,6 +76,88 @@ export async function testProviderConnection(config) {
   }
 }
 
+/**
+ * OpenAI-kind connection test. Tries `models.list()` first; if the endpoint
+ * does not implement that (common for chat-only proxies like LM Studio), falls
+ * back to a minimal `chat.completions.create({ max_tokens: 1 })`.
+ * @private
+ */
+async function testOpenAIConnection(config) {
+  try {
+    const client = createOpenAIClient(config);
+    return await testOpenAIClient(client, config);
+  } catch (error) {
+    return failureResponse(error);
+  }
+}
+
+function createOpenAIClient(config) {
+  const { baseUrl, authToken, apiTimeoutMs } = config;
+  const clientOptions = { apiKey: authToken || 'missing' };
+  if (baseUrl) clientOptions.baseURL = baseUrl;
+  if (apiTimeoutMs) clientOptions.timeout = apiTimeoutMs;
+  return new OpenAI(clientOptions);
+}
+
+async function testOpenAIClient(client, config) {
+  try {
+    return await testOpenAIModelsEndpoint(client, config);
+  } catch (error) {
+    if (error?.status !== 404) throw error;
+    return testOpenAIChatEndpoint(client, config);
+  }
+}
+
+async function testOpenAIModelsEndpoint(client, config) {
+  const listResult = await client.models.list();
+  const first = pickFirstModel(listResult) || config.defaultSonnetModel || null;
+  return connectionSuccess(first ? { model: first } : {});
+}
+
+async function testOpenAIChatEndpoint(client, config) {
+  const testModel = config.defaultSonnetModel || 'gpt-4o-mini';
+  const response = await client.chat.completions.create({
+    model: testModel,
+    max_tokens: 1,
+    messages: [{ role: 'user', content: 'Hi' }],
+  });
+  return connectionSuccess({
+    model: response?.model || testModel,
+    ...(response?.usage ? { usage: response.usage } : {}),
+  });
+}
+
+function connectionSuccess(details) {
+  return {
+    success: true,
+    message: 'Connection successful',
+    details,
+  };
+}
+
+function failureResponse(error) {
+  return {
+    success: false,
+    message: getErrorMessage(error),
+    details: { code: error.status || error.code, type: error.type || error.name },
+  };
+}
+
+/**
+ * Extract a representative model ID from whatever shape `models.list()` returns.
+ * @private
+ */
+function pickFirstModel(listResult) {
+  if (!listResult) return null;
+  // Newer SDKs expose .data; older ones are plain arrays / async iterables.
+  const data = Array.isArray(listResult) ? listResult : listResult.data;
+  if (Array.isArray(data) && data.length > 0) {
+    const entry = data[0];
+    return entry?.id || entry?.model || null;
+  }
+  return null;
+}
+
 /**
  * Get a human-readable error message from an error object
  * @param {Error} error - The error object

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

@@ -0,0 +1,38 @@
+import { resolveAgentTypeFromModel } from './sessionProvider.js';
+
+// Human-readable labels used in the cross-kind switch error message.
+export const AGENT_TYPE_LABELS = Object.freeze({
+  'claude-code': 'Claude Code',
+  codex: 'Codex',
+});
+
+/**
+ * @param {string} agentType
+ * @returns {string}
+ */
+export function agentLabel(agentType) {
+  return AGENT_TYPE_LABELS[agentType] || agentType || 'unknown';
+}
+
+/**
+ * Cross-kind model switch guard. A session is bound to one agent type for its
+ * lifetime. If the caller selected a model that resolves to a different agent
+ * than the session's existing agentType, reject BEFORE dispatching
+ * continueSession or updating session.model — mixing Claude and Codex
+ * mid-conversation would produce a broken resume/context state. Same-kind
+ * model changes (sonnet↔opus, gpt-4o↔o1-mini) pass through.
+ *
+ * @param {Object} session - The session row (must include agentType + model).
+ * @param {string|null} requestedModel - Model ID from req.body.model, or null.
+ * @returns {{ error: string, message: string }|null} 400-body on block, or null to allow.
+ */
+export function checkCrossKindSwitch(session, requestedModel) {
+  const sessionAgentType = session.agentType || 'claude-code';
+  const effectiveModel = requestedModel || session.model;
+  const requestedAgentType = resolveAgentTypeFromModel(effectiveModel);
+  if (requestedAgentType === sessionAgentType) return null;
+  return {
+    error: 'CROSS_KIND_MODEL_SWITCH',
+    message: `Cannot switch agent kind mid-session (${agentLabel(sessionAgentType)} → ${agentLabel(requestedAgentType)})`,
+  };
+}