mixdog 0.9.1 → 0.9.3

package/src/runtime/agent/orchestrator/{internal-roles.mjs → internal-agents.mjs}

@@ -1,50 +1,50 @@
 /**
- * Internal hidden roles — Mixdog-managed, user-untouchable.
+ * Internal hidden agents — Mixdog-managed, user-untouchable.
  *
- * Unlike public workflow agents, these hidden roles are NEVER exposed to callers of the `agent` tool. They are
+ * Unlike public workflow agents, these hidden agents are NEVER exposed to callers of the `agent` tool. They are
  * invoked only by internal handlers (explore / recall / search) and carry
  * their own system prompt + tool-set policy.
  *
  * Lookup order (agent-dispatch.resolvePresetName):
  *   1. explicit preset arg
  *   2. opts.preset
- *   3. hidden-role registry (defaults/hidden-roles.json + systemFile frontmatter)
+ *   3. hidden-agent registry (defaults/agents.json + systemFile frontmatter)
  *
- * Role definitions live in defaults/hidden-roles.json and the referenced
+ * Agent definitions live in defaults/agents.json and the referenced
  * systemFile markdown frontmatter. Editing those files is a Mixdog source change.
  *
  * The preset names refer to entries seeded in mixdog-config.json (agent.presets)
  * via DEFAULT_PRESETS (see config.mjs). If the user deletes the referenced preset
- * from their config the hidden roles degrade gracefully — `resolvePresetName`
+ * from their config the hidden agents degrade gracefully — `resolvePresetName`
  * returns a name, but session creation will fail with a clear "preset not
  * found" error rather than silently mis-dispatching.
  *
  * Kind classification:
- *   - 'retrieval'   : short-lived hidden retrieval roles (explore).
- *   - 'maintenance' : background-trigger hidden roles (memory cycle, scheduler,
+ *   - 'retrieval'   : short-lived hidden retrieval agents (explore).
+ *   - 'maintenance' : background-trigger hidden agents (memory cycle, scheduler,
  *                     webhook). Receive only their own self section in BP2.
  *
  * Permission classification:
  *   - 'read'       : read-only — apply_patch/shell blocked at loop.mjs runtime
- *                    guard with the same error string public read-only roles see.
- *   - 'read-write' : full tool surface — used by hidden roles that legitimately
+ *                    guard with the same error string public read-only agents see.
+ *   - 'read-write' : full tool surface — used by hidden agents that legitimately
  *                    mutate state (scheduler-task launches commands,
  *                    webhook-handler persists payloads). agent-dispatch honors this
- *                    declaratively instead of forcing every hidden role to 'read'.
+ *                    declaratively instead of forcing every hidden agent to 'read'.
  *
  * Tool schema profile:
- *   - 'none' : no tools exposed; pure transform/classifier roles.
+ *   - 'none' : no tools exposed; pure transform/classifier agents.
  *   - 'read' : read/search/code-navigation tools only.
  *   - 'full' : shared agent tool schema for provider cache reuse.
  *
- * Role-specific instruction metadata (consumed by rules-builder.cjs
+ * Agent-specific instruction metadata (consumed by rules-builder.cjs
  * buildAgentRoleSpecificContent + collect.mjs):
- *   - inboundEvent   : role reports results back to Lead and must carry the
+ *   - inboundEvent   : agent reports results back to Lead and must carry the
  *                      skip-protocol rule (rules/agent/20-skip-protocol.md)
- *                      in its BP2 role-rule block so no-op outputs opt out of the Lead
+ *                      in its BP2 agent-rule block so no-op outputs opt out of the Lead
  *                      inject.
  *   - instructionDir : DATA_DIR subdir whose *.md tree is folded into the
- *                      role's BP4-adjacent user/task data (webhook-handler →
+ *                      agent's BP4-adjacent user/task data (webhook-handler →
  *                      webhooks, scheduler-task → schedules).
  */
 
@@ -56,24 +56,24 @@ import {
   parseMarkdownFrontmatter,
 } from '../../shared/markdown-frontmatter.mjs'
 
-// Resolve the path to defaults/hidden-roles.json once.
+// Resolve the path to defaults/agents.json once.
 const _MIXDOG_ROOT = mixdogRoot()
-const _HIDDEN_ROLES_PATH = (() => {
-  return join(_MIXDOG_ROOT, 'defaults', 'hidden-roles.json')
+const _AGENTS_PATH = (() => {
+  return join(_MIXDOG_ROOT, 'defaults', 'agents.json')
 })()
 
 /** @type {{ mtime: number, map: object } | null} */
-let _hiddenRolesCache = null
+let _hiddenAgentsCache = null
 
 function _mtimeSafe(file) {
   try { return statSync(file).mtimeMs } catch { return 0 }
 }
 
-function _hiddenRolesDependencyMtime() {
-  let mtime = _mtimeSafe(_HIDDEN_ROLES_PATH)
+function _hiddenAgentsDependencyMtime() {
+  let mtime = _mtimeSafe(_AGENTS_PATH)
   try {
-    const raw = JSON.parse(readFileSync(_HIDDEN_ROLES_PATH, 'utf8'))
-    for (const entry of (raw.roles || [])) {
+    const raw = JSON.parse(readFileSync(_AGENTS_PATH, 'utf8'))
+    for (const entry of (raw.agents || [])) {
       const systemFile = typeof entry?.systemFile === 'string' ? entry.systemFile.trim() : ''
       if (!systemFile) continue
       mtime = Math.max(mtime, _mtimeSafe(join(_MIXDOG_ROOT, systemFile)))
@@ -82,7 +82,7 @@ function _hiddenRolesDependencyMtime() {
   return mtime
 }
 
-function _loadHiddenRoleFrontmatter(systemFile) {
+function _loadHiddenAgentFrontmatter(systemFile) {
   const rel = typeof systemFile === 'string' ? systemFile.trim() : ''
   if (!rel) return {}
   try {
@@ -92,8 +92,8 @@ function _loadHiddenRoleFrontmatter(systemFile) {
   }
 }
 
-function _mergeHiddenRoleFrontmatter(entry) {
-  const fm = _loadHiddenRoleFrontmatter(entry.systemFile)
+function _mergeHiddenAgentFrontmatter(entry) {
+  const fm = _loadHiddenAgentFrontmatter(entry.systemFile)
   const merged = { ...entry }
   const permission = normalizeAgentPermissionOrNone(fm.permission)
   if (permission) merged.permission = permission
@@ -111,62 +111,62 @@ function _mergeHiddenRoleFrontmatter(entry) {
 }
 
 /**
- * Read and parse defaults/hidden-roles.json. Throws on missing/malformed.
+ * Read and parse defaults/agents.json. Throws on missing/malformed.
  */
-function _loadHiddenRoles() {
+function _loadHiddenAgents() {
   try {
-    const raw = JSON.parse(readFileSync(_HIDDEN_ROLES_PATH, 'utf8'))
+    const raw = JSON.parse(readFileSync(_AGENTS_PATH, 'utf8'))
     const map = Object.create(null)
-    for (const entry of (raw.roles || [])) {
-      if (entry && entry.name) map[entry.name] = Object.freeze(_mergeHiddenRoleFrontmatter(entry))
+    for (const entry of (raw.agents || [])) {
+      if (entry && entry.agent) map[entry.agent] = Object.freeze(_mergeHiddenAgentFrontmatter(entry))
     }
     return Object.freeze(map)
   } catch (err) {
-    // Fail loudly — a missing or malformed hidden-roles.json breaks dispatch.
-    throw new Error(`[internal-roles] failed to load defaults/hidden-roles.json: ${err.message}`)
+    // Fail loudly — a missing or malformed agents.json breaks dispatch.
+    throw new Error(`[internal-agents] failed to load defaults/agents.json: ${err.message}`)
   }
 }
 
 /**
- * Return the hidden-role map, re-reading from disk when the file mtime has
+ * Return the hidden-agent map, re-reading from disk when the file mtime has
  * changed since the last load. This ensures that BP2 cache rebuilds triggered
- * by a hidden-roles.json modification (tracked via maxMtimeRecursive in
+ * by an agents.json modification (tracked via maxMtimeRecursive in
  * collect.mjs) consume fresh metadata in the same process.
  */
-function _getHiddenRoles() {
+function _getHiddenAgents() {
   try {
-    const mtime = _hiddenRolesDependencyMtime()
-    if (_hiddenRolesCache && mtime <= _hiddenRolesCache.mtime) {
-      return _hiddenRolesCache.map
+    const mtime = _hiddenAgentsDependencyMtime()
+    if (_hiddenAgentsCache && mtime <= _hiddenAgentsCache.mtime) {
+      return _hiddenAgentsCache.map
     }
-    const map = _loadHiddenRoles()
-    _hiddenRolesCache = { mtime, map }
+    const map = _loadHiddenAgents()
+    _hiddenAgentsCache = { mtime, map }
     return map
   } catch (err) {
     // Fail loudly — re-throw with a clear message. A cache hit is never used
     // when statSync fails because the caller expects current data.
-    throw new Error(`[internal-roles] failed to load defaults/hidden-roles.json: ${err.message}`)
+    throw new Error(`[internal-agents] failed to load defaults/agents.json: ${err.message}`)
   }
 }
 
 // Eager validate at module init so startup failures are immediate.
-_getHiddenRoles()
+_getHiddenAgents()
 
 /**
- * Return the hidden-role definition, or null if the name is not internal.
+ * Return the hidden-agent definition, or null if the name is not internal.
  */
-export function getHiddenRole(name) {
+export function getHiddenAgent(name) {
   if (!name) return null
-  return _getHiddenRoles()[name] || null
+  return _getHiddenAgents()[name] || null
 }
 
 /**
- * Resolve permission stamped on a agent session. Hidden roles declared
+ * Resolve permission stamped on a agent session. Hidden agents declared
  * `permission: 'read'` are read-locked — caller opts cannot upgrade them.
  * Other built-in permissions include `none`, `read-write`, `mcp`, and `full`.
  */
-export function resolveAgentSessionPermission(role, callerPermission) {
-  const hidden = getHiddenRole(role)
+export function resolveAgentSessionPermission(agent, callerPermission) {
+  const hidden = getHiddenAgent(agent)
   if (hidden && hidden.permission === 'read') return 'read'
   if (callerPermission != null && callerPermission !== '') return callerPermission
   if (hidden?.permission) return hidden.permission
@@ -176,61 +176,61 @@ export function resolveAgentSessionPermission(role, callerPermission) {
 /**
  * Boolean check — useful for branching inside agent-dispatch / session-manager.
  */
-export function isHiddenRole(name) {
+export function isHiddenAgent(name) {
   if (!name) return false
-  return Object.prototype.hasOwnProperty.call(_getHiddenRoles(), name)
+  return Object.prototype.hasOwnProperty.call(_getHiddenAgents(), name)
 }
 
 /**
- * List all hidden role names. Used by diagnostics / setup UI guards to ensure
- * a user-defined role doesn't collide with an internal one.
+ * List all hidden agent names. Used by diagnostics / setup UI guards to ensure
+ * a user-defined agent doesn't collide with an internal one.
  */
-export function listHiddenRoleNames() {
-  return Object.keys(_getHiddenRoles())
+export function listHiddenAgentNames() {
+  return Object.keys(_getHiddenAgents())
 }
 
 /**
- * List hidden role names matching a given kind ('retrieval' | 'maintenance').
- * Consumed by collect.mjs to drive BP2 role-shard classification dynamically
- * instead of hard-coding role-name sets.
+ * List hidden agent names matching a given kind ('retrieval' | 'maintenance').
+ * Consumed by collect.mjs to drive BP2 agent-shard classification dynamically
+ * instead of hard-coding agent-name sets.
  */
-export function listHiddenRolesByKind(kind) {
+export function listHiddenAgentsByKind(kind) {
   const out = []
-  for (const [name, def] of Object.entries(_getHiddenRoles())) {
+  for (const [name, def] of Object.entries(_getHiddenAgents())) {
     if (def.kind === kind) out.push(name)
   }
   return out
 }
 
 /**
- * Return the agents/<name>.md sections a hidden role shares in its BP2 catalog
+ * Return the agents/<name>.md sections a hidden agent shares in its BP2 catalog
  * (in addition to its own self section). Drives the explorer→worker cache
- * alignment declaratively instead of a hard-coded role-name branch in
- * collect.mjs. Returns [] when the role declares none.
+ * alignment declaratively instead of a hard-coded agent-name branch in
+ * collect.mjs. Returns [] when the agent declares none.
  */
-export function getRoleCatalogShareAgents(name) {
-  const hidden = getHiddenRole(name)
+export function getAgentCatalogShareAgents(name) {
+  const hidden = getHiddenAgent(name)
   if (!hidden || !Array.isArray(hidden.catalogShareAgents)) return []
   return hidden.catalogShareAgents.map((n) => String(n || '').trim()).filter(Boolean)
 }
 
 /**
- * True when a hidden role reports results back to Lead and must carry the
- * skip-protocol rule in its BP2 role-rule block. Replaces the hard-coded
+ * True when a hidden agent reports results back to Lead and must carry the
+ * skip-protocol rule in its BP2 agent-rule block. Replaces the hard-coded
  * INBOUND_EVENT_ROLES set in collect.mjs.
  */
-export function isInboundEventRole(name) {
-  const hidden = getHiddenRole(name)
+export function isInboundEventAgent(name) {
+  const hidden = getHiddenAgent(name)
   return !!(hidden && hidden.inboundEvent === true)
 }
 
 /**
  * Return the DATA_DIR subdir whose *.md tree rides as BP4-adjacent
- * user/task data, or null when the role declares none. Replaces the
+ * user/task data, or null when the agent declares none. Replaces the
  * webhook/scheduler ternary in rules-builder.cjs buildAgentRoleSpecificContent.
  */
-export function getRoleInstructionDir(name) {
-  const hidden = getHiddenRole(name)
+export function getAgentInstructionDir(name) {
+  const hidden = getHiddenAgent(name)
   const dir = hidden && typeof hidden.instructionDir === 'string' ? hidden.instructionDir.trim() : ''
   return dir || null
 }

package/src/runtime/agent/orchestrator/internal-tools.mjs

@@ -15,6 +15,8 @@
  * no-tool role guard) — not a permission check. No gating is needed here.
  */
 
+import { isToolEnvelope, makeToolEnvelope } from './session/tool-envelope.mjs';
+
 let _executor = null;
 let _tools = [];
 let _names = new Set();
@@ -24,35 +26,14 @@ let _bootResolver = null;
 const _bootPromise = new Promise((r) => { _bootResolver = r; });
 export function markBootReady() { if (_bootReady) return; _bootReady = true; _bootResolver(); }
 
-// Per-tool executor overrides. Populated by addInternalTools() for extra
-// internal tools that bypass the main dispatch (tools.json + dispatchTool).
-const _overrides = new Map();
-
 export function setInternalToolsProvider({ executor, tools }) {
     if (typeof executor !== 'function') throw new Error('internal-tools: executor must be a function');
     _executor = executor;
     const base = Array.isArray(tools) ? [...tools] : [];
-    // Re-registration (handleToolCall idempotent fallback) must preserve any
-    // override-backed tools previously registered via addInternalTools.
-    if (_overrides.size > 0) {
-        const baseNames = new Set(base.map(t => t?.name).filter(Boolean));
-        for (const [name] of _overrides) {
-            if (baseNames.has(name)) continue;
-            const existing = _tools.find(t => t?.name === name);
-            if (existing) base.push(existing);
-        }
-    }
     _tools = base;
     _names = new Set(_tools.map(t => t?.name).filter(Boolean));
 }
 
-/**
- * Register additional tools that aren't declared in tools.json — each comes
- * with its own executor.
- *
- * Re-registration is idempotent; later calls overwrite earlier entries with
- * the same name.
- */
 export function getInternalTools() {
     return _tools;
 }
@@ -63,11 +44,6 @@ export function isInternalTool(name) {
 
 export async function executeInternalTool(name, args, callerCtx = {}) {
     if (!_names.has(name)) throw new Error(`internal-tools: "${name}" is not registered`);
-    const override = _overrides.get(name);
-    if (override) {
-        const result = await override(args ?? {}, callerCtx);
-        return _normalize(result);
-    }
     if (!_executor) throw new Error(`internal-tools: executor not initialized (tool=${name})`);
     const result = await _executor(name, args ?? {}, callerCtx);
     return _normalize(result);
@@ -77,6 +53,17 @@ export async function executeInternalTool(name, args, callerCtx = {}) {
 // plain string either way. Worker/module handlers return the MCP-shaped
 // `{ content: [{type:'text', text}] }` envelope directly.
 function _normalize(result) {
+    // General newMessages tool-result channel: a tool may return a
+    // `{ __toolEnvelope, result, newMessages }` envelope (e.g. Skill, whose
+    // body rides ONE injected user message). Preserve the envelope shape, only
+    // normalizing its inner `result` to a string, so the agent loop's central
+    // normalizeToolEnvelope still splits it into stub + injected user body.
+    // Without this guard the envelope object would fall through to
+    // JSON.stringify below and the loop would see the stringified envelope as
+    // the tool_result (body inlined + duplicated, no newMessages).
+    if (isToolEnvelope(result)) {
+        return makeToolEnvelope(_normalize(result.result), result.newMessages);
+    }
     if (result && typeof result === 'object' && Array.isArray(result.content)) {
         return result.content
             .map((c) => (c?.type === 'text' ? c.text || '' : JSON.stringify(c)))

package/src/runtime/agent/orchestrator/mcp/client.mjs

@@ -1,4 +1,5 @@
-import { readFileSync, existsSync, mkdirSync, writeFileSync } from 'fs';
+import { readFileSync, existsSync, mkdirSync } from 'fs';
+import { writeFile } from 'fs/promises';
 import { join } from 'path';
 import { tmpdir } from 'os';
 import { randomUUID } from 'crypto';
@@ -37,13 +38,58 @@ async function loadMcpSdk() {
         import('@modelcontextprotocol/sdk/client/index.js'),
         import('@modelcontextprotocol/sdk/client/stdio.js'),
         import('@modelcontextprotocol/sdk/client/streamableHttp.js'),
-    ]).then(([clientMod, stdioMod, httpMod]) => ({
+        import('@modelcontextprotocol/sdk/client/sse.js'),
+        import('@modelcontextprotocol/sdk/client/websocket.js'),
+    ]).then(([clientMod, stdioMod, httpMod, sseMod, wsMod]) => ({
         Client: clientMod.Client,
         StdioClientTransport: stdioMod.StdioClientTransport,
         StreamableHTTPClientTransport: httpMod.StreamableHTTPClientTransport,
+        SSEClientTransport: sseMod.SSEClientTransport,
+        WebSocketClientTransport: wsMod.WebSocketClientTransport,
     }));
     return mcpSdkPromise;
 }
+/**
+ * Expand `${VAR}` and `${env:VAR}` references in string values using the
+ * provided env map (defaults to process.env). Recurses into arrays/objects.
+ * Unknown vars expand to an empty string. No shell execution.
+ */
+export function expandEnvVars(value, env = process.env) {
+    if (typeof value === 'string') {
+        return value.replace(/\$\{(?:env:)?([A-Za-z_][A-Za-z0-9_]*)\}/g, (_m, name) => {
+            const v = env?.[name];
+            return v == null ? '' : String(v);
+        });
+    }
+    if (Array.isArray(value)) {
+        return value.map((v) => expandEnvVars(v, env));
+    }
+    if (value && typeof value === 'object') {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            out[k] = expandEnvVars(v, env);
+        }
+        return out;
+    }
+    return value;
+}
+/**
+ * Resolve the canonical transport kind for an MCP server config entry.
+ * Returns one of: 'autoDetect' | 'stdio' | 'http' | 'sse' | 'ws'.
+ * Throws when no transport can be determined.
+ */
+export function resolveMcpTransportKind(cfg) {
+    if (cfg?.autoDetect) return 'autoDetect';
+    if (cfg?.type != null && cfg.type !== '') {
+        let t = String(cfg.type).toLowerCase();
+        if (t === 'streamable-http' || t === 'streamablehttp') t = 'http';
+        if (t === 'stdio' || t === 'http' || t === 'sse' || t === 'ws') return t;
+    }
+    if (cfg?.transport === 'http') return 'http';
+    if (cfg?.command) return 'stdio';
+    if (cfg?.url) return 'http';
+    throw new Error(`Invalid config: need autoDetect, type (stdio/http/sse/ws), url (http), or command (stdio)`);
+}
 // --- Public API ---
 /**
  * Connect to MCP servers defined in config.
@@ -92,11 +138,13 @@ export function getMcpServerStatus() {
             name: tool.name,
             description: tool.description || '',
         })),
-        transport: server.cfg?.autoDetect
-                ? 'autoDetect'
-                : server.cfg?.transport === 'http' || server.cfg?.url
-                    ? 'http'
-                    : 'stdio',
+        transport: (() => {
+            try {
+                return resolveMcpTransportKind(server.cfg);
+            } catch {
+                return 'stdio';
+            }
+        })(),
     }));
 }
 /**
@@ -226,7 +274,10 @@ function capMcpOutput(content) {
         const dir = join(tmpdir(), 'mixdog-mcp-output');
         mkdirSync(dir, { recursive: true });
         spillPath = join(dir, `mcp-${Date.now()}-${randomUUID().slice(0, 8)}.txt`);
-        writeFileSync(spillPath, s, 'utf-8');
+        // Fire-and-forget: the spill path is returned to the caller
+        // immediately (below) for later recovery; the write itself must not
+        // block this hot tool-result path.
+        writeFile(spillPath, s, 'utf-8').catch(() => { /* spill best-effort */ });
     } catch { /* spill best-effort */ }
     const spillNote = spillPath
         ? `\n\n... [full output spilled to ${spillPath}] ...`
@@ -275,11 +326,18 @@ export async function disconnectAll() {
     _invalidateMcpToolFieldMemo();
 }
 async function connectServer(name, cfg) {
-    const { Client, StdioClientTransport, StreamableHTTPClientTransport } = await loadMcpSdk();
+    const {
+        Client,
+        StdioClientTransport,
+        StreamableHTTPClientTransport,
+        SSEClientTransport,
+        WebSocketClientTransport,
+    } = await loadMcpSdk();
     const client = new Client({ name: `mixdog-agent/${name}`, version: '1.0.0' });
     let transport;
+    const kind = resolveMcpTransportKind(cfg);
     // Auto-detect: read port from a running service's port file
-    if (cfg.autoDetect) {
+    if (kind === 'autoDetect') {
         const spec = AUTO_DETECT_PORTS[cfg.autoDetect];
         if (!spec)
             throw new Error(`Unknown autoDetect target: "${cfg.autoDetect}"`);
@@ -314,16 +372,40 @@ async function connectServer(name, cfg) {
         transport = new StreamableHTTPClientTransport(new URL(url));
         mcpLog(`[mcp-client] Connecting "${name}" via autoDetect HTTP: ${url}\n`);
     }
-    else if (cfg.transport === 'http' && cfg.url) {
-        transport = new StreamableHTTPClientTransport(new URL(cfg.url));
-        mcpLog(`[mcp-client] Connecting "${name}" via HTTP: ${cfg.url}\n`);
+    else if (kind === 'http') {
+        const url = expandEnvVars(String(cfg.url ?? ''));
+        const headers = expandEnvVars(cfg.headers && typeof cfg.headers === 'object' ? cfg.headers : {});
+        const opts = (headers && Object.keys(headers).length > 0)
+            ? { requestInit: { headers } }
+            : undefined;
+        transport = opts
+            ? new StreamableHTTPClientTransport(new URL(url), opts)
+            : new StreamableHTTPClientTransport(new URL(url));
+        mcpLog(`[mcp-client] Connecting "${name}" via HTTP: ${url}\n`);
+    }
+    else if (kind === 'sse') {
+        const url = expandEnvVars(String(cfg.url ?? ''));
+        const headers = expandEnvVars(cfg.headers && typeof cfg.headers === 'object' ? cfg.headers : {});
+        const opts = (headers && Object.keys(headers).length > 0)
+            ? { requestInit: { headers } }
+            : undefined;
+        transport = opts
+            ? new SSEClientTransport(new URL(url), opts)
+            : new SSEClientTransport(new URL(url));
+        mcpLog(`[mcp-client] Connecting "${name}" via SSE: ${url}\n`);
+    }
+    else if (kind === 'ws') {
+        // WebSocketClientTransport ctor takes only a URL; headers are ignored.
+        const url = expandEnvVars(String(cfg.url ?? ''));
+        transport = new WebSocketClientTransport(new URL(url));
+        mcpLog(`[mcp-client] Connecting "${name}" via WebSocket: ${url}\n`);
     }
-    else if (cfg.command) {
+    else if (kind === 'stdio') {
         transport = new StdioClientTransport({
-            command: cfg.command,
-            args: cfg.args,
+            command: expandEnvVars(String(cfg.command ?? '')),
+            args: Array.isArray(cfg.args) ? expandEnvVars(cfg.args) : cfg.args,
             cwd: cfg.cwd,
-            env: { ...process.env, ...cfg.env },
+            env: { ...process.env, ...expandEnvVars(cfg.env && typeof cfg.env === 'object' ? cfg.env : {}) },
             stderr: cfg.stderr ?? 'pipe',
         });
         transport.stderr?.on?.('data', (chunk) => {
@@ -331,7 +413,7 @@ async function connectServer(name, cfg) {
         });
     }
     else {
-        throw new Error(`Invalid config for "${name}": need autoDetect, url (http), or command (stdio)`);
+        throw new Error(`Invalid config for "${name}": need autoDetect, type (stdio/http/sse/ws), url (http), or command (stdio)`);
     }
     await client.connect(transport);
     const toolsResult = await client.listTools();

package/src/runtime/agent/orchestrator/providers/anthropic-betas.mjs

@@ -1,7 +1,10 @@
+import { EFFORT_BETA_HEADER } from './anthropic-effort.mjs';
+
 export const EXTENDED_CACHE_TTL_BETA_HEADER = 'extended-cache-ttl-2025-04-11';
 export const INTERLEAVED_THINKING_BETA_HEADER = 'interleaved-thinking-2025-05-14';
 export const FAST_MODE_BETA_HEADER = 'fast-mode-2026-02-01';
 export const TOOL_SEARCH_BETA_HEADER = 'advanced-tool-use-2025-11-20';
+export { EFFORT_BETA_HEADER };
 
 export function supportsAnthropicFastMode(model) {
     const id = String(model || '').toLowerCase().replace(/\./g, '-');
@@ -12,6 +15,7 @@ export function buildAnthropicBetaHeaders({
     base = `${INTERLEAVED_THINKING_BETA_HEADER},${EXTENDED_CACHE_TTL_BETA_HEADER}`,
     fastMode = false,
     toolSearch = false,
+    effort = false,
 } = {}) {
     const headers = String(base || '')
         .split(',')
@@ -23,5 +27,8 @@ export function buildAnthropicBetaHeaders({
     if (toolSearch && !headers.includes(TOOL_SEARCH_BETA_HEADER)) {
         headers.push(TOOL_SEARCH_BETA_HEADER);
     }
+    if (effort && !headers.includes(EFFORT_BETA_HEADER)) {
+        headers.push(EFFORT_BETA_HEADER);
+    }
     return headers.join(',');
 }