wtt-connect 0.2.15 → 0.2.16

package/README.md

@@ -100,10 +100,23 @@ Important settings:
 - `WTT_CONNECT_ENABLE_SHELL=1` exposes an interactive agent-side Terminal from wtt-web for claimed online agents
 - `WTT_CONNECT_SHELL_MODE=unsafe|readonly|off`; default `unsafe` runs one-shot shell commands without command filtering. The interactive Terminal always opens a real PTY shell on the agent host.
 - `WTT_CONNECT_SHELL_TIMEOUT_SECONDS` and `WTT_CONNECT_SHELL_MAX_OUTPUT_CHARS` only bound legacy one-shot command execution and returned output
+- `WTT_CONNECT_MODEL` is only a fallback default. Per-message `metadata.model_config.model` from WTT Web overrides it for that run.
+
+Optional model/provider switcher:
+
+- `WTT_CONNECT_MODEL_SWITCH_MODE=off|cc-switch|command|custom`
+- `WTT_CONNECT_MODEL_SWITCH_COMMAND=cc-switch`
+- `WTT_CONNECT_MODEL_SWITCH_ARGS='["use","{adapter}","{provider}","--model","{model}"]'`
+- `WTT_CONNECT_MODEL_SWITCH_TEMPLATE='cc-switch use {adapter} {provider} --model {model}'`
+- `WTT_CONNECT_MODEL_SWITCH_STRICT=0|1`; when false, switcher failures are logged and the adapter still runs
+- `WTT_CONNECT_MODEL_SWITCH_TIMEOUT_MS=15000`
+- `WTT_CONNECT_MODEL_PROVIDER_MAP='{"openai-codex/*":{"adapter":"codex","provider":"openai"},"deepseek/*":{"adapter":"claude-code","provider":"deepseek"}}'`
+
+This hook is for Cloud Agent hosts that use `cc-switch` or a compatible local provider/config switcher. WTT Web still only sends per-message `metadata.model_config`; `wtt-connect` resolves adapter/provider/model, invokes the switcher inside the agent runtime, then runs the selected Claude Code or Codex adapter. When the switcher is enabled, each container serializes switcher plus CLI execution so concurrent topic runs do not race over a shared provider config.
 
 Session continuity:
 
-- `wtt-connect` uses the WTT topic/task id as the local session key, for example `wtt:topic:<topic_id>`.
+- `wtt-connect` uses the WTT topic/task id plus adapter and model as the local session key, for example `wtt:topic:<topic_id>:codex:gpt-5.5:high`.
 - Codex stores `codexThreadId` and resumes with `codex exec resume`.
 - Claude Code stores `claudeSessionId` and resumes the same topic with `claude --resume <session_id> -p ...`.
 - Keep `WTT_CONNECT_STATE_DIR`, `WTT_CONNECT_STORE_FILE`, and `WTT_CONNECT_WORKDIR` stable per claimed agent. If they are changed or deleted, the adapter cannot resume previous local sessions.
@@ -311,7 +324,7 @@ Discussion/collaborative topics are mention-gated: `wtt-connect` only replies wh
 
 In discussion/collaborative topics, `wtt-connect` also injects a silent collaboration standard into each agent prompt. Agents should treat the topic as a shared workboard, preserve shared state, split non-trivial work into owned tasks, state concrete done criteria, report execution evidence, challenge weak assumptions, and only @mention the next specific agent when handoff is required.
 
-Adapter routing can be explicit through task fields such as `exec_mode=gemini`, or through message mentions such as `@codex`, `@claude`, `@cursor`, `@gemini`, `@qoder`, `@opencode`, `@iflow`, `@kimi`, `@pi`, `@acp`, or `@devin` when those adapters are enabled.
+Adapter routing can be explicit through task fields such as `exec_mode=gemini`, through message `metadata.model_config.adapter`, or through message mentions such as `@codex`, `@claude`, `@cursor`, `@gemini`, `@qoder`, `@opencode`, `@iflow`, `@kimi`, `@pi`, `@acp`, or `@devin` when those adapters are enabled. If `metadata.model_config.model` is present, OpenAI/OpenAI-Codex model IDs route to Codex and Claude/DeepSeek/Kimi-style model IDs route to Claude Code. When the optional model switcher is enabled, the same resolved adapter/provider/model is passed to the configured `cc-switch`-compatible command before the adapter starts.
 
 OpenClaw is deliberately not part of the default `wtt-connect` adapter set because WTT already has the first-class `wtt-plugin` for OpenClaw.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wtt-connect",
-  "version": "0.2.15",
+  "version": "0.2.16",
   "private": false,
   "description": "WTT-native connector daemon for Codex, Claude Code, Cursor, Gemini, ACP, and other coding agent surfaces.",
   "type": "module",

package/src/adapter-registry.js

@@ -24,8 +24,11 @@ export class AdapterRegistry {
   }
 
   select(input = {}) {
-    const explicit = String(input.adapter || input.exec_mode || input.execMode || '').trim().toLowerCase();
+    const modelConfig = modelConfigFromInput(input);
+    const explicit = String(modelConfig.adapter || input.adapter || input.exec_mode || input.execMode || '').trim().toLowerCase();
     if (explicit && this.adapters.has(normalizeAdapterName(explicit))) return this.get(normalizeAdapterName(explicit));
+    const modelAdapter = adapterForModel(modelConfig.model);
+    if (modelAdapter && this.adapters.has(modelAdapter)) return this.get(modelAdapter);
     const type = String(input.task_type || input.taskType || '').trim().toLowerCase();
     if (type && this.config.adapterPolicy?.[type]) return this.get(this.config.adapterPolicy[type]);
     const text = `${input.title || ''}\n${input.description || ''}\n${input.content || ''}`.toLowerCase();
@@ -40,6 +43,34 @@ export class AdapterRegistry {
   }
 }
 
+function modelConfigFromInput(input = {}) {
+  const direct = input.model_config || input.modelConfig;
+  if (direct && typeof direct === 'object') return direct;
+  const meta = parseMetadata(input.metadata || input.msg_metadata || input.meta);
+  const cfg = meta?.model_config || meta?.modelConfig;
+  return cfg && typeof cfg === 'object' ? cfg : {};
+}
+
+function parseMetadata(metadata) {
+  if (!metadata) return null;
+  if (typeof metadata === 'object') return metadata;
+  if (typeof metadata !== 'string') return null;
+  try {
+    const parsed = JSON.parse(metadata);
+    return parsed && typeof parsed === 'object' ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function adapterForModel(model) {
+  const value = String(model || '').trim().toLowerCase();
+  if (!value) return '';
+  if (value.startsWith('openai-codex/') || value.startsWith('openai/') || value.startsWith('gpt-') || value.startsWith('o3') || value.startsWith('o4')) return 'codex';
+  if (value.startsWith('anthropic/') || value.startsWith('claude') || value.startsWith('deepseek/') || value.startsWith('deepseek') || value.startsWith('moonshot/') || value.startsWith('kimi')) return 'claude-code';
+  return '';
+}
+
 function adapterMentionAliases() {
   return [
     'codex',

package/src/adapters/claude-code.js

@@ -14,8 +14,9 @@ export class ClaudeCodeAdapter {
     const sessionKey = context.sessionKey || 'default';
     const stored = this.store?.getSession(sessionKey) || {};
     const sessionId = this.sessionByKey.get(sessionKey) || stored.claudeSessionId;
-    const args = this.buildArgs(prompt, sessionId);
-    log('info', 'claude-code launch', { sessionKey, resume: Boolean(sessionId) });
+    const args = this.buildArgs(prompt, sessionId, context);
+    const runtimeModel = modelForClaude(this.config, context);
+    log('info', 'claude-code launch', { sessionKey, resume: Boolean(sessionId), model: runtimeModel || this.config.model || process.env.ANTHROPIC_MODEL || '' });
     let result;
     try {
       result = await runClaude(this.config.claudeBin, args, this.config.workDir, this.config.taskTimeoutSeconds * 1000, context.onProgress);
@@ -24,7 +25,7 @@ export class ClaudeCodeAdapter {
       log('warn', 'claude-code resume failed; retrying with fresh session', { sessionKey, sessionId, error: err.message });
       this.sessionByKey.delete(sessionKey);
       this.store?.patchSession(sessionKey, { claudeSessionId: '', adapter: this.name });
-      result = await runClaude(this.config.claudeBin, this.buildArgs(prompt, ''), this.config.workDir, this.config.taskTimeoutSeconds * 1000, context.onProgress);
+      result = await runClaude(this.config.claudeBin, this.buildArgs(prompt, '', context), this.config.workDir, this.config.taskTimeoutSeconds * 1000, context.onProgress);
     }
     if (result.sessionId) {
       this.sessionByKey.set(sessionKey, result.sessionId);
@@ -33,17 +34,26 @@ export class ClaudeCodeAdapter {
     return result.text.trim();
   }
 
-  buildArgs(prompt, sessionId = '') {
+  buildArgs(prompt, sessionId = '', context = {}) {
     // Claude Code 2.x requires --verbose when stream-json is used with --print/-p.
     const args = [];
     if (sessionId) args.push('--resume', sessionId);
     args.push('-p', prompt, '--output-format', 'stream-json', '--verbose');
     if (['full-auto', 'yolo'].includes(this.config.mode)) args.push('--dangerously-skip-permissions', '--permission-mode', 'bypassPermissions');
-    if (this.config.model) args.push('--model', this.config.model);
+    const model = modelForClaude(this.config, context);
+    if (model) args.push('--model', model);
     return args;
   }
 }
 
+function modelForClaude(config, context = {}) {
+  const cfg = context.modelConfig || {};
+  const model = String(cfg.model || cfg.model_id || cfg.modelId || config.model || process.env.ANTHROPIC_MODEL || '').trim();
+  if (!model) return '';
+  if (model.startsWith('anthropic/')) return model.slice('anthropic/'.length);
+  return model;
+}
+
 function shouldRetryFreshSession(err) {
   const message = String(err?.message || err || '').toLowerCase();
   return [

package/src/adapters/codex.js

@@ -16,7 +16,8 @@ export class CodexAdapter {
     const stored = this.store?.getSession(sessionKey) || {};
     const threadId = this.threadBySession.get(sessionKey) || stored.codexThreadId;
     const args = this.buildArgs(threadId, context);
-    log('info', 'codex launch', { sessionKey, resume: Boolean(threadId), mode: this.config.mode });
+    const runtimeModel = modelForCodex(this.config, context);
+    log('info', 'codex launch', { sessionKey, resume: Boolean(threadId), mode: this.config.mode, model: runtimeModel || this.config.model || '' });
     let result;
     try {
       result = await this.runWithArgs(args, prompt, context, sessionKey);
@@ -48,14 +49,38 @@ export class CodexAdapter {
   buildArgs(threadId, context = {}) {
     const options = ['--skip-git-repo-check', '--json'];
     options.push(...(this.permissions?.codexArgs() || []));
-    if (this.config.model) options.push('--model', this.config.model);
+    const model = modelForCodex(this.config, context);
+    if (model) options.push('--model', model);
     for (const img of context.images || []) options.push('--image', img);
-    if (this.config.reasoningEffort) options.push('-c', `model_reasoning_effort=${JSON.stringify(this.config.reasoningEffort)}`);
+    const reasoningEffort = reasoningEffortForRun(this.config, context);
+    if (reasoningEffort && reasoningEffort !== 'off') options.push('-c', `model_reasoning_effort=${JSON.stringify(reasoningEffort)}`);
     if (threadId) return ['exec', 'resume', ...options, threadId, '-'];
     return ['exec', ...options, '--cd', this.config.workDir, '-'];
   }
 }
 
+function modelForCodex(config, context = {}) {
+  return normalizeCodexModel(modelFromContext(config, context));
+}
+
+function modelFromContext(config, context = {}) {
+  const cfg = context.modelConfig || {};
+  return String(cfg.model || cfg.model_id || cfg.modelId || config.model || process.env.OPENAI_MODEL || process.env.CODEX_MODEL || '').trim();
+}
+
+function reasoningEffortForRun(config, context = {}) {
+  const cfg = context.modelConfig || {};
+  return String(cfg.reasoning_effort || cfg.reasoningEffort || config.reasoningEffort || '').trim().toLowerCase();
+}
+
+function normalizeCodexModel(model) {
+  const value = String(model || '').trim();
+  if (!value) return '';
+  if (value.startsWith('openai-codex/')) return value.slice('openai-codex/'.length);
+  if (value.startsWith('openai/')) return value.slice('openai/'.length);
+  return value;
+}
+
 function shouldRetryFreshThread(err) {
   const message = String(err?.message || err || '').toLowerCase();
   return [

package/src/config.js

@@ -41,6 +41,15 @@ export function loadConfig(argv = {}) {
     adapter,
     adapters,
     adapterPolicy: fileConfig.adapterPolicy || parseJsonEnv(process.env.WTT_CONNECT_ADAPTER_POLICY, {}),
+    modelSwitch: {
+      mode: process.env.WTT_CONNECT_MODEL_SWITCH_MODE || fileConfig.modelSwitch?.mode || 'off',
+      command: process.env.WTT_CONNECT_MODEL_SWITCH_COMMAND || fileConfig.modelSwitch?.command || '',
+      args: parseJsonOrListEnv(process.env.WTT_CONNECT_MODEL_SWITCH_ARGS || fileConfig.modelSwitch?.args || ''),
+      template: process.env.WTT_CONNECT_MODEL_SWITCH_TEMPLATE || fileConfig.modelSwitch?.template || '',
+      strict: parseBool(process.env.WTT_CONNECT_MODEL_SWITCH_STRICT, fileConfig.modelSwitch?.strict ?? false),
+      timeoutMs: parseIntEnv(process.env.WTT_CONNECT_MODEL_SWITCH_TIMEOUT_MS, fileConfig.modelSwitch?.timeoutMs || 15000),
+      providerMap: fileConfig.modelSwitch?.providerMap || parseJsonEnv(process.env.WTT_CONNECT_MODEL_PROVIDER_MAP, {}),
+    },
     workDir,
     model: process.env.WTT_CONNECT_MODEL || fileConfig.model || '',
     mode: process.env.WTT_CONNECT_MODE || fileConfig.mode || 'full-auto',
@@ -147,3 +156,18 @@ function parseListEnv(value) {
   }
   return raw.split(',').map((x) => x.trim()).filter(Boolean);
 }
+
+function parseJsonOrListEnv(value) {
+  if (!value) return [];
+  if (Array.isArray(value)) return value.map((x) => String(x));
+  if (typeof value !== 'string') return [];
+  const raw = value.trim();
+  if (!raw) return [];
+  if (raw.startsWith('[')) {
+    try {
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed)) return parsed.map((x) => String(x));
+    } catch {}
+  }
+  return parseListEnv(raw);
+}

package/src/model-switcher.js

@@ -0,0 +1,137 @@
+import { execFile, exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { log } from './logger.js';
+
+const execFileAsync = promisify(execFile);
+const execAsync = promisify(exec);
+
+export function isModelSwitcherEnabled(config) {
+  const mode = String(config.modelSwitch?.mode || '').trim().toLowerCase();
+  return ['cc-switch', 'ccswitch', 'command', 'custom'].includes(mode);
+}
+
+export async function switchModelProvider(config, input = {}) {
+  if (!isModelSwitcherEnabled(config)) return resolveSwitchTarget(config, input);
+
+  const target = resolveSwitchTarget(config, input);
+  const switcher = config.modelSwitch || {};
+  const command = String(switcher.command || '').trim();
+  const template = String(switcher.template || '').trim();
+
+  if (!command && !template) {
+    const message = 'model switcher enabled but no command/template configured';
+    if (switcher.strict) throw new Error(message);
+    log('warn', message, { target });
+    return target;
+  }
+
+  try {
+    if (template) {
+      const rendered = renderShellTemplate(template, target);
+      await execAsync(rendered, { timeout: switcher.timeoutMs || 15000 });
+      log('info', 'model switcher template completed', { adapter: target.adapter, provider: target.provider, model: target.model });
+      return target;
+    }
+
+    const args = (switcher.args?.length ? switcher.args : defaultCcSwitchArgs(target))
+      .map((arg) => renderArgTemplate(arg, target));
+    await execFileAsync(command, args, { timeout: switcher.timeoutMs || 15000 });
+    log('info', 'model switcher command completed', { command, adapter: target.adapter, provider: target.provider, model: target.model });
+    return target;
+  } catch (err) {
+    const message = `model switcher failed: ${err.message}`;
+    if (switcher.strict) throw new Error(message);
+    log('warn', message, { adapter: target.adapter, provider: target.provider, model: target.model });
+    return target;
+  }
+}
+
+export function resolveSwitchTarget(config, input = {}) {
+  const modelConfig = input.modelConfig || {};
+  const rawModel = String(modelConfig.model || modelConfig.model_id || modelConfig.modelId || config.model || '').trim();
+  const mapped = modelMapEntry(config, rawModel);
+  const adapter = normalizeAdapter(modelConfig.adapter || modelConfig.agent_type || modelConfig.agentType || mapped.adapter || input.adapter || '');
+  const provider = String(modelConfig.provider || mapped.provider || providerFromModel(rawModel, adapter) || '').trim();
+  const model = String(mapped.model || modelForAdapter(rawModel, adapter) || rawModel || '').trim();
+  const reasoningEffort = String(modelConfig.reasoning_effort || modelConfig.reasoningEffort || '').trim().toLowerCase();
+  return {
+    adapter,
+    provider,
+    model,
+    raw_model: rawModel,
+    rawModel,
+    reasoning_effort: reasoningEffort,
+    reasoningEffort,
+    session_key: String(input.sessionKey || ''),
+    sessionKey: String(input.sessionKey || ''),
+  };
+}
+
+function modelMapEntry(config, rawModel) {
+  const map = config.modelSwitch?.providerMap || {};
+  const exact = map[rawModel];
+  if (exact && typeof exact === 'object') return exact;
+  const lower = String(rawModel || '').toLowerCase();
+  for (const [key, value] of Object.entries(map)) {
+    const pattern = String(key || '').toLowerCase();
+    if (!pattern.endsWith('*')) continue;
+    if (lower.startsWith(pattern.slice(0, -1)) && value && typeof value === 'object') return value;
+  }
+  return {};
+}
+
+function defaultCcSwitchArgs(target) {
+  const args = ['use'];
+  if (target.adapter) args.push('{adapter}');
+  if (target.provider) args.push('{provider}');
+  if (target.model) args.push('--model', '{model}');
+  return args;
+}
+
+function renderArgTemplate(value, target) {
+  return String(value).replace(/\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g, (_all, key) => safeText(target[key] ?? ''));
+}
+
+function renderShellTemplate(value, target) {
+  return String(value).replace(/\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g, (_all, key) => shellQuote(target[key] ?? ''));
+}
+
+function safeText(value) {
+  return String(value ?? '').replace(/[\r\n]/g, ' ').trim();
+}
+
+function shellQuote(value) {
+  const text = safeText(value);
+  if (!text) return "''";
+  return `'${text.replace(/'/g, `'\\''`)}'`;
+}
+
+function normalizeAdapter(value) {
+  const adapter = String(value || '').trim().toLowerCase();
+  if (adapter === 'claude') return 'claude-code';
+  if (adapter === 'cc-connect') return 'codex';
+  return adapter || '';
+}
+
+function providerFromModel(rawModel, adapter) {
+  const value = String(rawModel || '').trim().toLowerCase();
+  if (value.startsWith('openai-codex/')) return 'openai';
+  if (value.includes('/')) return value.split('/')[0];
+  if (value.startsWith('gpt-') || value.startsWith('o3') || value.startsWith('o4')) return 'openai';
+  if (value.startsWith('claude')) return 'anthropic';
+  if (value.startsWith('deepseek')) return 'deepseek';
+  if (value.startsWith('kimi')) return 'moonshot';
+  if (adapter === 'codex') return 'openai';
+  return '';
+}
+
+function modelForAdapter(rawModel, adapter) {
+  const value = String(rawModel || '').trim();
+  if (!value) return '';
+  if (adapter === 'codex') {
+    if (value.startsWith('openai-codex/')) return value.slice('openai-codex/'.length);
+    if (value.startsWith('openai/')) return value.slice('openai/'.length);
+  }
+  if (adapter === 'claude-code' && value.startsWith('anthropic/')) return value.slice('anthropic/'.length);
+  return value.includes('/') ? value.split('/').slice(1).join('/') : value;
+}

package/src/runner.js

@@ -18,6 +18,7 @@ import { log } from './logger.js';
 import { buildRuntimeInfo } from './runtime-info.js';
 import { runShellCommand } from './shell-runner.js';
 import { TerminalSessionManager } from './terminal-session.js';
+import { isModelSwitcherEnabled, switchModelProvider } from './model-switcher.js';
 
 const TERMINAL_STATUSES = new Set(['review', 'done', 'approved', 'cancelled']);
 const GENERATED_FILE_EXTENSIONS = new Set([
@@ -47,6 +48,7 @@ export class Runner {
     this.runningTasks = new Set();
     this.doneTasks = new Map();
     this.agentProfileCache = { value: null, expiresAt: 0 };
+    this.modelRunTail = Promise.resolve();
   }
 
   async start() {
@@ -167,8 +169,9 @@ export class Runner {
     await this.wtt.typing(topicId, 'start', { statusText: 'Agent 已接收消息，正在准备执行', statusKind: 'queued', ttlMs: 30000 });
     try {
       const transcripts = await this.transcribeAttachments(staged.files);
-      const adapter = this.registry.select({ ...m, content });
-      await this.wtt.typing(topicId, 'start', { statusText: `${adapterDisplayName(adapter.name)} 正在执行`, statusKind: 'running', adapter: adapter.name, ttlMs: 30000 });
+      const modelConfig = modelConfigFromMessage(m);
+      const adapter = this.registry.select({ ...m, content, model_config: modelConfig });
+      await this.wtt.typing(topicId, 'start', { statusText: `${adapterDisplayName(adapter.name)} 正在执行${modelConfig.model ? ` · ${modelConfig.model}` : ''}`, statusKind: 'running', adapter: adapter.name, model: modelConfig.model || undefined, ttlMs: 30000 });
       const agentProfile = await this.getAgentProfile();
       const agentSoul = renderAgentSoulContext(m.metadata, agentProfile?.role_template);
       const discussionRouting = renderDiscussionRoutingInstruction(m, this.config);
@@ -195,9 +198,10 @@ export class Runner {
         renderGeneratedFileArtifactInstruction(this.config, topicId),
         'Reply naturally and concisely unless the user asks for detail.',
       ].filter(Boolean).join('\n');
-      const output = await adapter.run(prompt, {
-        sessionKey: `wtt:topic:${topicId}`,
+      const output = await this.runAdapter(adapter, prompt, {
+        sessionKey: `wtt:topic:${topicId}:${adapter.name}:${sessionModelKey(modelConfig)}`,
         topicId,
+        modelConfig,
         files: staged.files,
         images: staged.images,
         onProgress: (event) => this.maybePublishProgress(topicId, event, adapter.name),
@@ -224,15 +228,17 @@ export class Runner {
     await this.api.patchTask(taskId, { status: 'doing', progress: 0, runner_agent_id: this.config.agentId });
     const staged = await this.attachments.stageMessage(task);
     const transcripts = await this.transcribeAttachments(staged.files);
-    const adapter = this.registry.select(task);
+    const modelConfig = modelConfigFromMessage(task);
+    const adapter = this.registry.select({ ...task, model_config: modelConfig });
     const agentProfile = await this.getAgentProfile();
-    if (topicId) await this.wtt.typing(topicId, 'start', { statusText: `${adapterDisplayName(adapter.name)} 正在执行任务`, statusKind: 'running', adapter: adapter.name, ttlMs: 30000 });
+    if (topicId) await this.wtt.typing(topicId, 'start', { statusText: `${adapterDisplayName(adapter.name)} 正在执行任务${modelConfig.model ? ` · ${modelConfig.model}` : ''}`, statusKind: 'running', adapter: adapter.name, model: modelConfig.model || undefined, ttlMs: 30000 });
     const prompt = buildTaskPrompt(task, this.config, staged, transcripts, agentProfile);
     try {
-      const output = await adapter.run(prompt, {
-        sessionKey: `wtt:task:${taskId}`,
+      const output = await this.runAdapter(adapter, prompt, {
+        sessionKey: `wtt:task:${taskId}:${adapter.name}:${sessionModelKey(modelConfig)}`,
         taskId,
         topicId,
+        modelConfig,
         files: staged.files,
         images: staged.images,
         onProgress: (ev) => topicId ? this.maybePublishProgress(topicId, ev, adapter.name) : Promise.resolve(),
@@ -268,6 +274,31 @@ export class Runner {
     return value;
   }
 
+  async runAdapter(adapter, prompt, context = {}) {
+    const execute = async () => {
+      await switchModelProvider(this.config, {
+        adapter: adapter.name,
+        modelConfig: context.modelConfig,
+        sessionKey: context.sessionKey,
+      });
+      return adapter.run(prompt, context);
+    };
+
+    if (!isModelSwitcherEnabled(this.config)) return execute();
+
+    const previous = this.modelRunTail.catch(() => {});
+    let release = () => {};
+    this.modelRunTail = new Promise((resolve) => {
+      release = resolve;
+    });
+    await previous;
+    try {
+      return await execute();
+    } finally {
+      release();
+    }
+  }
+
   async transcribeAttachments(files) {
     try {
       return await this.stt.transcribeAll(files);
@@ -677,6 +708,28 @@ function metadataValue(metadata, key) {
   return obj && typeof obj === 'object' ? obj[key] : '';
 }
 
+function modelConfigFromMessage(message = {}) {
+  const direct = message.model_config || message.modelConfig;
+  const meta = parseMetadata(message.metadata || message.msg_metadata || message.meta);
+  const cfg = (direct && typeof direct === 'object') ? direct : (meta?.model_config || meta?.modelConfig);
+  if (!cfg || typeof cfg !== 'object') return {};
+  const model = String(cfg.model || cfg.model_id || cfg.modelId || '').trim();
+  const reasoningRaw = String(cfg.reasoning_effort || cfg.reasoningEffort || '').trim().toLowerCase();
+  const reasoningEffort = ['off', 'low', 'medium', 'high', 'xhigh'].includes(reasoningRaw) ? reasoningRaw : '';
+  const adapter = String(cfg.adapter || cfg.agent_type || cfg.agentType || '').trim().toLowerCase();
+  return {
+    ...(model ? { model } : {}),
+    ...(reasoningEffort ? { reasoning_effort: reasoningEffort, reasoningEffort } : {}),
+    ...(adapter ? { adapter } : {}),
+  };
+}
+
+function sessionModelKey(modelConfig = {}) {
+  const model = String(modelConfig.model || 'default').trim().toLowerCase();
+  const effort = String(modelConfig.reasoning_effort || modelConfig.reasoningEffort || '').trim().toLowerCase();
+  return `${model || 'default'}:${effort || 'default'}`.replace(/[^a-z0-9._:-]+/g, '-').slice(0, 96);
+}
+
 function parseMetadata(metadata) {
   if (!metadata) return null;
   let obj = metadata;

package/src/runtime-info.js

@@ -6,11 +6,14 @@ import { execFileSync } from 'node:child_process';
 export function buildRuntimeInfo(config) {
   const workdir = resolveWorkDir(config.workDir);
   const git = gitInfo(workdir);
+  const model = runtimeModel(config);
   return {
     kind: 'wtt-connect',
     agent_id: config.agentId,
     adapter: config.adapter,
     adapters: config.adapters,
+    ...(model ? { model, current_model: model } : {}),
+    ...(config.reasoningEffort ? { reasoning_effort: String(config.reasoningEffort) } : {}),
     workdir,
     workdir_name: path.basename(workdir || ''),
     cwd: safeRealpath(process.cwd()),
@@ -25,6 +28,20 @@ export function buildRuntimeInfo(config) {
   };
 }
 
+function runtimeModel(config) {
+  const explicit = String(config.model || '').trim();
+  if (explicit) return explicit;
+
+  const adapter = String(config.adapter || '').trim().toLowerCase();
+  if (adapter === 'codex') {
+    return String(process.env.OPENAI_MODEL || process.env.CODEX_MODEL || '').trim();
+  }
+  if (adapter === 'claude-code' || adapter === 'claude' || adapter === 'claude_code') {
+    return String(process.env.ANTHROPIC_MODEL || '').trim();
+  }
+  return String(process.env.WTT_CONNECT_MODEL || '').trim();
+}
+
 function resolveWorkDir(workDir) {
   const raw = String(workDir || process.cwd()).trim() || process.cwd();
   return safeRealpath(path.resolve(raw));