circuschief 0.5.0 → 0.7.0

package/packages/server/src/agents/adapters/codexEventMapper.js

@@ -0,0 +1,235 @@
+/**
+ * Codex event mapper.
+ *
+ * Translates the real Codex CLI JSON-line event schema (as emitted by
+ * `codex exec --json`) into the normalized SDK-shaped events that Circus
+ * Chief's stream event handler already understands for Claude Code:
+ *
+ *   - {@code system(init)}
+ *   - {@code stream_event(content_block_delta)}
+ *   - {@code assistant}
+ *   - {@code result(success, usage)}
+ *
+ * Real Codex event types (v0.124.0, confirmed via
+ * `codex app-server generate-json-schema`):
+ *
+ *   - {@code thread.started}   — { thread_id }
+ *   - {@code turn.started}     — no payload
+ *   - {@code item.started}     — { item: ThreadItem }
+ *   - {@code item.completed}   — { item: ThreadItem }
+ *   - {@code turn.completed}   — { usage: { input_tokens, cached_input_tokens, output_tokens } }
+ *   - {@code turn.failed}      — { error: { message } }
+ *   - {@code error}            — { message } (transient, treated as fatal)
+ *
+ * ThreadItem.type variants handled in v1:
+ *   - {@code agent_message} — { id, text, ... }  → emitted as text_delta + assistant
+ *   - {@code command_execution} — { id, command, aggregated_output, exit_code, status } → tool_result
+ *   - {@code file_change} — { id, changes: [{path, kind}] } → tool_result
+ *   - {@code reasoning} — { id, text } or legacy { content: [{type, text}] } → tool_result
+ *
+ * All other variants (mcp_tool_call,
+ * dynamic_tool_call, collab_agent_tool_call, web_search, image_view, image_generation,
+ * plan, context_compaction, hook_prompt, entered_review_mode, exited_review_mode,
+ * user_message) are currently ignored.
+ *
+ * The mapper is stateful across calls so it can accumulate agent message
+ * text across multiple `item.completed` events within a turn and stash
+ * usage counters until the terminal `turn.completed`.
+ *
+ * Pure in-process — no I/O, no timers, no child processes.
+ *
+ * @param {Object} [options]
+ * @param {string} [options.model] - Optional model name to surface in the
+ *   {@code system(init)} event. Codex's {@code thread.started} event does
+ *   not carry the model, so the adapter must pass it in.
+ * @returns {{
+ *   map: (codexEvent: Object) => Array<Object>,
+ *   reset: () => void,
+ *   finalize: () => Array<Object>
+ * }}
+ */
+export function createCodexEventMapper({ model } = {}) {
+  const mapperState = new MapperState();
+  const warnedUnknownItemTypes = new Set();
+
+  const handlers = {
+    'thread.started': (evt) => handleThreadStarted(evt, model),
+    'turn.started': () => [],
+    'item.started': () => [],
+    'item.completed': (evt) => handleItemCompleted(evt, mapperState, warnedUnknownItemTypes),
+    'turn.completed': (evt) => mapperState.onTurnCompleted(evt),
+    'turn.failed': (evt) => handleTurnFailed(evt),
+    'error': (evt) => handleError(evt),
+  };
+
+  function map(codexEvent) {
+    if (!codexEvent || typeof codexEvent !== 'object') return [];
+    const handler = handlers[codexEvent.type];
+    if (!handler) {
+      console.warn(`[codexEventMapper] Unknown Codex event type: "${codexEvent.type}"`);
+      return [];
+    }
+    return handler(codexEvent);
+  }
+
+  return {
+    map,
+    reset: () => mapperState.reset(),
+    finalize: () => mapperState.finalize(),
+  };
+}
+
+// --- Mapper state class ----------------------------------------------------
+
+class MapperState {
+  constructor() {
+    this.reset();
+  }
+
+  reset() {
+    this.lastUsage = null;
+    this.terminated = false;
+  }
+
+  /**
+   * Called by the adapter when the underlying stream ends without an explicit
+   * {@code turn.completed}. Returns a terminal result event if one hasn't been
+   * emitted yet; otherwise an empty array.
+   */
+  finalize() {
+    if (this.terminated) return [];
+    this.terminated = true;
+    return [this.buildResultEvent()];
+  }
+
+  onTurnCompleted(evt) {
+    if (evt && evt.usage) {
+      this.lastUsage = {
+        input_tokens: evt.usage.input_tokens,
+        output_tokens: evt.usage.output_tokens,
+      };
+    }
+    this.terminated = true;
+    return [this.buildResultEvent()];
+  }
+
+  buildResultEvent() {
+    const usage = this.lastUsage || { input_tokens: 0, output_tokens: 0 };
+    return {
+      type: 'result',
+      subtype: 'success',
+      usage: {
+        input_tokens: usage.input_tokens || 0,
+        output_tokens: usage.output_tokens || 0,
+      },
+    };
+  }
+}
+
+// --- Pure event handlers ---------------------------------------------------
+
+function handleThreadStarted(evt, model) {
+  const init = {
+    type: 'system',
+    subtype: 'init',
+    session_id: evt.thread_id,
+  };
+  if (model) init.model = model;
+  return [init];
+}
+
+function handleItemCompleted(evt, _state, warnedTypes) {
+  const item = evt.item;
+  if (!item || typeof item !== 'object') return [];
+
+  if (isAgentMessageItem(item)) {
+    const text = typeof item.text === 'string' ? item.text : '';
+    return [
+      {
+        type: 'stream_event',
+        event: {
+          type: 'content_block_delta',
+          delta: { type: 'text_delta', text },
+        },
+      },
+      {
+        type: 'assistant',
+        message: { content: [{ type: 'text', text }] },
+      },
+    ];
+  }
+
+  if (item.type === 'command_execution') {
+    return [mapCommandExecution(item)];
+  }
+
+  if (item.type === 'file_change') {
+    return [mapFileChange(item)];
+  }
+
+  if (item.type === 'reasoning') {
+    return [mapReasoning(item)];
+  }
+
+  // Unknown types — warn once per type
+  if (item.type && !warnedTypes.has(item.type)) {
+    warnedTypes.add(item.type);
+    console.warn(`[codexEventMapper] Ignoring unsupported item.type "${item.type}"`);
+  }
+  return [];
+}
+
+function isAgentMessageItem(item) {
+  return item.type === 'agent_message' || item.type === 'agentMessage';
+}
+
+function handleTurnFailed(evt) {
+  const message = evt?.error?.message || 'Codex turn failed';
+  throw new Error(message);
+}
+
+function handleError(evt) {
+  const message = evt?.message || 'Codex error';
+  throw new Error(message);
+}
+
+// --- Tool-use mapping helpers -----------------------------------------------
+
+function mapCommandExecution(item) {
+  const cmd = item.command || '';
+  const parts = [`$ ${cmd}`];
+  if (item.exit_code !== undefined && item.exit_code !== 0) {
+    parts.push(`exit code: ${item.exit_code}`);
+  }
+  if (item.aggregated_output) parts.push(item.aggregated_output);
+  return {
+    type: 'tool_result',
+    tool_name: 'command_execution',
+    content: parts.join('\n'),
+  };
+}
+
+function mapFileChange(item) {
+  const changes = Array.isArray(item.changes)
+    ? item.changes.map((c) => `${c.kind || 'change'}: ${c.path || 'unknown'}`).join('\n')
+    : 'unknown file change';
+  return {
+    type: 'tool_result',
+    tool_name: 'file_change',
+    content: changes,
+  };
+}
+
+function mapReasoning(item) {
+  // v0.124.0 shape: plain `text` string (e.g. gpt-5.2)
+  // Legacy shape: `content` array of {type, text} objects
+  const text = item.text
+    || (Array.isArray(item.content)
+      ? item.content.map((c) => c.text || '').join('\n')
+      : '');
+  return {
+    type: 'tool_result',
+    tool_name: 'reasoning',
+    content: text,
+  };
+}

package/packages/server/src/agents/types.js

@@ -24,6 +24,7 @@
  * @property {Object} env - Environment variables
  * @property {Function} spawnClaudeCodeProcess - Process spawner function
  * @property {string} [model] - Model to use
+ * @property {string|null} [effortLevel] - Reasoning effort override, or null/auto for provider default
  * @property {string} systemPrompt - System prompt string
  */
 

package/packages/server/src/agents/vcr/VCRAgentAdapter.js

@@ -116,6 +116,14 @@ export class VCRAgentAdapter {
     return this.innerAgent.supportsResume?.() ?? false;
   }
 
+  /**
+   * Proxy conversation context need to inner agent
+   * @returns {boolean}
+   */
+  needsConversationContext() {
+    return this.innerAgent.needsConversationContext?.() ?? true;
+  }
+
   /**
    * Proxy capabilities to inner agent
    * @returns {object}

package/packages/server/src/api/agents.js

@@ -0,0 +1,27 @@
+import { Router } from 'express';
+import { agentGateway } from '../agents/AgentGateway.js';
+
+const router = Router();
+
+/**
+ * GET /api/agents
+ *
+ * Returns the capabilities of every registered agent adapter, sourced from the
+ * adapter's static `capabilities` field (no adapter instantiation).
+ *
+ * Response shape:
+ *   [
+ *     { agentType: 'claude-code', capabilities: { streaming, thinking, reasoningEffort, toolUse, resume } },
+ *     { agentType: 'codex',       capabilities: { streaming, thinking, reasoningEffort, toolUse, resume } },
+ *   ]
+ */
+router.get('/', (_req, res) => {
+  try {
+    const agents = agentGateway.getAllAgentCapabilities();
+    res.json(agents);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+export default router;

package/packages/server/src/api/canvas.js

@@ -279,6 +279,26 @@ router.get('/:id/canvas/file/:filename/content', (req, res) => {
   });
 });
 
+// GET /api/sessions/:id/canvas/:itemId/content - Get one canvas item content inline
+router.get('/:id/canvas/:itemId/content', (req, res) => {
+  const session = sessions.getById(req.params.id);
+  if (!session) return res.status(404).json({ error: ERR_SESSION_NOT_FOUND });
+
+  const item = canvasItems.getById(req.params.itemId);
+  if (!item) return res.status(404).json({ error: 'Canvas item not found' });
+  if (item.sessionId !== req.params.id) {
+    return res.status(400).json({ error: 'Canvas item does not belong to this session' });
+  }
+
+  res.json({
+    content: item.content ?? null,
+    data: item.data ?? null,
+    type: item.type,
+    mimeType: item.mimeType,
+    filename: item.filename,
+  });
+});
+
 // GET /api/sessions/:id/canvas/file/:filename - Get canvas file by filename
 // Writes the file to /tmp and returns the file path for Claude's Read tool
 // Always returns the latest version

package/packages/server/src/api/index.js

@@ -11,6 +11,7 @@ import providersRouter from './providers.js';
 import commandsRouter from './commands.js';
 import metricsRouter from './metrics.js';
 import kanbanRouter from './kanban.js';
+import agentsRouter from './agents.js';
 import { getDbPath } from '../database.js';
 import { schedulerService } from '../services/schedulerService.js';
 
@@ -38,6 +39,7 @@ router.use('/git', gitRouter);
 router.use('/filesystem', filesystemRouter);
 router.use('/settings', settingsRouter);
 router.use('/providers', providersRouter);
+router.use('/agents', agentsRouter);
 router.use('/commands', commandsRouter)
 
 // Canvas routes are nested under sessions

package/packages/server/src/api/projects-session-helpers.js

@@ -44,6 +44,26 @@ export function resolveDefault(explicit, projectDefault, systemDefault) {
   return systemDefault;
 }
 
+/**
+ * Normalize provider IDs from JSON or multipart request fields.
+ * @param {*} value - Raw providerId value
+ * @returns {string|null|undefined}
+ */
+export function normalizeProviderId(value) {
+  if (value === undefined) return undefined;
+  if (value === null || value === '') return null;
+  if (typeof value !== 'string') {
+    throw new TypeError('providerId must be a string or null');
+  }
+  return value;
+}
+
+function resolveProviderDefault(explicit, projectDefault, systemDefault) {
+  if (explicit !== undefined) return explicit;
+  if (projectDefault !== undefined && projectDefault !== null) return projectDefault;
+  return systemDefault ?? null;
+}
+
 /**
  * Resolve thinkingEnabled with special boolean handling.
  * @param {object} body - Request body
@@ -114,11 +134,16 @@ export function prepareSessionConfig(body, projectDefs, systemDefaults) {
     effortLevel = null;
   }
 
+  const explicitProviderId = normalizeProviderId(body.providerId);
+  const projectProviderId = normalizeProviderId(projectDefs?.providerId);
+  const systemProviderId = normalizeProviderId(systemDefaults.providerId);
+
   return {
     prompt: body.prompt,
     name: body.name,
     mode: resolveDefault(body.mode, projectDefs?.mode, systemDefaults.mode),
     model: resolveDefault(body.model, projectDefs?.model, systemDefaults.model || null),
+    providerId: resolveProviderDefault(explicitProviderId, projectProviderId, systemProviderId),
     effortLevel,
     gitBranch: resolveDefault(body.gitBranch, projectDefs?.gitBranch, null),
     gitMode: resolveDefault(body.gitMode, projectDefs?.gitMode, null),

package/packages/server/src/api/projects.js

@@ -18,6 +18,7 @@ import {
   setupAndStartSession,
 } from './projects-session-helpers.js';
 import { validateGitSettings, buildRunsBySession } from './projects-helpers.js';
+import { resolveAgentTypeFromModel } from '../services/sessionProvider.js';
 import { access, constants } from 'fs/promises';
 import { dirname, isAbsolute } from 'path';
 
@@ -242,7 +243,9 @@ function createSessionRow(projectId, config, nextTemplateId, initialStatus) {
     parentSessionId: config.parentSessionId,
     status: initialStatus,
     model: config.model,
+    providerId: config.providerId,
     effortLevel: config.effortLevel,
+    agentType: config.agentType,
   });
 
   const postCreateUpdate = {
@@ -298,6 +301,11 @@ router.post('/:id/sessions', uploadMiddleware('files', 10), handleUploadError, a
     }
 
     const { config, nextTemplateId } = prepared;
+    // Derive the agent type from the resolved model (after template overrides
+    // have been applied inside validateAndPrepareSessionConfig). Null/unknown
+    // model IDs fall back to 'claude-code'. This is the single source of truth
+    // for which adapter the session will use; sessions.create() persists it.
+    config.agentType = resolveAgentTypeFromModel(config.model);
     const initialStatus = determineInitialStatus(config);
     session = createSessionRow(req.params.id, config, nextTemplateId, initialStatus);
     return await startSessionOrFail(req, res, { session, config, project });

package/packages/server/src/api/providers.js

@@ -139,6 +139,7 @@ router.post('/:id/test', async (req, res) => {
     // Pick the sonnet-tiered model (if any) as the test model, falling back to any first model
     const sonnetModel = provider.models?.find((m) => m.tier === 'sonnet');
     const testConfig = {
+      kind: provider.kind || 'anthropic',
       baseUrl: provider.baseUrl,
       authToken: provider.authToken,
       defaultSonnetModel: sonnetModel?.modelId,

package/packages/server/src/api/sessions-draft.js

@@ -57,6 +57,7 @@ router.post('/:id/start', requireSession, async (req, res) => {
     const updatedSession = await startDraft(req.session_, {
       prompt: req.body.prompt,
       model: req.body.model,
+      providerId: req.body.providerId,
     });
 
     res.json({ success: true, session: updatedSession });

package/packages/server/src/api/sessions-messages.js

@@ -4,6 +4,7 @@ import { continueSession } from '../services/sessionManager.js';
 import { upload as _upload, handleUploadError } from '../middleware/upload.js';
 import { requireSession, requireSessionAndProject } from '../middleware/sessionLookup.js';
 import * as slashCommandService from '../services/slashCommandService.js';
+import { checkCrossKindSwitch } from '../services/sessionAgentGuard.js';
 
 const router = Router();
 
@@ -61,6 +62,11 @@ router.post('/:id/message', _upload.array('files', 10), handleUploadError, requi
     return res.status(400).json({ error: 'Session is not waiting for input' });
   }
 
+  const crossKindError = checkCrossKindSwitch(req.session_, model);
+  if (crossKindError) {
+    return res.status(400).json(crossKindError);
+  }
+
   try {
     // Store file attachments if any - saves to disk in workingDirectory/.attachments
     const messageAttachments = attachments.createBatch(req.session_.id, null, files, req.workingDirectory);

package/packages/server/src/api/settings.js

@@ -1,8 +1,9 @@
 import { Router } from 'express';
-import { settings } from '../db/index.js';
+import { modelProviders, settings } from '../db/index.js';
 import { DEFAULT_SESSION_TITLE_PROMPT } from '../services/summaryService.js';
 
 const router = Router();
+const SUPPORTED_SUMMARY_PROVIDER_KINDS = new Set(['anthropic', 'openai']);
 
 /**
  * GET /api/settings/token-weights
@@ -93,19 +94,42 @@ router.get('/summary', (req, res) => {
  */
 router.put('/summary', (req, res) => {
   try {
-    const { disableSessionSummaries, sessionTitlePrompt } = req.body;
+    const body = req.body || {};
+    const {
+      disableSessionSummaries,
+      sessionTitlePrompt,
+      summaryModel,
+      summaryProviderId,
+    } = body;
 
     // Validate that all required fields are present
     if (typeof disableSessionSummaries !== 'boolean' ||
-        typeof sessionTitlePrompt !== 'string') {
+        typeof sessionTitlePrompt !== 'string' ||
+        !Object.prototype.hasOwnProperty.call(body, 'summaryModel') ||
+        !Object.prototype.hasOwnProperty.call(body, 'summaryProviderId')) {
       return res.status(400).json({
-        error: 'Invalid summary settings. disableSessionSummaries must be a boolean, sessionTitlePrompt must be a string'
+        error: 'Invalid summary settings. disableSessionSummaries must be a boolean, sessionTitlePrompt must be a string, summaryModel must be present, and summaryProviderId must be present'
       });
     }
 
+    if (typeof summaryModel !== 'string') {
+      return res.status(400).json({ error: 'summaryModel must be a string' });
+    }
+
+    if (summaryProviderId !== null && typeof summaryProviderId !== 'string') {
+      return res.status(400).json({ error: 'summaryProviderId must be a string or null' });
+    }
+
+    const validationError = validateSummaryModelSelection(summaryModel, summaryProviderId);
+    if (validationError) {
+      return res.status(400).json({ error: validationError });
+    }
+
     const updatedSettings = settings.setSummarySettings({
       disableSessionSummaries,
       sessionTitlePrompt,
+      summaryModel,
+      summaryProviderId,
     });
 
     // Include the default prompt for UI display/editing
@@ -119,6 +143,30 @@ router.put('/summary', (req, res) => {
   }
 });
 
+function validateSummaryModelSelection(summaryModel, summaryProviderId) {
+  if (!summaryModel) {
+    if (summaryProviderId !== null) {
+      return 'summaryProviderId must be null when summaryModel is empty';
+    }
+    return null;
+  }
+
+  if (!summaryProviderId) {
+    return 'summaryProviderId is required when summaryModel is set';
+  }
+
+  const provider = modelProviders.getById(summaryProviderId);
+  if (!provider) return `Unknown summary provider: ${summaryProviderId}`;
+  if (!SUPPORTED_SUMMARY_PROVIDER_KINDS.has(provider.kind || 'anthropic')) {
+    return `Unsupported summary provider kind: ${provider.kind}`;
+  }
+  const ownsModel = provider.models?.some((model) => model.modelId === summaryModel);
+  if (!ownsModel) {
+    return `Provider ${summaryProviderId} does not own summary model ${summaryModel}`;
+  }
+  return null;
+}
+
 /**
  * DELETE /api/settings/summary
  * Reset summary settings to defaults

package/packages/server/src/db/ConversationRepository.js

@@ -237,6 +237,7 @@ export class ConversationRepository extends BaseRepository {
    * @param {Object} usage - Usage data
    * @param {number} usage.inputTokens
    * @param {number} usage.outputTokens
+   * @param {number} usage.thinkingTokens
    * @param {number} usage.cacheReadInputTokens
    * @param {number} usage.cacheCreationInputTokens
    * @param {number} usage.webSearchRequests
@@ -255,6 +256,7 @@ export class ConversationRepository extends BaseRepository {
         `UPDATE conversations SET
           input_tokens = ?,
           output_tokens = ?,
+          thinking_tokens = ?,
           cache_read_input_tokens = ?,
           cache_creation_input_tokens = ?,
           web_search_requests = ?,
@@ -265,6 +267,7 @@ export class ConversationRepository extends BaseRepository {
       .run(
         usage.inputTokens,
         usage.outputTokens,
+        usage.thinkingTokens || 0,
         usage.cacheReadInputTokens,
         usage.cacheCreationInputTokens,
         usage.webSearchRequests,
@@ -290,9 +293,12 @@ export class ConversationRepository extends BaseRepository {
       const now = Date.now();
 
       this.db
-        .prepare(
-          `INSERT INTO conversations (id, session_id, name, summary, is_active, created_at, updated_at)
-           VALUES (?, ?, ?, ?, ?, ?, ?)`
+      .prepare(
+          `INSERT INTO conversations (id, session_id, name, summary, is_active,
+                                      input_tokens, output_tokens, thinking_tokens,
+                                      cache_read_input_tokens, cache_creation_input_tokens,
+                                      web_search_requests, context_window, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
         )
         .run(
           id,
@@ -300,6 +306,13 @@ export class ConversationRepository extends BaseRepository {
           conv.name,
           conv.summary,
           conv.isActive ? 1 : 0,
+          conv.inputTokens,
+          conv.outputTokens,
+          conv.thinkingTokens,
+          conv.cacheReadInputTokens,
+          conv.cacheCreationInputTokens,
+          conv.webSearchRequests,
+          conv.contextWindow,
           now,
           now
         );