mixdog 0.9.2 → 0.9.4

package/src/session-runtime/quick-model-rows.mjs

@@ -0,0 +1,170 @@
+// Quick (offline) provider/model picker row builders, extracted from
+// mixdog-session-runtime.mjs. Dependency-injected factory: closes over
+// route/config/search accessors and shared row helpers supplied by the facade.
+import { clean } from './session-text.mjs';
+import { QUICK_SEARCH_MODELS } from './quick-search-models.mjs';
+import { SEARCH_DEFAULT_PROVIDER, SEARCH_DEFAULT_MODEL } from './workflow.mjs';
+
+export function createQuickModelRows({
+  getRoute,
+  getSearchRoute,
+  displayConfig,
+  providerModelCacheRow,
+  providerModelsFromCacheRows,
+  sortProviderModels,
+  modelMetaByRoute,
+  modelMetaKey,
+  normalizeSearchProviderId,
+  normalizeSearchRouteConfig,
+  isSearchCapableProvider,
+  searchCapableFor,
+  currentMainSearchModelMeta,
+}) {
+  function quickProviderModelRows() {
+    const route = getRoute();
+    const pickerConfig = displayConfig();
+    const rows = [];
+    const seen = new Set();
+    const addRoute = (routeLike = {}) => {
+      const provider = clean(routeLike.provider);
+      const model = clean(routeLike.model);
+      if (!provider || !model) return;
+      const key = `${provider}:${model}`;
+      if (seen.has(key)) return;
+      seen.add(key);
+      const row = providerModelCacheRow(provider, {
+        id: model,
+        name: routeLike.modelDisplay || routeLike.display || model,
+        display: routeLike.modelDisplay || routeLike.display || model,
+        latest: routeLike.latest === true,
+        supportsReasoning: !!routeLike.effort,
+        mode: 'chat',
+      });
+      rows.push(row);
+      modelMetaByRoute.set(modelMetaKey(provider, model), row);
+    };
+
+    addRoute(route);
+    for (const preset of pickerConfig.presets || []) addRoute(preset);
+    for (const workflowRoute of Object.values(pickerConfig.workflowRoutes || {})) addRoute(workflowRoute);
+    for (const agentRoute of Object.values(pickerConfig.agents || {})) addRoute(agentRoute);
+    return providerModelsFromCacheRows(rows);
+  }
+
+  function addQuickSearchModel(rows, seen, provider, model) {
+    const providerName = normalizeSearchProviderId(provider);
+    const modelId = clean(model?.id || model);
+    if (!providerName || !modelId || !isSearchCapableProvider(providerName)) return;
+    const key = `${providerName}:${modelId}`;
+    if (seen.has(key)) return;
+    const row = providerModelCacheRow(providerName, {
+      id: modelId,
+      name: model?.name || model?.display || modelId,
+      display: model?.display || model?.name || modelId,
+      contextWindow: model?.contextWindow || null,
+      outputTokens: model?.outputTokens || null,
+      latest: model?.latest === true,
+      supportsWebSearch: true,
+      supportsFunctionCalling: model?.supportsFunctionCalling === true,
+      supportsPromptCaching: model?.supportsPromptCaching === true,
+      supportsReasoning: model?.supportsReasoning === true,
+      reasoningLevels: Array.isArray(model?.reasoningLevels) ? model.reasoningLevels : undefined,
+      reasoningOptions: Array.isArray(model?.reasoningOptions) ? model.reasoningOptions : [],
+      mode: 'chat',
+    });
+    if (row.supportsWebSearch !== true) return;
+    seen.add(key);
+    rows.push({
+      ...row,
+      provider: providerName,
+      searchCapable: true,
+      searchToolType: row.searchToolType || 'web_search',
+    });
+  }
+
+  function addDefaultSearchModel(rows, seen = new Set()) {
+    const route = getRoute();
+    const mainModel = currentMainSearchModelMeta();
+    if (!mainModel || !searchCapableFor(route.provider, mainModel)) return;
+    const key = `${SEARCH_DEFAULT_PROVIDER}:${SEARCH_DEFAULT_MODEL}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    rows.push({
+      id: SEARCH_DEFAULT_MODEL,
+      provider: SEARCH_DEFAULT_PROVIDER,
+      display: 'Default',
+      name: 'Default',
+      description: `Use current main model: ${route.provider}/${route.model}`,
+      supportsWebSearch: true,
+      searchCapable: true,
+      searchToolType: 'web_search',
+      mode: 'chat',
+    });
+  }
+
+  function quickSearchProviderModelRows() {
+    const route = getRoute();
+    const pickerConfig = displayConfig();
+    const rows = [];
+    const seen = new Set();
+    addDefaultSearchModel(rows, seen);
+    for (const [name, providerConfig] of Object.entries(pickerConfig.providers || {})) {
+      const providerName = normalizeSearchProviderId(name);
+      if (!providerConfig?.enabled || !isSearchCapableProvider(providerName)) continue;
+      for (const model of QUICK_SEARCH_MODELS[providerName] || []) {
+        addQuickSearchModel(rows, seen, providerName, model);
+      }
+    }
+    const configuredSearch = normalizeSearchRouteConfig(pickerConfig.searchRoute) || normalizeSearchRouteConfig(getSearchRoute());
+    if (configuredSearch?.provider && configuredSearch?.model) {
+      addQuickSearchModel(rows, seen, configuredSearch.provider, {
+        id: configuredSearch.model,
+        display: configuredSearch.model,
+      });
+    }
+    const mainModel = currentMainSearchModelMeta();
+    if (mainModel && searchCapableFor(route.provider, mainModel)) {
+      addQuickSearchModel(rows, seen, route.provider, {
+        id: route.model,
+        display: route.model,
+      });
+    }
+    return searchModelsFromRows(rows);
+  }
+
+  function searchModelsFromRows(rows) {
+    return sortProviderModels((rows || [])
+      .filter((row) => row.supportsWebSearch === true)
+      .map((row) => ({
+        ...row,
+        provider: normalizeSearchProviderId(row.provider),
+        searchCapable: true,
+        searchToolType: row.searchToolType || 'web_search',
+      })));
+  }
+
+  function searchRowsWithDefault(rows = []) {
+    const out = [];
+    const seen = new Set();
+    addDefaultSearchModel(out, seen);
+    for (const row of rows || []) {
+      const providerName = normalizeSearchProviderId(row?.provider);
+      const modelId = clean(row?.id || row?.model);
+      if (providerName === SEARCH_DEFAULT_PROVIDER && modelId.toLowerCase() === SEARCH_DEFAULT_MODEL) continue;
+      const key = `${providerName}:${modelId}`;
+      if (!providerName || !modelId || seen.has(key)) continue;
+      seen.add(key);
+      out.push(row);
+    }
+    return out;
+  }
+
+  return {
+    quickProviderModelRows,
+    addQuickSearchModel,
+    addDefaultSearchModel,
+    quickSearchProviderModelRows,
+    searchModelsFromRows,
+    searchRowsWithDefault,
+  };
+}

package/src/session-runtime/quick-search-models.mjs

@@ -0,0 +1,46 @@
+// Static quick-pick model catalog surfaced during onboarding / search setup.
+// Pure data extracted from mixdog-session-runtime.mjs.
+
+export const ONBOARDING_VERSION = 1;
+
+export const QUICK_SEARCH_MODELS = Object.freeze({
+  'openai-oauth': [
+    { id: 'gpt-5.5', display: 'GPT-5.5', latest: true, contextWindow: 1000000 },
+    { id: 'gpt-5.4', display: 'GPT-5.4', latest: true, contextWindow: 1000000 },
+    { id: 'gpt-5', display: 'GPT-5', contextWindow: 400000 },
+    { id: 'gpt-4.1', display: 'GPT-4.1', contextWindow: 1000000 },
+  ],
+  openai: [
+    { id: 'gpt-5.5', display: 'GPT-5.5', latest: true, contextWindow: 1000000 },
+    { id: 'gpt-5.4', display: 'GPT-5.4', latest: true, contextWindow: 1000000 },
+    { id: 'gpt-5', display: 'GPT-5', contextWindow: 400000 },
+    { id: 'gpt-4.1', display: 'GPT-4.1', contextWindow: 1000000 },
+    { id: 'gpt-4o', display: 'GPT-4o', contextWindow: 128000 },
+  ],
+  'grok-oauth': [
+    { id: 'grok-4.3', display: 'Grok 4.3', latest: true, contextWindow: 1000000 },
+    { id: 'grok-4.20', display: 'Grok 4.20', contextWindow: 1000000 },
+    { id: 'grok-4', display: 'Grok 4', contextWindow: 256000 },
+  ],
+  xai: [
+    { id: 'grok-4.3', display: 'Grok 4.3', latest: true, contextWindow: 1000000 },
+    { id: 'grok-4.20', display: 'Grok 4.20', contextWindow: 1000000 },
+    { id: 'grok-4', display: 'Grok 4', contextWindow: 256000 },
+  ],
+  gemini: [
+    { id: 'gemini-3-pro', display: 'Gemini 3 Pro', latest: true, contextWindow: 1000000 },
+    { id: 'gemini-2.5-pro', display: 'Gemini 2.5 Pro', contextWindow: 1000000 },
+    { id: 'gemini-2.5-flash', display: 'Gemini 2.5 Flash', contextWindow: 1000000 },
+    { id: 'gemini-2.0-flash', display: 'Gemini 2.0 Flash', contextWindow: 1000000 },
+  ],
+  'anthropic-oauth': [
+    { id: 'claude-opus-4-8', display: 'Claude Opus 4.8', latest: true, contextWindow: 1000000 },
+    { id: 'claude-sonnet-4-6', display: 'Claude Sonnet 4.6', latest: true, contextWindow: 1000000 },
+    { id: 'claude-haiku-4-5-20251001', display: 'Claude Haiku 4.5', contextWindow: 200000 },
+  ],
+  anthropic: [
+    { id: 'claude-opus-4-8', display: 'Claude Opus 4.8', latest: true, contextWindow: 1000000 },
+    { id: 'claude-sonnet-4-6', display: 'Claude Sonnet 4.6', latest: true, contextWindow: 1000000 },
+    { id: 'claude-haiku-4-5-20251001', display: 'Claude Haiku 4.5', contextWindow: 200000 },
+  ],
+});

package/src/session-runtime/session-hooks.mjs

@@ -0,0 +1,93 @@
+// session-hooks.mjs — attaches the standard hook-bus bridge properties
+// (beforeToolHook / afterToolHook / afterToolFailureHook / afterToolBatchHook /
+// preCompactHook / postCompactHook) onto a freshly created session object.
+// Extracted from mixdog-session-runtime.mjs createCurrentSession(): a
+// self-contained cluster whose only couplings are the hooks bus and the
+// facade's hookCommonPayload / currentCwd accessor + the session itself. All
+// properties are non-enumerable/configurable/writable exactly as before so the
+// loop/manager can read them by name without changing session enumeration.
+
+export function attachSessionHooks(session, { hooks, hookCommonPayload, getCwd }) {
+  const currentCwd = () => getCwd();
+  // PreToolUse bridge.
+  Object.defineProperty(session, 'beforeToolHook', {
+    value: (input) => hooks.beforeTool(hookCommonPayload({
+      ...input,
+      session_id: input?.sessionId || input?.session_id || session?.id,
+      tool_name: input?.name || input?.tool_name,
+      tool_input: input?.args || input?.tool_input,
+      tool_use_id: input?.toolCallId || input?.tool_use_id,
+      cwd: input?.cwd || currentCwd(),
+    })),
+    enumerable: false,
+    configurable: true,
+    writable: true,
+  });
+  // PostToolUse: bridge runtime tool completions to the standard hook bus.
+  // dispatch() returns a promise; the loop's afterToolHook caller already
+  // try/catches, so a rejection cannot escape the tool loop.
+  Object.defineProperty(session, 'afterToolHook', {
+    value: (input) => hooks.dispatch('PostToolUse', hookCommonPayload({
+      session_id: input?.sessionId || input?.session_id || session?.id,
+      cwd: input?.cwd || currentCwd(),
+      tool_name: input?.name,
+      tool_input: input?.args,
+      tool_use_id: input?.toolCallId || input?.tool_use_id,
+      tool_response: input?.result,
+    })),
+    enumerable: false,
+    configurable: true,
+    writable: true,
+  });
+  // PostToolUseFailure: dispatched by loop.mjs only when a tool execution
+  // resolved to a failure (thrown-error path or an is_error result). Same
+  // shape as afterToolHook; `result` carries the error text. Best-effort.
+  Object.defineProperty(session, 'afterToolFailureHook', {
+    value: (input) => hooks.dispatch('PostToolUseFailure', hookCommonPayload({
+      session_id: input?.sessionId || input?.session_id || session?.id,
+      cwd: input?.cwd || currentCwd(),
+      tool_name: input?.name,
+      tool_input: input?.args,
+      tool_use_id: input?.toolCallId || input?.tool_use_id,
+      tool_response: input?.result,
+    })),
+    enumerable: false,
+    configurable: true,
+    writable: true,
+  });
+  // PostToolBatch: dispatched by loop.mjs after a full parallel batch of
+  // tool calls resolves and before the next model call. No matcher event.
+  Object.defineProperty(session, 'afterToolBatchHook', {
+    value: (input) => hooks.dispatch('PostToolBatch', hookCommonPayload({
+      session_id: input?.sessionId || input?.session_id || session?.id,
+      cwd: input?.cwd || currentCwd(),
+    })),
+    enumerable: false,
+    configurable: true,
+    writable: true,
+  });
+  // PreCompact / PostCompact: dispatched by manager.mjs/loop.mjs compaction
+  // flow via these session-property hooks (manager has no hooks bus access).
+  // payload { trigger: 'auto' | 'manual' }. Best-effort.
+  Object.defineProperty(session, 'preCompactHook', {
+    value: (input) => hooks.dispatch('PreCompact', hookCommonPayload({
+      session_id: input?.sessionId || input?.session_id || session?.id,
+      cwd: input?.cwd || currentCwd(),
+      trigger: input?.trigger || 'auto',
+    })),
+    enumerable: false,
+    configurable: true,
+    writable: true,
+  });
+  Object.defineProperty(session, 'postCompactHook', {
+    value: (input) => hooks.dispatch('PostCompact', hookCommonPayload({
+      session_id: input?.sessionId || input?.session_id || session?.id,
+      cwd: input?.cwd || currentCwd(),
+      trigger: input?.trigger || 'auto',
+    })),
+    enumerable: false,
+    configurable: true,
+    writable: true,
+  });
+  return session;
+}

package/src/session-runtime/session-text.mjs

@@ -0,0 +1,100 @@
+// Session message/preview text helpers. Pure, no runtime-closure deps.
+
+export function sessionMessageText(content) {
+  if (content == null) return '';
+  if (typeof content === 'string') return content;
+  const parts = Array.isArray(content)
+    ? content
+    : (content && typeof content === 'object' && Array.isArray(content.content) ? content.content : null);
+  if (parts) {
+    return parts.map((part) => {
+      if (typeof part === 'string') return part;
+      return part?.text ?? '';
+    }).filter(Boolean).join('\n');
+  }
+  if (typeof content === 'object' && typeof content.text === 'string') return content.text;
+  try { return JSON.stringify(content); } catch { return String(content); }
+}
+
+export function messageContextText(message) {
+  if (!message || typeof message !== 'object') return '';
+  let text = sessionMessageText(message.content);
+  if (message.role === 'assistant' && Array.isArray(message.toolCalls) && message.toolCalls.length) {
+    try { text += `\n${JSON.stringify(message.toolCalls)}`; }
+    catch { text += `\n[${message.toolCalls.length} tool calls]`; }
+  }
+  if (message.role === 'tool' && message.toolCallId) text += `\n${message.toolCallId}`;
+  return text;
+}
+
+export function isSessionPreviewNoise(text) {
+  const value = String(text || '').trim();
+  return !value
+    || value.startsWith('<system-reminder>')
+    || value.startsWith('</system-reminder>')
+    || /^#\s*permission\b/i.test(value)
+    || /^permission:\s*/i.test(value)
+    || /^cwd:\s*/i.test(value);
+}
+
+export function cleanSessionPreview(text) {
+  return String(text || '')
+    .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/gi, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, 160);
+}
+
+export function clean(value) {
+  return String(value ?? '').trim();
+}
+
+export function hasOwn(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj || {}, key);
+}
+
+export function toolResponseText(result) {
+  if (result && typeof result === 'object' && Array.isArray(result.content)) {
+    return result.content
+      .map((part) => (part?.type === 'text' ? part.text || '' : JSON.stringify(part)))
+      .join('\n');
+  }
+  if (typeof result === 'string') return result;
+  return JSON.stringify(result, null, 2);
+}
+
+export function isEmptyRecallText(value) {
+  const text = String(value || '').trim();
+  return !text || /^\(?no results\)?$/i.test(text) || /^\(?empty memory result\)?$/i.test(text);
+}
+
+export function currentSessionRecallRows(session, query, { limit = 10 } = {}) {
+  const messages = Array.isArray(session?.messages) ? session.messages : [];
+  if (!messages.length) return '(no results)';
+  const terms = [...new Set(String(query || '').toLowerCase().match(/[\p{L}\p{N}_./:-]{2,}/gu) || [])]
+    .filter(Boolean)
+    .slice(0, 16);
+  const max = Math.max(1, Math.min(100, Number(limit) || 10));
+  const rows = [];
+  for (let i = messages.length - 1; i >= 0 && rows.length < max; i -= 1) {
+    const m = messages[i];
+    if (!m || (m.role !== 'user' && m.role !== 'assistant' && m.role !== 'tool')) continue;
+    const text = messageContextText(m).replace(/\s+/g, ' ').trim();
+    if (!text) continue;
+    if (terms.length && !terms.some((term) => text.toLowerCase().includes(term))) continue;
+    rows.push(`[session:${i + 1}] ${m.role}: ${text.slice(0, 1000)}`);
+  }
+  return rows.length ? rows.join('\n') : '(no results)';
+}
+
+export function sessionHasConversationMessages(activeSession) {
+  const messages = Array.isArray(activeSession?.messages) ? activeSession.messages : [];
+  return messages.some((message) => {
+    const role = message?.role;
+    if (role !== 'user' && role !== 'assistant' && role !== 'tool') return false;
+    const text = sessionMessageText(message.content).trim();
+    if (!text && role !== 'assistant') return false;
+    if (role === 'user' && isSessionPreviewNoise(text)) return false;
+    return true;
+  });
+}