chati-dev 4.5.6 → 4.5.8

package/src/terminal/spawner.js

@@ -11,6 +11,7 @@ import { spawn } from 'child_process';
 import { validateWriteScopes, buildIsolationEnv } from './isolation.js';
 import { getProvider } from './cli-registry.js';
 import { getRateLimiter } from './rate-limiter.js';
+import { recordModelSelection } from '../orchestrator/session-manager.js';
 
 // ---------------------------------------------------------------------------
 // Constants
@@ -108,6 +109,9 @@ export function cleanParentEnv(env) {
  * @property {string} taskId          - Task identifier
  * @property {string} [model]         - LLM model tier name (e.g. opus, pro, codex, claude-sonnet)
  * @property {string} [provider]      - CLI provider name (claude, gemini, codex, grok)
+ * @property {string} [providerId]    - Vendor provider identifier (anthropic, openai, xai)
+ * @property {string} [reasoningConfiguration] - Requested reasoning effort
+ * @property {string} [catalogSnapshotRef] - Capability catalog snapshot used for routing
  * @property {boolean} [strictProvider] - Reject a missing provider rather than using the legacy fallback
  * @property {string} [prompt]        - Full prompt string (from prompt-builder, piped via stdin)
  * @property {object} [contextPayload] - Context to inject via env var
@@ -159,6 +163,7 @@ export function buildSpawnCommand(config) {
     CHATI_AGENT: config.agent,
     CHATI_TASK_ID: config.taskId,
     CHATI_SPAWNED: 'true',
+    ...(config.reasoningConfiguration ? { CHATI_REASONING_CONFIGURATION: config.reasoningConfiguration } : {}),
   };
 
   if (config.contextPayload) {
@@ -174,13 +179,20 @@ export function buildSpawnCommand(config) {
   const providerName = config.provider || 'claude';
   let command, args, prompt;
   let providerFallback = null;
+  let actualProvider = providerName;
+  let actualModel;
+  let actualReasoningConfiguration = null;
 
   try {
     const provider = getProvider(providerName);
-    const adapterResult = provider.adapter.buildCommand(config, provider);
+    const requestedModel = config.model || provider.defaultModel;
+    actualModel = provider.modelMap[requestedModel] || requestedModel;
+    const adapterResult = provider.adapter.buildCommand({ ...config, model: actualModel }, provider);
     command = adapterResult.command;
     args = adapterResult.args;
     prompt = adapterResult.stdinPrompt;
+    actualModel = adapterResult.effectiveModel;
+    actualReasoningConfiguration = adapterResult.effectiveReasoningConfiguration;
   } catch (err) {
     if (config.strictProvider) {
       const failure = new Error(`Selected provider "${providerName}" is unavailable: ${err.message}`);
@@ -194,18 +206,26 @@ export function buildSpawnCommand(config) {
       reason: err.message,
       timestamp: new Date().toISOString(),
     };
+    actualProvider = 'claude';
     console.error(`[chati] Provider "${providerName}" resolution failed: ${err.message}. Falling back to claude.`);
     command = 'claude';
     args = ['--print', '--dangerously-skip-permissions'];
-    if (config.model) {
-      const claudeProvider = getProvider('claude');
-      const resolvedModel = claudeProvider.modelMap[config.model] || config.model;
-      args.push('--model', resolvedModel);
+    const claudeProvider = getProvider('claude');
+    const requestedClaudeModel = config.model || 'sonnet';
+    actualModel = claudeProvider.modelMap[requestedClaudeModel]
+      || (requestedClaudeModel.startsWith('claude-') ? requestedClaudeModel : claudeProvider.modelMap.sonnet);
+    args.push('--model', actualModel);
+    if (config.reasoningConfiguration) {
+      args.push('--effort', config.reasoningConfiguration);
+      actualReasoningConfiguration = config.reasoningConfiguration;
     }
     prompt = config.prompt || null;
   }
 
-  return { command, args, env, terminalId, prompt, providerFallback };
+  return {
+    command, args, env, terminalId, prompt, providerFallback,
+    actualProvider, actualModel, actualReasoningConfiguration,
+  };
 }
 
 /**
@@ -215,11 +235,29 @@ export function buildSpawnCommand(config) {
  * @returns {TerminalHandle}
  */
 export function spawnTerminal(config) {
-  const { command, args, env, terminalId, prompt, providerFallback } = buildSpawnCommand(config);
+  const {
+    command, args, env, terminalId, prompt, providerFallback,
+    actualProvider, actualModel, actualReasoningConfiguration,
+  } = buildSpawnCommand(config);
 
   const cwd = config.workingDir || process.cwd();
   const timeout = config.timeout || 300_000; // default 5 minutes
 
+  const selectionRecord = recordModelSelection(cwd, {
+    agent: config.agent,
+    taskId: config.taskId,
+    provider: actualProvider,
+    providerId: providerFallback ? null : (config.providerId || null),
+    model: actualModel,
+    reasoningConfiguration: actualReasoningConfiguration,
+    catalogSnapshotRef: providerFallback ? null : (config.catalogSnapshotRef || null),
+  });
+  if (!selectionRecord.saved) {
+    const auditError = new Error(selectionRecord.error || 'Failed to persist model selection audit');
+    auditError.code = 'MODEL_SELECTION_AUDIT_FAILED';
+    throw auditError;
+  }
+
   const child = spawn(command, args, {
     cwd,
     env: { ...cleanParentEnv(process.env), ...env },
@@ -238,8 +276,9 @@ export function spawnTerminal(config) {
     process: child,
     agent: config.agent,
     taskId: config.taskId,
-    model: config.model || 'unknown',
-    provider: config.provider || 'claude',
+    model: actualModel || config.model || 'provider-default',
+    provider: actualProvider,
+    reasoningConfiguration: config.reasoningConfiguration || null,
     providerFallback,
     startedAt: new Date().toISOString(),
     status: 'running',
@@ -250,7 +289,7 @@ export function spawnTerminal(config) {
   };
 
   // Record spawn in rate limiter for throttling
-  const providerForRate = config.provider || 'claude';
+  const providerForRate = actualProvider;
   getRateLimiter(providerForRate).recordSpawn();
 
   // Capture output (capped at ~10MB to prevent unbounded memory growth)