mixdog 0.9.3 → 0.9.4

package/src/session-runtime/mcp-glue.mjs

@@ -0,0 +1,177 @@
+// MCP config/status/connect glue, extracted from mixdog-session-runtime.mjs.
+// Dependency-injected factory: all live state (config, currentCwd, connect
+// generation/in-flight/failures) is threaded through accessors + a caller-owned
+// `state` object so the facade's teardown/reconnect paths still observe it.
+// Method behavior is byte-for-byte identical; only grouping changes.
+import { resolve } from 'node:path';
+import { clean } from './session-text.mjs';
+import { readProjectMcpServers } from './plugin-mcp.mjs';
+
+export function createMcpGlue({
+  mcpClient,
+  getConfig,
+  getCurrentCwd,
+  state,
+}) {
+  function mcpTransportLabel(cfg = {}) {
+    if (cfg.autoDetect) return `autoDetect:${cfg.autoDetect}`;
+    try {
+      return mcpClient.resolveMcpTransportKind(cfg);
+    } catch {
+      return 'unknown';
+    }
+  }
+
+  // Merge mixdog-config `agent.mcpServers` with project-local `.mcp.json`.
+  // On name collision the project-local `.mcp.json` entry WINS (Claude Code
+  // precedence: project > user config). `sources[name]` records each server's
+  // origin ('config' | 'project') for status reporting.
+  function resolveEffectiveMcpServers() {
+    const config = getConfig();
+    const configured = config?.mcpServers && typeof config.mcpServers === 'object'
+      ? config.mcpServers
+      : {};
+    const project = readProjectMcpServers(getCurrentCwd());
+    const servers = { ...configured, ...project };
+    const sources = {};
+    for (const name of Object.keys(configured)) sources[name] = 'config';
+    for (const name of Object.keys(project)) sources[name] = 'project';
+    return { servers, sources };
+  }
+
+  function mcpStatus() {
+    const { servers: configured, sources } = resolveEffectiveMcpServers();
+    const connected = new Map((mcpClient.getMcpServerStatus?.() || []).map((row) => [row.name, row]));
+    const failures = new Map((state.mcpFailures || []).map((row) => [row.name, row]));
+    const servers = [];
+    for (const [name, cfg] of Object.entries(configured)) {
+      const live = connected.get(name);
+      const fail = failures.get(name);
+      servers.push({
+        name,
+        configured: true,
+        enabled: cfg?.enabled !== false,
+        connected: Boolean(live),
+        status: cfg?.enabled === false ? 'disabled' : live ? 'connected' : fail ? 'failed' : 'disconnected',
+        transport: mcpTransportLabel(cfg),
+        toolCount: live?.toolCount || 0,
+        tools: live?.tools || [],
+        error: fail?.msg || null,
+        source: sources[name] || 'config',
+      });
+      connected.delete(name);
+    }
+    for (const live of connected.values()) {
+      servers.push({ ...live, configured: false, status: 'connected' });
+    }
+    servers.sort((a, b) => String(a.name).localeCompare(String(b.name)));
+    return {
+      servers,
+      configuredCount: Object.keys(configured).length,
+      connectedCount: servers.filter((row) => row.connected).length,
+      failedCount: servers.filter((row) => row.status === 'failed').length,
+    };
+  }
+
+  async function connectConfiguredMcp({ reset = false } = {}) {
+    // Serialize reconnects: boot connect, cwd-change reset, and rapid cwd
+    // switches must never interleave their disconnect/connect phases, or an
+    // older run finishing after a newer reset could re-add stale servers into
+    // the shared client registry. Approach: a generation token + a single
+    // in-flight promise. Each call bumps the generation, waits for any prior
+    // run to finish, then bails if a newer call has superseded it — leaving the
+    // latest requested effective-server-set in the registry.
+    const gen = ++state.mcpConnectGeneration;
+    if (state.mcpConnectInFlight) {
+      try { await state.mcpConnectInFlight; } catch { /* prior run's failures already captured */ }
+    }
+    if (gen !== state.mcpConnectGeneration) return mcpStatus();
+    const run = (async () => {
+      if (reset) await mcpClient.disconnectAll?.();
+      state.mcpFailures = [];
+      const { servers } = resolveEffectiveMcpServers();
+      if (Object.keys(servers).length === 0) return;
+      try {
+        await mcpClient.connectMcpServers(servers);
+      } catch (error) {
+        state.mcpFailures = Array.isArray(error?.failures)
+          ? error.failures
+          : [{ name: 'mcp', msg: error?.message || String(error) }];
+      }
+    })();
+    state.mcpConnectInFlight = run;
+    try {
+      await run;
+    } finally {
+      if (state.mcpConnectInFlight === run) state.mcpConnectInFlight = null;
+    }
+    return mcpStatus();
+  }
+
+  function normalizeMcpServerInput(input = {}) {
+    const currentCwd = getCurrentCwd();
+    const name = clean(input.name).toLowerCase().replace(/[^a-z0-9_.-]+/g, '-').replace(/^-+|-+$/g, '');
+    if (!name) throw new Error('MCP server name is required');
+    const coerceStringRecord = (value) => {
+      if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+      const out = {};
+      for (const [key, val] of Object.entries(value)) {
+        if (val === undefined || val === null) continue;
+        out[String(key)] = String(val);
+      }
+      return Object.keys(out).length > 0 ? out : null;
+    };
+    const withOptionalHeaders = (config) => {
+      const headers = coerceStringRecord(input.headers);
+      if (headers) config.headers = headers;
+      return config;
+    };
+    const url = clean(input.url);
+    const type = clean(input.type).toLowerCase();
+    if (url) {
+      if (type === 'sse') {
+        if (!/^https?:\/\//i.test(url)) throw new Error('MCP URL must start with http:// or https://');
+        return { name, config: withOptionalHeaders({ type: 'sse', url }) };
+      }
+      if (type === 'ws') {
+        if (!/^(?:wss?|https?):\/\//i.test(url)) {
+          throw new Error('MCP WebSocket URL must start with ws://, wss://, http://, or https://');
+        }
+        return { name, config: withOptionalHeaders({ type: 'ws', url }) };
+      }
+      if (type === 'http' || type === 'streamable-http') {
+        if (!/^https?:\/\//i.test(url)) throw new Error('MCP URL must start with http:// or https://');
+        return { name, config: withOptionalHeaders({ type: 'http', url }) };
+      }
+      if (/^wss?:\/\//i.test(url)) {
+        return { name, config: withOptionalHeaders({ type: 'ws', url }) };
+      }
+      if (!/^https?:\/\//i.test(url)) throw new Error('MCP URL must start with http:// or https://');
+      return { name, config: withOptionalHeaders({ type: 'http', url }) };
+    }
+    const command = clean(input.command);
+    if (!command) throw new Error('MCP server command or URL is required');
+    const args = Array.isArray(input.args)
+      ? input.args.map((v) => String(v)).filter(Boolean)
+      : clean(input.args).split(/\s+/).filter(Boolean);
+    const requestedCwd = clean(input.cwd);
+    const cwdForServer = requestedCwd ? resolve(currentCwd, requestedCwd) : currentCwd;
+    const root = resolve(currentCwd);
+    const resolvedCwd = resolve(cwdForServer);
+    if (resolvedCwd !== root && !resolvedCwd.startsWith(`${root}\\`) && !resolvedCwd.startsWith(`${root}/`)) {
+      throw new Error('MCP server cwd must stay under the current project');
+    }
+    const config = { type: 'stdio', command, args, cwd: resolvedCwd };
+    const env = coerceStringRecord(input.env);
+    if (env) config.env = env;
+    return { name, config };
+  }
+
+  return {
+    mcpTransportLabel,
+    resolveEffectiveMcpServers,
+    mcpStatus,
+    connectConfiguredMcp,
+    normalizeMcpServerInput,
+  };
+}

package/src/session-runtime/model-recency.mjs

@@ -0,0 +1,111 @@
+// Provider-model version parsing, recency comparison, sorting, and cache-row
+// construction. Extracted from mixdog-session-runtime.mjs. Pure except for the
+// injected route provider (for sort priority) and searchCapableFor predicate.
+import { clean } from './session-text.mjs';
+
+export function parsedProviderModelVersion(id) {
+  const text = clean(id).toLowerCase();
+  const claude = text.match(/^claude-[a-z]+-(\d+)(?:[-.](\d+))?/);
+  if (claude) return [Number(claude[1]) || 0, Number(claude[2]) || 0];
+  const compact = text.match(/(?:^|[-_])(?:o|gpt|grok|qwen|llama|mistral|gemma|phi|glm)(\d+)(?:\.(\d+))?(?:\.(\d{1,3}))?/);
+  if (compact) return compact.slice(1).filter((v) => v != null).map((v) => Number(v) || 0);
+  const generic = text.match(/(?:^|[-_v])(\d+)(?:\.(\d+))?(?:\.(\d{1,3}))?/);
+  return generic ? generic.slice(1).filter((v) => v != null).map((v) => Number(v) || 0) : [];
+}
+
+export function compareProviderModelVersion(a, b) {
+  const va = parsedProviderModelVersion(a.id || a.display || a.name);
+  const vb = parsedProviderModelVersion(b.id || b.display || b.name);
+  if (va.length === 0 && vb.length === 0) return 0;
+  if (va.length === 0) return 1;
+  if (vb.length === 0) return -1;
+  for (let i = 0; i < Math.max(va.length, vb.length); i += 1) {
+    const delta = (vb[i] || 0) - (va[i] || 0);
+    if (delta) return delta;
+  }
+  return 0;
+}
+
+export function providerModelReleaseTime(model) {
+  if (model?.releaseDate) {
+    const t = Date.parse(model.releaseDate);
+    if (Number.isFinite(t)) return t;
+  }
+  const created = Number(model?.created);
+  if (Number.isFinite(created) && created > 0) {
+    return created < 1_000_000_000_000 ? created * 1000 : created;
+  }
+  const dated = clean(model?.id).match(/(?:^|-)(\d{4})(\d{2})(\d{2})(?:$|-)/);
+  return dated ? (Date.parse(`${dated[1]}-${dated[2]}-${dated[3]}`) || 0) : 0;
+}
+
+export function isClaudeProviderModel(model) {
+  return clean(model?.provider).toLowerCase().includes('anthropic')
+    && /^claude-[a-z]+-/.test(clean(model?.id).toLowerCase());
+}
+
+export function compareProviderModelRecency(a, b) {
+  if (isClaudeProviderModel(a) && isClaudeProviderModel(b)) {
+    if (a.latest !== b.latest) return a.latest ? -1 : 1;
+    const versionDelta = compareProviderModelVersion(a, b);
+    if (versionDelta) return versionDelta;
+    const ta = providerModelReleaseTime(a);
+    const tb = providerModelReleaseTime(b);
+    if (ta !== tb) return tb - ta;
+    return clean(a.display || a.id).localeCompare(clean(b.display || b.id));
+  }
+  const ta = providerModelReleaseTime(a);
+  const tb = providerModelReleaseTime(b);
+  if (ta !== tb) return tb - ta;
+  if (a.latest !== b.latest) return a.latest ? -1 : 1;
+  const versionDelta = compareProviderModelVersion(a, b);
+  if (versionDelta) return versionDelta;
+  return clean(a.display || a.id).localeCompare(clean(b.display || b.id));
+}
+
+export function sortProviderModels(models, primaryProvider = '') {
+  return (models || []).sort((a, b) => {
+    const ar = a.provider === primaryProvider ? 0 : 1;
+    const br = b.provider === primaryProvider ? 0 : 1;
+    if (ar !== br) return ar - br;
+    if (a.provider !== b.provider) return a.provider.localeCompare(b.provider);
+    return compareProviderModelRecency(a, b);
+  });
+}
+
+export function isSelectableLlmModel(model) {
+  const id = clean(model?.id).toLowerCase();
+  const display = clean(model?.display || model?.name).toLowerCase();
+  const mode = clean(model?.mode).toLowerCase();
+  const text = `${id} ${display}`;
+  if (!id) return false;
+  if (mode && !['chat', 'completion', 'responses', 'messages'].includes(mode)) return false;
+  if (/(^|[-_\s])(image|images|video|videos|audio|tts|stt|speech|embed|embedding|embeddings|rerank|reranker|realtime|moderation|imagine)([-_\s]|$)/i.test(text)) return false;
+  if (/(^|[-_\s])(dall[-_\s]?e|sora|imagen)([-_\s]|$)/i.test(text)) return false;
+  return true;
+}
+
+export function providerModelCacheRow(name, m, searchCapableFor) {
+  return {
+    id: m.id,
+    provider: name,
+    display: m.display || m.name || m.id,
+    created: typeof m.created === 'number' ? m.created : null,
+    releaseDate: m.releaseDate || null,
+    contextWindow: m.contextWindow,
+    outputTokens: m.outputTokens || null,
+    family: m.family || null,
+    tier: m.tier || null,
+    latest: m.latest === true,
+    description: m.description || '',
+    supportsVision: m.supportsVision === true,
+    supportsFunctionCalling: m.supportsFunctionCalling === true,
+    supportsWebSearch: searchCapableFor(name, m),
+    supportsPromptCaching: m.supportsPromptCaching === true,
+    supportsReasoning: m.supportsReasoning === true,
+    reasoningLevels: Array.isArray(m.reasoningLevels) ? m.reasoningLevels : undefined,
+    reasoningOptions: Array.isArray(m.reasoningOptions) ? m.reasoningOptions : [],
+    reasoningContentField: m.reasoningContentField || null,
+    mode: m.mode || null,
+  };
+}

package/src/session-runtime/native-search.mjs

@@ -0,0 +1,247 @@
+// Native (provider-hosted) web-search runtime, extracted from
+// mixdog-session-runtime.mjs. Dependency-injected factory pattern: closes over
+// route/searchRoute/config/reg/session accessors supplied by the facade.
+import { clean } from './session-text.mjs';
+
+export function createNativeSearch({
+  getRoute,
+  getSearchRoute,
+  setSearchRoute,
+  getConfig,
+  getSession,
+  getReg,
+  ensureFullConfig,
+  ensureProvidersReady,
+  ensureProviderEnabled,
+  normalizeSearchProviderId,
+  normalizeSearchRouteConfig,
+  isDefaultSearchRouteConfig,
+  isSearchCapableProvider,
+  searchCapableFor,
+}) {
+  function normalizeSearchAllowedDomain(site) {
+    const raw = clean(site);
+    if (!raw) return '';
+    try {
+      return new URL(/^https?:\/\//i.test(raw) ? raw : `https://${raw}`).hostname.toLowerCase();
+    } catch {
+      return raw.replace(/^https?:\/\//i, '').split('/')[0].toLowerCase();
+    }
+  }
+
+  function nativeSearchUserLocation(locale) {
+    if (!locale || typeof locale !== 'object' || Array.isArray(locale)) return null;
+    const location = { type: 'approximate' };
+    for (const key of ['country', 'region', 'city', 'timezone']) {
+      const value = clean(locale[key]);
+      if (value) location[key] = value;
+    }
+    return Object.keys(location).length > 1 ? location : null;
+  }
+
+  function nativeSearchTool(args = {}, toolType = 'web_search', providerId = '') {
+    const providerName = normalizeSearchProviderId(providerId);
+    const domain = normalizeSearchAllowedDomain(args.site);
+    const type = clean(toolType) || 'web_search';
+    const location = nativeSearchUserLocation(args.locale);
+    if (providerName === 'gemini') {
+      return { type: type || 'google_search' };
+    }
+    if (providerName === 'anthropic' || providerName === 'anthropic-oauth') {
+      const tool = {
+        type: 'web_search_20250305',
+        name: 'web_search',
+        max_uses: Math.max(1, Math.min(10, Number(args.maxResults) || 5)),
+      };
+      if (domain) tool.allowed_domains = [domain];
+      if (location) tool.user_location = location;
+      return tool;
+    }
+    if (providerName === 'grok-oauth' || providerName === 'xai') {
+      const tool = { type };
+      if (domain) tool.filters = { allowed_domains: [domain] };
+      return tool;
+    }
+    const tool = {
+      type,
+    };
+    if (type === 'web_search') {
+      tool.search_context_size = clean(args.contextSize) || 'low';
+      if (domain) tool.filters = { allowed_domains: [domain] };
+      if (location) tool.user_location = location;
+    }
+    return tool;
+  }
+
+  function nativeSearchToolTypes(routeLike = {}) {
+    const envToolType = clean(process.env.MIXDOG_NATIVE_SEARCH_TOOL_TYPE);
+    if (envToolType) return [envToolType];
+    const configured = clean(routeLike.toolType);
+    if (configured) return [configured];
+    const providerName = normalizeSearchProviderId(routeLike.provider);
+    if (providerName === 'gemini') return ['google_search'];
+    if (providerName === 'anthropic' || providerName === 'anthropic-oauth') return ['web_search'];
+    if (providerName === 'grok-oauth' || providerName === 'xai') return ['web_search'];
+    return ['web_search', 'web_search_preview'];
+  }
+
+  function currentMainSearchModelMeta() {
+    const route = getRoute();
+    if (!route?.provider || !route?.model) return null;
+    return { ...route, id: route.model, display: route.model, name: route.model };
+  }
+
+  function nativeSearchRoutes() {
+    const route = getRoute();
+    const cfg = ensureFullConfig();
+    const searchRoute = normalizeSearchRouteConfig(cfg.searchRoute) || normalizeSearchRouteConfig(getSearchRoute());
+    setSearchRoute(searchRoute);
+    if (!searchRoute) return [];
+    if (isDefaultSearchRouteConfig(searchRoute)) {
+      const mainModel = currentMainSearchModelMeta();
+      if (!mainModel || !searchCapableFor(route.provider, mainModel)) return [];
+      return [{
+        key: `default\n${route.provider}\n${route.model}`,
+        provider: normalizeSearchProviderId(route.provider),
+        model: route.model,
+        source: 'default-search-route',
+        effort: route.effectiveEffort || route.effort || null,
+        fast: route.fast === true,
+        toolType: searchRoute.toolType || null,
+      }];
+    }
+    const providerName = normalizeSearchProviderId(searchRoute.provider);
+    if (!isSearchCapableProvider(providerName)) return [];
+    return [{
+      key: `${providerName}\n${searchRoute.model}`,
+      provider: providerName,
+      model: searchRoute.model,
+      source: 'search-route',
+      effort: searchRoute.effort || null,
+      fast: searchRoute.fast === true,
+      toolType: searchRoute.toolType || null,
+    }];
+  }
+
+  function nativeSearchMessages(searchArgs = {}) {
+    const prompt = searchArgs.prompt || '';
+    return [
+      {
+        role: 'system',
+        content: [
+          'You are Mixdog native web search.',
+          'Use the hosted web_search tool for current or external facts.',
+          'Answer concisely, cite source URLs, and do not request local tools or file edits.',
+        ].join('\n'),
+      },
+      { role: 'user', content: prompt },
+    ];
+  }
+
+  function flattenNativeSearchSources(result = {}) {
+    const out = [];
+    const add = (source, fallbackTitle = '') => {
+      if (!source || typeof source !== 'object') return;
+      const url = clean(source.url || source.uri || source.href || source.source_url);
+      if (!url) return;
+      out.push({
+        title: clean(source.title || source.query || source.name || fallbackTitle || url),
+        url,
+        snippet: clean(source.snippet || source.text || source.description),
+        source: source.source || 'native-web-search',
+        provider: source.provider || 'native-web-search',
+      });
+    };
+    for (const citation of Array.isArray(result.citations) ? result.citations : []) add(citation);
+    for (const call of Array.isArray(result.webSearchCalls) ? result.webSearchCalls : []) {
+      const action = call?.action || {};
+      for (const source of Array.isArray(action.sources) ? action.sources : []) add(source, action.query || '');
+      if (action.url) add({ url: action.url, title: action.query || '' });
+      for (const url of Array.isArray(action.urls) ? action.urls : []) add({ url, title: action.query || '' });
+    }
+    const seen = new Set();
+    return out.filter((item) => {
+      const key = item.url || `${item.title}\n${item.snippet}`;
+      if (!key || seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+  }
+
+  async function runNativeWebSearch(searchArgs = {}, { signal } = {}) {
+    const route = getRoute();
+    const session = getSession();
+    const reg = getReg();
+    const candidates = nativeSearchRoutes();
+    if (!candidates.length) {
+      if (isDefaultSearchRouteConfig(getSearchRoute())) {
+        throw new Error(`default search route requires the current main model to support native web search (${route?.provider || 'unknown'}/${route?.model || 'unknown'})`);
+      }
+      throw new Error('search route is not configured; open /search to choose a search provider/model');
+    }
+    const errors = [];
+    for (const candidate of candidates) {
+      for (const toolType of nativeSearchToolTypes(candidate)) {
+        try {
+          // Read config lazily: nativeSearchRoutes() above may have run
+          // ensureFullConfig() and replaced the facade config with the
+          // secret-bearing one — an early snapshot would miss those secrets.
+          await ensureProvidersReady(ensureProviderEnabled(getConfig(), candidate.provider));
+          const providerImpl = reg.getProvider(candidate.provider);
+          if (!providerImpl || typeof providerImpl.send !== 'function') {
+            throw new Error(`provider "${candidate.provider}" is not ready`);
+          }
+          const model = candidate.model;
+          const searchTool = nativeSearchTool(searchArgs, toolType, candidate.provider);
+          const startedAt = Date.now();
+          const result = await providerImpl.send(
+            nativeSearchMessages(searchArgs),
+            model,
+            undefined,
+            {
+              signal,
+              role: 'web-search',
+              sessionId: `${session?.id || 'search'}:native-search:${Date.now().toString(36)}`,
+              sourceType: 'native-search',
+              sourceName: 'search',
+              nativeTools: [searchTool],
+              nativeInclude: candidate.provider === 'openai' || candidate.provider === 'openai-oauth'
+                ? ['web_search_call.action.sources']
+                : [],
+              toolChoice: candidate.provider === 'gemini' ? 'auto' : 'required',
+              ...(candidate.effort ? { effort: candidate.effort } : {}),
+              fast: candidate.fast === true,
+              onStageChange: () => {},
+              onStreamDelta: () => {},
+            },
+          );
+          const sources = flattenNativeSearchSources(result);
+          return {
+            content: String(result?.content || '').trim(),
+            provider: candidate.provider,
+            model: result?.model || candidate.model || null,
+            usage: result?.usage || null,
+            citations: sources,
+            webSearchCalls: result?.webSearchCalls || [],
+            durationMs: Date.now() - startedAt,
+          };
+        } catch (err) {
+          errors.push(`${candidate.provider}${candidate.model ? `/${candidate.model}` : ''}/${toolType}: ${err?.message || String(err)}`);
+        }
+      }
+    }
+    throw new Error(`native web search failed: ${errors.join(' | ')}`);
+  }
+
+  return {
+    normalizeSearchAllowedDomain,
+    nativeSearchUserLocation,
+    nativeSearchTool,
+    nativeSearchToolTypes,
+    currentMainSearchModelMeta,
+    nativeSearchRoutes,
+    nativeSearchMessages,
+    flattenNativeSearchSources,
+    runNativeWebSearch,
+  };
+}

package/src/session-runtime/output-styles.mjs

@@ -5,18 +5,20 @@ import { readFileSync, readdirSync } from 'node:fs';
 import { clean } from './session-text.mjs';
 import { readJsonSafe } from './fs-utils.mjs';
 
-const OUTPUT_STYLE_ORDER = ['default', 'simple', 'minimal', 'oneline'];
+const OUTPUT_STYLE_ORDER = ['default', 'simple', 'minimal', 'extreme-minimal'];
 const OUTPUT_STYLE_ALIASES = new Map([
   ['compact', 'default'],
   ['normal', 'default'],
-  ['extreme', 'minimal'],
-  ['extremesimple', 'minimal'],
-  ['extreme-simple', 'minimal'],
-  ['extreme_simple', 'minimal'],
-  ['mono', 'oneline'],
-  ['oneline', 'oneline'],
-  ['one-line', 'oneline'],
-  ['one_line', 'oneline'],
+  ['extreme', 'extreme-minimal'],
+  ['extremesimple', 'extreme-minimal'],
+  ['extreme-simple', 'extreme-minimal'],
+  ['extreme_simple', 'extreme-minimal'],
+  ['extrememinimal', 'extreme-minimal'],
+  ['extreme_minimal', 'extreme-minimal'],
+  ['mono', 'extreme-minimal'],
+  ['oneline', 'extreme-minimal'],
+  ['one-line', 'extreme-minimal'],
+  ['one_line', 'extreme-minimal'],
 ]);
 
 export function normalizeOutputStyleId(value) {