mixdog 0.9.151 → 0.9.153

package/src/standalone/session-runtime-inline-host.mjs

@@ -0,0 +1,258 @@
+/**
+ * In-process session runtime host.
+ *
+ * Sessions remain independent async actors, but share the daemon's V8 isolate
+ * and ESM module cache. Native helpers and explicitly bounded worker pools keep
+ * CPU-heavy parsing/search work off the daemon loop.
+ */
+export function createInlineSessionRuntimeHost({
+  cwd = process.cwd(),
+  log = () => {},
+  loadLocalModule = () => import('../tui/session-local.mjs'),
+  loadAgentGraph = () => Promise.all([
+    import('../runtime/agent/orchestrator/config.mjs'),
+    import('../runtime/agent/orchestrator/providers/registry.mjs'),
+    import('../runtime/agent/orchestrator/agent-runtime/agent-dispatch.mjs'),
+  ]).then(([config, registry, dispatch]) => ({ config, registry, dispatch })),
+  executeAgentControl = null,
+} = {}) {
+  const records = new Map();
+  const recordsBySessionId = new Map();
+  const agentDispatchers = new Map();
+  const agentDispatchRuns = new Map();
+  let nextRuntimeId = 0;
+  let closed = false;
+  let localModulePromise = null;
+  let prewarmPromise = null;
+  let agentGraphPromise = null;
+  let preparedProviderSignature = null;
+  let providerPreparePromise = null;
+
+  function localModule() {
+    localModulePromise ??= Promise.resolve().then(loadLocalModule).catch((error) => {
+      localModulePromise = null;
+      throw error;
+    });
+    return localModulePromise;
+  }
+
+  function agentGraph() {
+    agentGraphPromise ??= Promise.resolve().then(loadAgentGraph).then(
+      (graph) => graph,
+      (error) => {
+        agentGraphPromise = null;
+        throw error;
+      },
+    );
+    return agentGraphPromise;
+  }
+
+  async function prepareAgentProviders() {
+    const { config, registry } = await agentGraph();
+    const providers = config.loadConfig()?.providers || {};
+    let signature = null;
+    try { signature = JSON.stringify(providers); } catch { /* re-prepare each call */ }
+    if (signature !== null && preparedProviderSignature === signature) return;
+    if (providerPreparePromise) {
+      await providerPreparePromise;
+      if (signature !== null && preparedProviderSignature === signature) return;
+      return prepareAgentProviders();
+    }
+    const pending = Promise.resolve()
+      .then(() => registry.initProviders(providers))
+      .then(() => { preparedProviderSignature = signature; });
+    const tracked = pending.finally(() => {
+      if (providerPreparePromise === tracked) providerPreparePromise = null;
+    });
+    providerPreparePromise = tracked;
+    await tracked;
+  }
+
+  function forget(record) {
+    if (!record || !records.delete(record.id)) return;
+    for (const [sessionId, owner] of recordsBySessionId) {
+      if (owner === record) recordsBySessionId.delete(sessionId);
+    }
+  }
+
+  function ownerRuntime(sessionId) {
+    const id = String(sessionId || '').trim();
+    const known = recordsBySessionId.get(id);
+    if (known) return known.runtime;
+    for (const record of records.values()) {
+      const current = String(record.runtime.getState?.()?.sessionId || record.runtime.id || '');
+      if (!current || current !== id) continue;
+      recordsBySessionId.set(id, record);
+      return record.runtime;
+    }
+    return null;
+  }
+
+  async function create(options = {}) {
+    if (closed) throw new Error('session runtime host is closed');
+    const module = await localModule();
+    const runtime = await module.createLocalSessionRuntime({
+      ...options,
+      ...(options.cwd ? {} : { cwd }),
+      ...(typeof executeAgentControl === 'function' ? { executeAgentControl } : {}),
+    });
+    const record = {
+      id: `inline-${process.pid}-${++nextRuntimeId}`,
+      runtime,
+    };
+    records.set(record.id, record);
+    const hintedSessionId = String(options.sessionId || '').trim();
+    if (hintedSessionId) recordsBySessionId.set(hintedSessionId, record);
+
+    const originalDispose = typeof runtime.dispose === 'function'
+      ? runtime.dispose.bind(runtime)
+      : null;
+    runtime.dispose = async (...args) => {
+      try {
+        return await originalDispose?.(...args);
+      } finally {
+        forget(record);
+      }
+    };
+    return runtime;
+  }
+
+  function prewarm() {
+    if (closed) return Promise.reject(new Error('session runtime host is closed'));
+    prewarmPromise ??= localModule().then((module) => Promise.allSettled([
+      module.preloadSessionRuntimeModule?.(),
+      module.preloadAgentLoopRuntime?.(),
+      module.preloadKeychainSecrets?.(),
+    ])).then(() => ({ ready: true }));
+    return prewarmPromise;
+  }
+
+  async function agentDispatch(payload = {}, { signal = null } = {}) {
+    if (closed) throw new Error('session runtime host is closed');
+    const dispatchId = String(payload?.dispatchId || '');
+    if (!dispatchId) throw new Error('agent dispatch id is required');
+    if (agentDispatchRuns.has(dispatchId)) {
+      throw new Error(`agent dispatch ${dispatchId} is already running`);
+    }
+    const controller = new AbortController();
+    const abort = () => {
+      if (controller.signal.aborted) return;
+      try { controller.abort(signal?.reason); } catch { try { controller.abort(); } catch {} }
+    };
+    if (signal?.aborted) abort();
+    else signal?.addEventListener?.('abort', abort, { once: true });
+    agentDispatchRuns.set(dispatchId, controller);
+    try {
+      if (controller.signal.aborted) throw controller.signal.reason || new Error('agent dispatch canceled');
+      const agent = String(payload.agent || '');
+      const { dispatch } = await agentGraph();
+      await prepareAgentProviders();
+      if (controller.signal.aborted) throw controller.signal.reason || new Error('agent dispatch canceled');
+      let dispatcher = agentDispatchers.get(agent);
+      if (!dispatcher) {
+        dispatcher = dispatch.makeAgentDispatch({
+          agent,
+          ...(payload.options && typeof payload.options === 'object' ? payload.options : {}),
+        });
+        agentDispatchers.set(agent, dispatcher);
+      }
+      const params = payload.params && typeof payload.params === 'object' ? payload.params : {};
+      const prompt = String(params.prompt ?? '');
+      return await dispatcher({
+        prompt,
+        preset: params.preset || undefined,
+        cwd: typeof params.cwd === 'string' && params.cwd ? params.cwd : undefined,
+        parentSignal: controller.signal,
+        ...(Number.isFinite(Number(params.idleTimeoutMs)) && Number(params.idleTimeoutMs) > 0
+          ? { idleTimeoutMs: Number(params.idleTimeoutMs) }
+          : {}),
+      });
+    } finally {
+      signal?.removeEventListener?.('abort', abort);
+      agentDispatchRuns.delete(dispatchId);
+    }
+  }
+
+  return {
+    create,
+    prewarm,
+    agentDispatch,
+    async agentControl(args = {}, context = {}) {
+      if (closed) throw new Error('session runtime host is closed');
+      if (typeof executeAgentControl === 'function') {
+        return await executeAgentControl(args, context);
+      }
+      throw new Error('canonical Agent control is unavailable');
+    },
+    notifySessionCompletion(ownerSessionId, text, meta = {}) {
+      const runtime = ownerRuntime(ownerSessionId);
+      return runtime?.deliverToolCompletion?.(
+        String(ownerSessionId || ''),
+        String(text || ''),
+        meta,
+      ) === true;
+    },
+    async agentSessionAction(sessionId, action, args = []) {
+      void sessionId;
+      void action;
+      void args;
+      throw new Error('Agent sessions are owned by the canonical session service');
+    },
+    refreshRuntimeWorkload() {
+      return Promise.resolve(this.workloads);
+    },
+    subscribeAgentSessionStates(listener) {
+      void listener;
+      return () => {};
+    },
+    agentSessionState(sessionId) {
+      void sessionId;
+      return null;
+    },
+    get workloads() {
+      const memory = process.memoryUsage();
+      return {
+        mode: 'in-process',
+        refreshedAt: Date.now(),
+        shardCount: 0,
+        shards: [],
+        worker: {
+          pid: process.pid,
+          runtimes: records.size,
+          memory: {
+            rss: memory.rss,
+            heapTotal: memory.heapTotal,
+            heapUsed: memory.heapUsed,
+            external: memory.external,
+          },
+        },
+      };
+    },
+    async close(reason = 'session runtime host closed') {
+      if (closed) return;
+      closed = true;
+      for (const controller of agentDispatchRuns.values()) {
+        try { controller.abort(new Error(reason)); } catch {}
+      }
+      agentDispatchRuns.clear();
+      const active = [...records.values()];
+      await Promise.allSettled(active.map((record) => record.runtime.dispose?.(reason)));
+      records.clear();
+      recordsBySessionId.clear();
+    },
+    get status() {
+      return {
+        mode: 'in-process',
+        active: !closed,
+        worker: {
+          pid: process.pid,
+          pids: [process.pid],
+          runtimes: records.size,
+        },
+        shards: [],
+        shardCount: 0,
+        providerCooldown: null,
+      };
+    },
+  };
+}

package/src/standalone/session-runtime-inline-host.test.mjs

@@ -0,0 +1,385 @@
+import assert from 'node:assert/strict';
+import { mkdirSync, mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+
+import {
+  drainSessionStore,
+  saveSessionAsync,
+  saveSessionAsyncDeferred,
+} from '../runtime/agent/orchestrator/session/store.mjs';
+import { createInlineSessionRuntimeHost } from './session-runtime-inline-host.mjs';
+
+async function waitFor(predicate, label, timeoutMs = 5_000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (predicate()) return;
+    await new Promise((resolve) => setTimeout(resolve, 10));
+  }
+  throw new Error(`timed out waiting for ${label}`);
+}
+
+function createFakeLocalModule(events) {
+  return {
+    async createLocalSessionRuntime(options = {}) {
+      events.push(['create', options]);
+      const listeners = new Set();
+      const state = { sessionId: options.sessionId || null };
+      return {
+        get id() { return state.sessionId; },
+        getState: () => state,
+        subscribe(listener) {
+          listeners.add(listener);
+          return () => listeners.delete(listener);
+        },
+        async resume(sessionId) {
+          events.push(['resume', sessionId]);
+          state.sessionId = sessionId;
+          return true;
+        },
+        async submitAsync(prompt, options) {
+          events.push(['submit', prompt, options]);
+          return true;
+        },
+        deliverToolCompletion(sessionId, text, meta) {
+          events.push(['completion', sessionId, text, meta]);
+          return state.sessionId === sessionId;
+        },
+        async dispose(reason) {
+          events.push(['dispose', reason]);
+        },
+        async agentControl(args) {
+          return JSON.stringify(args);
+        },
+      };
+    },
+    async preloadSessionRuntimeModule() {
+      events.push(['prewarm', 'runtime']);
+    },
+    async preloadAgentLoopRuntime() {
+      events.push(['prewarm', 'agent-loop']);
+    },
+    async preloadKeychainSecrets() {
+      events.push(['prewarm', 'keychain']);
+    },
+  };
+}
+
+function deferred() {
+  let resolve;
+  const promise = new Promise((accept) => { resolve = accept; });
+  return { promise, resolve };
+}
+
+test('inline host keeps session actors in the daemon process and releases them', async () => {
+  const events = [];
+  const host = createInlineSessionRuntimeHost({
+    cwd: 'C:\\project',
+    loadLocalModule: async () => createFakeLocalModule(events),
+    executeAgentControl: async (args) => JSON.stringify(args),
+  });
+
+  const first = await host.create({ sessionId: 'session-a' });
+  const second = await host.create({ sessionId: 'session-b', cwd: 'D:\\other' });
+
+  assert.equal(host.status.mode, 'in-process');
+  assert.equal(host.status.worker.pid, process.pid);
+  assert.equal(host.status.worker.runtimes, 2);
+  assert.equal(events[0][1].cwd, 'C:\\project');
+  assert.equal(events[1][1].cwd, 'D:\\other');
+  assert.equal(
+    await host.agentControl({ type: 'list' }, { callerSessionId: 'session-a' }),
+    '{"type":"list"}',
+  );
+  const completionMeta = { type: 'agent_task_result', execution_id: 'task-agent-1' };
+  assert.equal(host.notifySessionCompletion(
+    'session-a',
+    'Agent handoff',
+    completionMeta,
+  ), true);
+  assert.deepEqual(
+    events.find(([type]) => type === 'completion'),
+    ['completion', 'session-a', 'Agent handoff', completionMeta],
+  );
+
+  await first.dispose('idle');
+  assert.equal(host.status.worker.runtimes, 1);
+  await host.close('done');
+  assert.equal(host.status.active, false);
+  assert.equal(host.status.worker.runtimes, 0);
+  assert.equal(events.some(([type, reason]) => type === 'dispose' && reason === 'done'), true);
+  void second;
+});
+
+test('inline host prewarm deliberately leaves the memory process cold', async () => {
+  const events = [];
+  const host = createInlineSessionRuntimeHost({
+    loadLocalModule: async () => createFakeLocalModule(events),
+  });
+
+  await host.prewarm();
+  await host.prewarm();
+
+  assert.deepEqual(
+    events.filter(([type]) => type === 'prewarm').map(([, target]) => target).sort(),
+    ['agent-loop', 'keychain', 'runtime'],
+  );
+  await host.close('done');
+});
+
+test.skip('retired Agent session surface is not part of the canonical session host', async () => {
+  const events = [];
+  const session = {
+    id: 'agent-a',
+    provider: 'test-provider',
+    model: 'test-model',
+    cwd: 'E:\\agent-project',
+  };
+  const host = createInlineSessionRuntimeHost({
+    loadLocalModule: async () => createFakeLocalModule(events),
+    loadAgentSessionManager: async () => ({
+      getSession: (sessionId) => sessionId === session.id ? session : null,
+    }),
+  });
+
+  assert.equal(host.agentSessionState(session.id), null);
+  assert.equal(await host.agentSessionAction(session.id, 'submitAsync', [
+    'hello agent',
+    { id: 'desktop-agent-message' },
+  ]), true);
+  assert.equal(host.agentSessionState(session.id)?.sessionId, session.id);
+  assert.deepEqual(events[0], ['create', {
+    provider: session.provider,
+    model: session.model,
+    cwd: session.cwd,
+    toolMode: 'full',
+    desktopSession: null,
+  }]);
+  assert.deepEqual(events[1], ['resume', session.id]);
+  assert.deepEqual(events[2], [
+    'submit',
+    'hello agent',
+    { id: 'desktop-agent-message' },
+  ]);
+
+  await host.close('done');
+  assert.equal(events.some(([type, reason]) => type === 'dispose' && reason === 'done'), true);
+});
+
+test.skip('retired Agent store projection is not part of the canonical session host', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'mixdog-inline-agent-publication-'));
+  const previous = process.env.MIXDOG_DATA_DIR;
+  process.env.MIXDOG_DATA_DIR = root;
+  mkdirSync(join(root, 'sessions'));
+  const host = createInlineSessionRuntimeHost();
+  const unsubscribe = host.subscribeAgentSessionStates(() => {});
+  const session = {
+    id: `sess_inline_agent_${process.pid}_${Date.now()}`,
+    owner: 'agent',
+    agent: 'worker',
+    provider: 'test-provider',
+    model: 'test-model',
+    cwd: 'C:\\project',
+    status: 'running',
+    messages: [{ role: 'user', content: 'Reply exactly DONE' }],
+    generation: 0,
+    closed: false,
+  };
+
+  try {
+    await new Promise((resolve) => setImmediate(resolve));
+    await saveSessionAsync(session, { expectedGeneration: session.generation });
+    await waitFor(
+      () => host.agentSessionState(session.id)?.items?.length === 1,
+      'initial Agent projection',
+    );
+
+    session.status = 'idle';
+    session.messages.push({ role: 'assistant', content: 'DONE' });
+    await saveSessionAsyncDeferred(session, { expectedGeneration: session.generation });
+    await waitFor(
+      () => host.agentSessionState(session.id)?.items?.length === 2,
+      'terminal Agent projection',
+    );
+
+    const snapshot = host.agentSessionState(session.id);
+    assert.equal(Boolean(snapshot.busy), false);
+    assert.equal(snapshot.items[1].kind, 'assistant');
+    assert.equal(snapshot.items[1].text, 'DONE');
+  } finally {
+    unsubscribe();
+    await host.close('done');
+    drainSessionStore();
+    if (previous === undefined) delete process.env.MIXDOG_DATA_DIR;
+    else process.env.MIXDOG_DATA_DIR = previous;
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test.skip('retired Agent dispatch projector is not part of the canonical session host', async () => {
+  const allowRequesting = deferred();
+  const allowReasoning = deferred();
+  const allowReset = deferred();
+  const allowTerminal = deferred();
+  const allowCommit = deferred();
+  const resetAcks = [];
+  const session = {
+    id: `sess_inline_agent_stream_${process.pid}_${Date.now()}`,
+    owner: 'agent',
+    agent: 'worker',
+    provider: 'test-provider',
+    model: 'test-model',
+    cwd: 'C:\\project',
+    messages: [{ role: 'user', content: 'Reply exactly DONE' }],
+  };
+  const host = createInlineSessionRuntimeHost({
+    loadAgentGraph: async () => ({
+      config: { loadConfig: () => ({ providers: {} }) },
+      registry: { initProviders: async () => {} },
+      dispatch: {
+        makeAgentDispatch: () => async (call) => {
+          const requiredCallbacks = [
+            'onSessionStart',
+            'onStageChange',
+            'onReasoningDelta',
+            'onTextDelta',
+            'onTextReset',
+            'onAssistantMessageCommitted',
+          ];
+          for (const name of requiredCallbacks) {
+            if (typeof call?.[name] !== 'function') {
+              throw new TypeError(`missing formal Agent projection callback ${name}`);
+            }
+          }
+
+          call.onSessionStart(session);
+          call.onStageChange(session, 'requesting');
+          await allowRequesting.promise;
+
+          call.onStageChange(session, 'streaming');
+          call.onReasoningDelta(session, 'inspect first');
+          await allowReasoning.promise;
+
+          call.onTextDelta(session, 'PARTIAL');
+          await allowReset.promise;
+          resetAcks.push(call.onTextReset(session, { chars: 99 }));
+          resetAcks.push(call.onTextReset(session, { chars: 3 }));
+          await allowTerminal.promise;
+          resetAcks.push(call.onTextReset(session, { chars: 4 }));
+          call.onTextDelta(session, 'DONE');
+          session.messages.push({ role: 'assistant', content: 'DONE' });
+          call.onAssistantMessageCommitted(session);
+          await allowCommit.promise;
+          return 'DONE';
+        },
+      },
+    }),
+  });
+
+  try {
+    const dispatch = host.agentDispatch({
+      dispatchId: `dispatch_${session.id}`,
+      agent: 'worker',
+      params: { prompt: 'Reply exactly DONE' },
+    });
+    await waitFor(
+      () => {
+        const snapshot = host.agentSessionState(session.id);
+        return snapshot?.busy === true
+          && snapshot?.spinner?.mode === 'requesting'
+          && snapshot?.agentStage === 'requesting';
+      },
+      'requesting Agent stage',
+    );
+    const requesting = host.agentSessionState(session.id);
+    assert.equal(requesting.thinking, null);
+    assert.equal(requesting.streamingTail, null);
+    assert.equal(requesting.items[0].kind, 'user');
+    assert.equal(requesting.items[0].text, 'Reply exactly DONE');
+
+    allowRequesting.resolve();
+    await waitFor(
+      () => {
+        const snapshot = host.agentSessionState(session.id);
+        return snapshot?.thinking === 'inspect first'
+          && snapshot?.spinner?.mode === 'thinking'
+          && snapshot?.spinner?.thinking === true
+          && snapshot?.agentStage === 'streaming';
+      },
+      'reasoning Agent frame',
+    );
+    const reasoning = host.agentSessionState(session.id);
+    assert.equal(reasoning.busy, true);
+    assert.equal(reasoning.streamingTail, null);
+
+    allowReasoning.resolve();
+    await waitFor(
+      () => host.agentSessionState(session.id)?.streamingTail?.text === 'PARTIAL',
+      'partial Agent assistant frame',
+    );
+    const partial = host.agentSessionState(session.id);
+    assert.equal(partial.busy, true);
+    assert.equal(partial.thinking, null);
+    assert.equal(partial.spinner.mode, 'responding');
+    assert.equal(partial.agentStage, 'streaming');
+    assert.equal(partial.items[0].kind, 'user');
+    assert.equal(partial.items[0].text, 'Reply exactly DONE');
+
+    allowReset.resolve();
+    await waitFor(
+      () => host.agentSessionState(session.id)?.streamingTail?.text === 'PART',
+      'exact Agent text retraction',
+    );
+    assert.deepEqual(resetAcks, [false, true]);
+
+    allowTerminal.resolve();
+    await waitFor(
+      () => {
+        const snapshot = host.agentSessionState(session.id);
+        const assistant = snapshot?.items
+          ?.filter((item) => item.kind === 'assistant')
+          .map((item) => item.text);
+        return snapshot?.busy === true
+          && snapshot?.streamingTail == null
+          && assistant?.length === 1
+          && assistant[0] === 'DONE';
+      },
+      'committed Agent assistant transcript before settle',
+    );
+    const committed = host.agentSessionState(session.id);
+    assert.equal(committed.busy, true);
+    assert.equal(committed.streamingTail, null);
+    assert.equal(committed.thinking, null);
+    assert.equal(committed.spinner?.mode, 'responding');
+    assert.deepEqual(
+      committed.items.filter((item) => item.kind === 'assistant').map((item) => item.text),
+      ['DONE'],
+    );
+
+    allowCommit.resolve();
+    assert.equal(await dispatch, 'DONE');
+    await waitFor(
+      () => host.agentSessionState(session.id)?.busy === false,
+      'terminal Agent callback projection',
+    );
+    const terminal = host.agentSessionState(session.id);
+    assert.deepEqual(resetAcks, [false, true, true]);
+    assert.equal(terminal.spinner, null);
+    assert.equal(terminal.streamingTail, null);
+    assert.equal(terminal.thinking, null);
+    assert.equal(Object.hasOwn(terminal, 'agentStage'), false);
+    assert.deepEqual(
+      terminal.items.filter((item) => item.kind === 'assistant').map((item) => item.text),
+      ['DONE'],
+    );
+  } finally {
+    allowRequesting.resolve();
+    allowReasoning.resolve();
+    allowReset.resolve();
+    allowTerminal.resolve();
+    allowCommit.resolve();
+    await host.close('done');
+  }
+});
+