mixdog 0.9.1 → 0.9.2

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

@@ -37,13 +37,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 +137,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';
+            }
+        })(),
     }));
 }
 /**
@@ -275,11 +322,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 +368,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 +409,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(',');
 }

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

@@ -0,0 +1,188 @@
+/**
+ * Anthropic effort API alignment (Claude Code effort.ts + configureEffortParams).
+ */
+
+export const EFFORT_LEVELS = Object.freeze(['low', 'medium', 'high', 'max']);
+
+export const EFFORT_BETA_HEADER = 'effort-2025-11-24';
+
+export const LEGACY_EFFORT_BUDGET = Object.freeze({
+    low: 1024,
+    medium: 4096,
+    high: 16384,
+    max: 32768,
+});
+const _LOGGED_EFFORT_NORMALIZATION = new Set();
+const _LOGGED_UNKNOWN_EFFORT = new Set();
+
+function normalizeModelId(model) {
+    return String(model || '').toLowerCase().replace(/\./g, '-');
+}
+
+function parseClaudeVersion(model) {
+    const m = normalizeModelId(model);
+    const triple = m.match(/^claude-(haiku|sonnet|opus|fable)-(\d+)-(\d+)/);
+    if (triple) {
+        return { family: triple[1], major: Number(triple[2]), minor: Number(triple[3]) };
+    }
+    const pair = m.match(/^claude-(sonnet|fable)-(\d+)(?:$|[-@])/);
+    if (pair) {
+        return { family: pair[1], major: Number(pair[2]), minor: null };
+    }
+    return null;
+}
+
+function isLegacyAnthropicReasoningModel(model) {
+    const parsed = parseClaudeVersion(model);
+    if (!parsed) return false;
+    if (parsed.family === 'haiku') return true;
+    if (parsed.family === 'fable') return false;
+    if (parsed.family === 'sonnet' || parsed.family === 'opus') {
+        if (parsed.major < 4) return true;
+        if (parsed.major === 4 && parsed.minor !== null && parsed.minor < 6) return true;
+        return false;
+    }
+    return false;
+}
+
+// @[MODEL LAUNCH]: extend allowlist when new Claude models ship with effort support.
+export function modelSupportsEffort(model) {
+    if (isEnvTruthy(process.env.MIXDOG_ANTHROPIC_ALWAYS_ENABLE_EFFORT)) return true;
+    const m = normalizeModelId(model);
+    if (!m.includes('claude')) return false;
+    if (isLegacyAnthropicReasoningModel(model)) return false;
+    if (m.includes('opus-4-6') || m.includes('sonnet-4-6')) return true;
+    if (m.includes('sonnet-5') || m.includes('fable-5')) return true;
+    if (/^claude-opus-4-(6|7|8)(?:$|[-@])/.test(m)) return true;
+    if (/^claude-opus-5-/.test(m)) return true;
+    if (m.startsWith('claude-')) return true;
+    return false;
+}
+
+// @[MODEL LAUNCH]: extend when new Opus models support max effort.
+export function modelSupportsMaxEffort(model) {
+    const m = normalizeModelId(model);
+    if (/^claude-opus-4-(6|7|8)(?:$|[-@])/.test(m)) return true;
+    if (/^claude-opus-5-/.test(m)) return true;
+    return false;
+}
+
+function isEnvTruthy(value) {
+    const s = String(value ?? '').trim().toLowerCase();
+    return s === '1' || s === 'true' || s === 'yes' || s === 'on';
+}
+
+function logOnce(key, write) {
+    if (_LOGGED_EFFORT_NORMALIZATION.has(key)) return;
+    _LOGGED_EFFORT_NORMALIZATION.add(key);
+    try { write(); } catch { /* ignore */ }
+}
+
+/**
+ * Normalize user/config effort to API levels (low/medium/high/max).
+ * Maps legacy xhigh → max (Opus 4.6+) or high; clamps max on non-Opus models.
+ */
+export function normalizeAnthropicEffortInput(raw, model, logTag = 'anthropic') {
+    if (raw === undefined || raw === null || raw === '') return undefined;
+    let level = String(raw).trim().toLowerCase();
+    if (level === 'extra-high' || level === 'very-high') level = 'xhigh';
+
+    if (level === 'xhigh') {
+        const mapped = modelSupportsMaxEffort(model) ? 'max' : 'high';
+        logOnce(`xhigh:${mapped}`, () => {
+            process.stderr.write(
+                `[${logTag}] effort "xhigh" normalized to "${mapped}" (official levels: ${EFFORT_LEVELS.join(', ')})\n`,
+            );
+        });
+        return mapped;
+    }
+
+    if (level === 'max' && !modelSupportsMaxEffort(model)) {
+        logOnce('max:high', () => {
+            process.stderr.write(`[${logTag}] effort "max" downgraded to "high" for model ${model}\n`);
+        });
+        return 'high';
+    }
+
+    if (EFFORT_LEVELS.includes(level)) return level;
+    return undefined;
+}
+
+export function anthropicEffortUsesOutputConfig(model, opts = {}) {
+    const thinkingBudgetTokens = Number(opts.thinkingBudgetTokens);
+    if (Number.isFinite(thinkingBudgetTokens) && thinkingBudgetTokens > 0) return false;
+    return modelSupportsEffort(model);
+}
+
+export function shouldIncludeEffortBeta(model, opts = {}) {
+    return anthropicEffortUsesOutputConfig(model, opts);
+}
+
+/**
+ * Apply effort / thinking to a Messages API body or SDK params object (mutates).
+ */
+export function applyAnthropicEffortToBody(
+    body,
+    {
+        model,
+        opts = {},
+        maxTokens,
+        clampThinkingBudgetTokens,
+        logTag = 'anthropic',
+    },
+) {
+    if (!body || typeof body !== 'object') return;
+
+    const thinkingBudgetTokens = Number(opts.thinkingBudgetTokens);
+    if (Number.isFinite(thinkingBudgetTokens) && thinkingBudgetTokens > 0) {
+        const budgetTokens = clampThinkingBudgetTokens(thinkingBudgetTokens, maxTokens);
+        if (budgetTokens) {
+            body.thinking = { type: 'enabled', budget_tokens: budgetTokens };
+        }
+        return;
+    }
+
+    const normalized = normalizeAnthropicEffortInput(opts.effort, model, logTag);
+
+    if (modelSupportsEffort(model)) {
+        if (normalized) {
+            const existing = body.output_config && typeof body.output_config === 'object'
+                ? body.output_config
+                : {};
+            body.output_config = { ...existing, effort: normalized };
+        }
+        return;
+    }
+
+    if (normalized && LEGACY_EFFORT_BUDGET[normalized]) {
+        const budgetTokens = clampThinkingBudgetTokens(LEGACY_EFFORT_BUDGET[normalized], maxTokens);
+        if (budgetTokens) {
+            body.thinking = { type: 'enabled', budget_tokens: budgetTokens };
+        }
+        return;
+    }
+
+    if (opts.effort && normalized === undefined && !_LOGGED_UNKNOWN_EFFORT.has(opts.effort)) {
+        _LOGGED_UNKNOWN_EFFORT.add(opts.effort);
+        try {
+            process.stderr.write(
+                `[${logTag}] unknown effort=${opts.effort} ignored (known legacy: ${Object.keys(LEGACY_EFFORT_BUDGET).join(', ')})\n`,
+            );
+        } catch { /* ignore */ }
+    }
+}
+
+export function effortValuesForModel(capabilities, modelId) {
+    const effort = capabilities?.effort;
+    let levels = [...EFFORT_LEVELS];
+    if (!modelSupportsMaxEffort(modelId)) {
+        levels = levels.filter((level) => level !== 'max');
+    }
+    if (!effort) return [];
+    if (effort === true) return levels;
+    const values = levels.filter(
+        (level) => effort?.[level] === true || effort?.[level]?.supported === true,
+    );
+    if (values.length) return values;
+    return effort.supported === true ? levels : [];
+}