march-cli 0.1.0

package/src/agent/runner.mjs

@@ -0,0 +1,266 @@
+import {
+  createAgentSession,
+  ModelRegistry,
+  SettingsManager,
+} from "@earendil-works/pi-coding-agent";
+import { createMarchAuthStorage } from "../auth/storage.mjs";
+import { ContextEngine } from "../context/engine.mjs";
+import { createMarchLifecycleAdapter } from "../extensions/lifecycle-adapter.mjs";
+import { syncPiSessionSidecar } from "../session/sidecar-sync.mjs";
+import { LspService } from "../lsp/service.mjs";
+import { formatRecallHints } from "../memory/markdown-store.mjs";
+import { appendProviderUserMessage, installModelPayloadDumper, replaceProviderContextMessages } from "./model-payload-dumper.mjs";
+import { resolveInitialModel, resolveRunnerSessionManager } from "./runner/runner-init.mjs";
+import { runRunnerCleanup } from "./runner/runner-cleanup.mjs";
+import { createRunnerRuntimeHost } from "./runtime/runner-runtime-host.mjs";
+import { getRunnerSessionStats, syncEngineSessionState } from "./runner/runner-session-state.mjs";
+import { resolveRunnerSessionOptions } from "./session/session-options.mjs";
+import { createSessionBinding } from "./session/session-binding.mjs";
+import { maybeAutoNameSession } from "./session/session-auto-name.mjs";
+import { MARCH_BASE_TOOL_NAMES } from "./tool-names.mjs";
+import { runRunnerTurn } from "./turn/turn-runner.mjs";
+import { appendFastVariants, createFastModelEntry, fromFastEntryModel, isFastProvider } from "./runner/fast-model.mjs";
+import { registerSuperGrokProvider } from "../supergrok/provider.mjs";
+
+export { MARCH_BASE_TOOL_NAMES };
+export { installModelPayloadDumper } from "./model-payload-dumper.mjs";
+export { createDefaultSessionManager, resolveRunnerSessionManager } from "./runner/runner-init.mjs";
+export { getRunnerSessionStats, syncEngineSessionState } from "./runner/runner-session-state.mjs";
+
+export async function createRunner({ cwd, modelId = null, provider = null, providers = {}, stateRoot, ui, memoryStore = null, memoryTools = [], shellRuntime = null, mcpTools = [], mcpInjections = [], mcpClientManager = null, webTools = [], namespace = "", sessionManager = null, useRuntimeHost = false, projectMarchDir = null, syncPiSidecar = false, extensionPaths = [], lifecycleHooks = [], lifecycleDiagnostics = [], authStorage = null, permissionController = null, modelContextDumper = null, turnNotifier = null, onModelPayload = null, createAgentSessionImpl = createAgentSession, createAgentSessionRuntimeImpl, createRuntimeServices, createRuntimeSessionFromServices, maxTurns, trimBatch, serviceTier = null }) {
+  if (!useRuntimeHost && extensionPaths.length > 0) {
+    throw new Error("--extension requires the default pi runtime host path");
+  }
+  const authConfig = authStorage
+    ? { authStorage, hasAuth: true }
+    : createMarchAuthStorage({ provider: provider ?? "deepseek", providers, cwd });
+  if (!authConfig.hasAuth) throw new Error("No providers configured. Run: march provider --config");
+  const resolvedAuth = authConfig.authStorage;
+  const modelRegistry = ModelRegistry.create(resolvedAuth);
+  registerSuperGrokProvider(modelRegistry);
+  const selectedModel = resolveInitialModel({ modelRegistry, provider, modelId });
+  if (!selectedModel) throw new Error("No authenticated models available. Run: march provider --config");
+  provider = selectedModel.provider;
+  modelId = selectedModel.id;
+  const settingsManager = SettingsManager.inMemory({
+    compaction: { enabled: false },
+    retry: { enabled: true, maxRetries: 3, baseDelayMs: 2000 },
+  });
+  const lspService = new LspService({ cwd });
+  const engine = new ContextEngine({ cwd, modelId, provider, namespace, shellRuntime, lspService, injections: mcpInjections, maxTurns, trimBatch });
+  const resolvedSessionManager = resolveRunnerSessionManager(cwd, sessionManager);
+  const sessionBinding = createSessionBinding(null);
+  let currentModelCallKind = "model";
+  let currentPromptForContext = "";
+  let currentTurnContextMode = "rebuild";
+  let nextTurnContextMode = "rebuild";
+  let pendingMidTurnRecallHints = [];
+  let runtimeHost = null;
+  let lifecycleAdapter = null;
+  let _currentFastEntry = null;
+  if (useRuntimeHost) {
+    runtimeHost = await createRunnerRuntimeHost({
+      cwd, stateRoot, provider, modelId,
+      authStorage: resolvedAuth, settingsManager, modelRegistry,
+      sessionManager: resolvedSessionManager, sessionBinding, engine, ui,
+      projectMarchDir,
+      memoryTools, memoryStore, shellRuntime, lspService, mcpTools, webTools,
+      permissionController, extensionPaths,
+      onRebind: (session) => {
+        installModelPayloadDumper(session, modelContextDumper, () => currentModelCallKind, onModelPayload, injectMarchSystemContext);
+        syncEngineSessionState(engine, session);
+      },
+      createAgentSessionRuntimeImpl,
+      createServices: createRuntimeServices,
+      createFromServices: createRuntimeSessionFromServices,
+    });
+  } else {
+    const sessionOptions = resolveRunnerSessionOptions({
+      cwd, provider, modelId, modelRegistry, engine, ui,
+      memoryTools, shellRuntime, lspService, mcpTools, webTools, permissionController,
+      authStorage: resolvedAuth, projectMarchDir,
+    });
+    const { session } = await createAgentSessionImpl({
+      cwd, agentDir: stateRoot, ...sessionOptions,
+      authStorage: resolvedAuth, modelRegistry,
+      sessionManager: resolvedSessionManager, settingsManager,
+    });
+    sessionBinding.set(session);
+    installModelPayloadDumper(session, modelContextDumper, () => currentModelCallKind, onModelPayload, injectMarchSystemContext);
+  }
+  syncEngineSessionState(engine, sessionBinding.get());
+  lifecycleAdapter = createMarchLifecycleAdapter({
+    cwd, projectMarchDir, extensionPaths, sessionBinding, engine,
+    getSessionStats: () => getRunnerSessionStats(sessionBinding.get(), runtimeHost),
+    getRuntimeDiagnostics: () => runtimeHost?.getDiagnostics?.() ?? [],
+    manifestHooks: lifecycleHooks,
+    manifestDiagnostics: lifecycleDiagnostics,
+  });
+  if (serviceTier === "priority" && selectedModel && isFastProvider(selectedModel.provider)) {
+    _currentFastEntry = createFastModelEntry(selectedModel).model;
+  }
+  return {
+    engine,
+    get session() { return sessionBinding.get(); },
+    shellRuntime,
+    async runTurn(prompt, userMessage, { userRecallHints = [], currentProject = "" } = {}) {
+      currentPromptForContext = prompt;
+      const contextMode = nextTurnContextMode;
+      currentTurnContextMode = contextMode;
+      nextTurnContextMode = "rebuild";
+      pendingMidTurnRecallHints = [];
+      try {
+        const result = await runRunnerTurn({
+          prompt, userMessage, options: { userRecallHints, currentProject },
+          sessionBinding, engine, ui, projectMarchDir, memoryStore,
+          setModelCallKind: (kind) => { currentModelCallKind = kind; },
+          onMidTurnRecallHints: (hints) => { pendingMidTurnRecallHints.push(...hints); },
+          syncCurrentPiSidecar,
+          autoNameSession,
+          contextMode,
+        });
+        await notifyTurnEndBestEffort(turnNotifier, {
+          status: "success",
+          sessionName: engine.sessionName,
+          draft: result?.draft ?? "",
+        });
+        return result;
+      } catch (err) {
+        await notifyTurnEndBestEffort(turnNotifier, {
+          status: "error",
+          sessionName: engine.sessionName,
+          errorMessage: err?.message ?? String(err),
+        });
+        throw err;
+      } finally {
+        currentTurnContextMode = "rebuild";
+      }
+    },
+    abort() {
+      const activeSession = sessionBinding.get();
+      activeSession.abortRetry?.();
+      const result = activeSession.abort();
+      nextTurnContextMode = "continueExistingPiTranscript";
+      return result;
+    },
+    async cycleModel() {
+      const result = await sessionBinding.get().cycleModel();
+      _currentFastEntry = null;
+      if (result?.model) {
+        engine.setRuntimeState({
+          modelId: result.model.id, provider: result.model.provider,
+          thinkingLevel: result.thinkingLevel,
+        });
+      }
+      return result;
+    },
+    getCurrentModel() { return _currentFastEntry ?? sessionBinding.get().model; },
+    async setModel(model) {
+      const activeSession = sessionBinding.get();
+      const { baseId, isFast } = fromFastEntryModel(model);
+      const baseEntry = sessionBinding.get().scopedModels.find((e) => e.model.id === baseId);
+      if (!baseEntry) throw new Error(`Model not found: ${baseId}`);
+      await activeSession.setModel(baseEntry.model);
+      _currentFastEntry = isFast ? model : null;
+      engine.setRuntimeState({
+        modelId: activeSession.model?.id ?? baseId,
+        provider: activeSession.model?.provider ?? model.provider,
+        thinkingLevel: activeSession.thinkingLevel,
+      });
+      return model;
+    },
+    getScopedModels() { return appendFastVariants(sessionBinding.get().scopedModels); },
+    getConfiguredProviders() {
+      const configured = Object.values(providers ?? {}).map((profile) => profile?.type).filter(Boolean);
+      const available = (modelRegistry.getAvailable?.() ?? []).map((model) => model.provider);
+      return [...new Set([...configured, ...available])];
+    },
+    getSessionStats() { return getRunnerSessionStats(sessionBinding.get(), runtimeHost); },
+    setSessionName(name) {
+      const activeSession = sessionBinding.get();
+      activeSession.setSessionName?.(name);
+      engine.setSessionName(name);
+      syncCurrentPiSidecar();
+      return engine.sessionName;
+    },
+    canSwitchPiSession() { return Boolean(runtimeHost); },
+    async startNewSession() {
+      if (!runtimeHost) throw new Error("pi runtime host is not enabled");
+      nextTurnContextMode = "rebuild";
+      syncCurrentPiSidecar();
+      const result = await runtimeHost.newSession();
+      if (result?.cancelled) return { cancelled: true };
+      engine.restoreSession({}, [], { replace: true });
+      shellRuntime?.killAll?.();
+      const stats = getRunnerSessionStats(sessionBinding.get(), runtimeHost);
+      return { sessionId: stats.sessionId, sessionFile: stats.sessionFile };
+    },
+    getExtensionDiagnostics() { return runtimeHost?.getDiagnostics?.() ?? []; },
+    getExtensionLifecycleState() { return lifecycleAdapter.getState(); },
+    async switchPiSession(sessionPath) {
+      if (!runtimeHost) throw new Error("pi runtime host is not enabled");
+      nextTurnContextMode = "rebuild";
+      return runtimeHost.switchSession(sessionPath);
+    },
+    cycleThinkingLevel() {
+      const level = sessionBinding.get().cycleThinkingLevel();
+      engine.setRuntimeState({ thinkingLevel: level });
+      return level;
+    },
+    getThinkingLevel() { return sessionBinding.get().thinkingLevel; },
+    setThinkingLevel(level) {
+      const activeSession = sessionBinding.get();
+      activeSession.setThinkingLevel(level);
+      engine.setRuntimeState({ thinkingLevel: activeSession.thinkingLevel });
+      return activeSession.thinkingLevel;
+    },
+    getAvailableThinkingLevels() { return sessionBinding.get().getAvailableThinkingLevels(); },
+    async dispose() {
+      await runRunnerCleanup([
+        () => runtimeHost?.dispose() ?? sessionBinding.get().dispose(),
+        () => shellRuntime?.dispose?.() ?? shellRuntime?.killAll?.(),
+        () => lspService.dispose(),
+        () => mcpClientManager?.disconnectAll?.(),
+      ]);
+    },
+  };
+  function syncCurrentPiSidecar() {
+    return syncPiSessionSidecar({
+      enabled: syncPiSidecar, projectMarchDir, engine,
+      sessionStats: getRunnerSessionStats(sessionBinding.get(), runtimeHost),
+    });
+  }
+  function autoNameSession() {
+    return maybeAutoNameSession({
+      engine,
+      session: sessionBinding.get(),
+      setSessionName: (name) => {
+        const activeSession = sessionBinding.get();
+        activeSession.setSessionName?.(name);
+        engine.setSessionName(name);
+        return engine.sessionName;
+      },
+    });
+  }
+  function injectMarchSystemContext(payload, { kind } = {}) {
+    if (kind !== "user") return payload;
+    let nextPayload = currentTurnContextMode === "continueExistingPiTranscript"
+      ? payload
+      : replaceProviderContextMessages(payload, engine.buildProviderContext(currentPromptForContext));
+    if (_currentFastEntry) nextPayload = { ...nextPayload, service_tier: "priority" };
+    if (pendingMidTurnRecallHints.length > 0) {
+      nextPayload = appendProviderUserMessage(nextPayload, formatRecallHints("assistant", pendingMidTurnRecallHints));
+      pendingMidTurnRecallHints = [];
+    }
+    return nextPayload;
+  }
+}
+
+async function notifyTurnEndBestEffort(turnNotifier, event) {
+  if (!turnNotifier?.notifyTurnEnd) return;
+  try {
+    await turnNotifier.notifyTurnEnd(event);
+  } catch {
+    // Notification must never change turn behavior.
+  }
+}

package/src/agent/runtime/runner-runtime-host.mjs

@@ -0,0 +1,73 @@
+import { createAgentSessionRuntime } from "@earendil-works/pi-coding-agent";
+import { createMarchRuntimeFactory } from "./runtime-factory.mjs";
+import { createRuntimeHost } from "./runtime-host.mjs";
+import { resolveRunnerSessionOptions } from "../session/session-options.mjs";
+import { registerSuperGrokProvider } from "../../supergrok/provider.mjs";
+
+export async function createRunnerRuntimeHost({
+  cwd,
+  stateRoot,
+  provider,
+  modelId,
+  authStorage,
+  settingsManager,
+  modelRegistry,
+  sessionManager,
+  sessionBinding,
+  engine,
+  ui,
+  projectMarchDir = null,
+  memoryTools = [],
+  shellRuntime = null,
+  lspService = null,
+  mcpTools = [],
+  webTools = [],
+  permissionController = null,
+  extensionPaths = [],
+  onRebind = null,
+  createAgentSessionRuntimeImpl = createAgentSessionRuntime,
+  createServices,
+  createFromServices,
+}) {
+  const createRuntime = createMarchRuntimeFactory({
+    agentDir: stateRoot,
+    authStorage,
+    settingsManager,
+    modelRegistry,
+    createServices,
+    createFromServices,
+    resourceLoaderOptions: {
+      additionalExtensionPaths: extensionPaths,
+    },
+    resolveSessionOptions: ({ cwd: sessionCwd, services }) => {
+      const activeModelRegistry = services.modelRegistry ?? modelRegistry;
+      registerSuperGrokProvider(activeModelRegistry);
+      return resolveRunnerSessionOptions({
+        cwd: sessionCwd,
+        provider,
+        modelId,
+        modelRegistry: activeModelRegistry,
+        engine,
+        ui,
+        memoryTools,
+        shellRuntime,
+        lspService,
+        mcpTools,
+        webTools,
+        permissionController,
+        authStorage,
+        projectMarchDir,
+      });
+    },
+  });
+
+  const runtime = await createAgentSessionRuntimeImpl(createRuntime, {
+    cwd,
+    agentDir: stateRoot,
+    sessionManager,
+  });
+
+  const host = createRuntimeHost({ runtime, sessionBinding, onRebind });
+  if (onRebind) await onRebind(runtime.session);
+  return host;
+}

package/src/agent/runtime/runtime-factory.mjs

@@ -0,0 +1,42 @@
+import {
+  createAgentSessionFromServices,
+  createAgentSessionServices,
+} from "@earendil-works/pi-coding-agent";
+
+export function createMarchRuntimeFactory({
+  agentDir,
+  authStorage,
+  settingsManager,
+  modelRegistry,
+  resolveSessionOptions,
+  resourceLoaderOptions = {},
+  createServices = createAgentSessionServices,
+  createFromServices = createAgentSessionFromServices,
+}) {
+  if (typeof resolveSessionOptions !== "function") {
+    throw new Error("resolveSessionOptions is required");
+  }
+
+  return async ({ cwd, sessionManager, sessionStartEvent }) => {
+    const services = await createServices({
+      cwd,
+      agentDir,
+      authStorage,
+      settingsManager,
+      modelRegistry,
+      resourceLoaderOptions,
+    });
+    const sessionOptions = await resolveSessionOptions({ cwd, services });
+    const result = await createFromServices({
+      services,
+      sessionManager,
+      sessionStartEvent,
+      ...sessionOptions,
+    });
+    return {
+      ...result,
+      services,
+      diagnostics: services.diagnostics,
+    };
+  };
+}

package/src/agent/runtime/runtime-host.mjs

@@ -0,0 +1,34 @@
+export function createRuntimeHost({ runtime, sessionBinding, onRebind = null }) {
+  const bindSession = async (session) => {
+    sessionBinding.set(session);
+    if (onRebind) await onRebind(session);
+    return session;
+  };
+
+  runtime.setRebindSession?.(bindSession);
+  sessionBinding.set(runtime.session);
+
+  return {
+    get runtime() {
+      return runtime;
+    },
+    getSession() {
+      return sessionBinding.get();
+    },
+    getDiagnostics() {
+      return runtime.diagnostics ?? [];
+    },
+    async switchSession(sessionPath, options) {
+      return runtime.switchSession(sessionPath, options);
+    },
+    async newSession(options) {
+      return runtime.newSession(options);
+    },
+    async fork(entryId, options) {
+      return runtime.fork(entryId, options);
+    },
+    async dispose() {
+      return runtime.dispose();
+    },
+  };
+}

package/src/agent/session/session-auto-name.mjs

@@ -0,0 +1,41 @@
+const MAX_SESSION_NAME_LENGTH = 60;
+
+export function maybeAutoNameSession({ engine, session, setSessionName }) {
+  if (engine?.sessionName || session?.sessionName) return null;
+  if (!Array.isArray(engine?.turns) || engine.turns.length !== 1) return null;
+  if (typeof setSessionName !== "function") return null;
+
+  const title = generateSessionName(engine.turns[0]);
+  if (!title) return null;
+  return setSessionName(title);
+}
+
+export function generateSessionName(turn) {
+  const text = normalizeTitleSource(turn?.userMessage) || normalizeTitleSource(turn?.assistantMessage);
+  if (!text) return "New session";
+  return truncateTitle(stripPromptNoise(text), MAX_SESSION_NAME_LENGTH) || "New session";
+}
+
+function normalizeTitleSource(value) {
+  return String(value ?? "")
+    .replace(/```[\s\S]*?```/g, " ")
+    .replace(/`([^`]+)`/g, "$1")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function stripPromptNoise(text) {
+  return text
+    .replace(/^[@#>\-\s]+/, "")
+    .replace(/^(please|pls|can you|could you|help me|帮我|请)\s+/i, "")
+    .replace(/[.。!?！？,:;，：；]+$/g, "")
+    .trim();
+}
+
+function truncateTitle(text, maxLength) {
+  if (text.length <= maxLength) return text;
+  const sliced = text.slice(0, maxLength).trimEnd();
+  const lastSpace = sliced.lastIndexOf(" ");
+  if (lastSpace >= Math.floor(maxLength * 0.6)) return sliced.slice(0, lastSpace);
+  return sliced;
+}

package/src/agent/session/session-binding.mjs

@@ -0,0 +1,12 @@
+export function createSessionBinding(initialSession) {
+  let current = initialSession;
+  return {
+    get() {
+      return current;
+    },
+    set(nextSession) {
+      current = nextSession;
+      return current;
+    },
+  };
+}

package/src/agent/session/session-options.mjs

@@ -0,0 +1,46 @@
+import { getModel } from "@earendil-works/pi-ai";
+import { MARCH_BASE_TOOL_NAMES } from "../tool-names.mjs";
+import { createMarchCustomTools } from "../tools.mjs";
+
+export function resolveRunnerSessionOptions({
+  cwd,
+  provider,
+  modelId,
+  modelRegistry,
+  engine,
+  ui,
+  memoryTools = [],
+  shellRuntime = null,
+  lspService = null,
+  mcpTools = [],
+  webTools = [],
+  permissionController = null,
+  authStorage = null,
+  projectMarchDir = null,
+}) {
+  if (engine.cwd !== cwd) {
+    throw new Error(`Runtime session cwd mismatch: engine=${engine.cwd}, session=${cwd}`);
+  }
+
+  const availableModels = modelRegistry.getAvailable?.() ?? [];
+  const model = (provider && modelId ? modelRegistry.find(provider, modelId) : null)
+    ?? availableModels[0]
+    ?? (provider && modelId ? getModel(provider, modelId) : null);
+  if (!model) throw new Error(`Model not found: ${provider}/${modelId}`);
+
+  const customTools = createMarchCustomTools({ cwd, engine, ui, memoryTools, shellRuntime, lspService, mcpTools, webTools, permissionController, authStorage, projectMarchDir });
+  const customToolNames = customTools.map((tool) => tool.name);
+  const tools = [
+    ...customToolNames.filter((name) => name === "read"),
+    ...MARCH_BASE_TOOL_NAMES,
+    ...customToolNames.filter((name) => name !== "read"),
+  ];
+
+  return {
+    model,
+    thinkingLevel: "medium",
+    customTools,
+    tools,
+    scopedModels: availableModels.map((model) => ({ model })),
+  };
+}

package/src/agent/tool-names.mjs

@@ -0,0 +1 @@
+export const MARCH_BASE_TOOL_NAMES = ["grep", "ls"];

package/src/agent/tool-result.mjs

@@ -0,0 +1,3 @@
+export function toolText(text, details = {}) {
+  return { content: [{ type: "text", text }], details };
+}

package/src/agent/tools.mjs

@@ -0,0 +1,54 @@
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { createCommandExecTool } from "./command-exec-tool.mjs";
+import { createContextStatsTool } from "./context-stats-tool.mjs";
+import { createEditFileTool } from "./file-edit-tool.mjs";
+import { createFindTool } from "./find-tool.mjs";
+import { createReadFileTool } from "./read-file-tool.mjs";
+import { toolText } from "./tool-result.mjs";
+import { createShellTools } from "../shell/tools.mjs";
+import { createWebTools } from "../web/tools.mjs";
+import { initImageGen } from "../image-gen/index.mjs";
+import { createSuperGrokTool } from "../supergrok/tool.mjs";
+export function createMarchCustomTools({ cwd, engine, ui, memoryTools = [], shellRuntime = null, lspService = null, mcpTools = [], webTools = [], permissionController = null, authStorage = null, projectMarchDir = null }) {
+  const commandExecTool = createCommandExecTool({ cwd });
+  const contextStatsTool = createContextStatsTool({ engine });
+  const editFileTool = createEditFileTool({ engine, ui, lspService });
+  const findTool = createFindTool({ cwd });
+  const readFileTool = createReadFileTool({ engine });
+
+  const tools = [
+    readFileTool,
+    contextStatsTool,
+    commandExecTool,
+    editFileTool,
+    findTool,
+    ...createShellTools(shellRuntime),
+    ...memoryTools,
+    ...mcpTools,
+    ...webTools,
+    ...(authStorage ? [createSuperGrokTool({ authStorage, projectMarchDir })] : []),
+    ...(authStorage ? initImageGen({ authStorage, projectMarchDir }) : []),
+  ];
+
+  if (!permissionController) return tools;
+
+  return tools.map((tool) => {
+    const execute = tool.execute;
+    if (!execute) return tool;
+    const wrapped = async (toolCallId, params) => {
+      const decision = await permissionController.requestApproval(
+        tool.name,
+        params,
+        ui.requestPermission
+          ? (ctx) => ui.requestPermission(ctx)
+          : null,
+      );
+      if (decision.behavior === "deny") {
+        return toolText(`Permission denied: ${decision.message}`, { error: true, permissionDenied: true });
+      }
+      return execute(toolCallId, params);
+    };
+    return { ...tool, execute: wrapped };
+  });
+}

package/src/agent/turn/turn-events.mjs

@@ -0,0 +1,64 @@
+export function createTurnEventState() {
+  return {
+    draft: "",
+    thinkingText: "",
+    thinkingAccumulator: "",
+    assistantReplyOpen: false,
+  };
+}
+
+export function handleRunnerSessionEvent(event, { ui, engine, state }) {
+  if (event.type === "message_update" && event.assistantMessageEvent) {
+    handleAssistantMessageEvent(event.assistantMessageEvent, { ui, state });
+  }
+  if (event.type === "tool_execution_start") {
+    closeAssistantReply({ ui, state });
+    ui.toolStart(event.toolName, event.args);
+  }
+  if (event.type === "tool_execution_end") {
+    ui.toolEnd(event.toolName, event.isError, event.result);
+  }
+  if (event.type === "auto_retry_start") {
+    ui.retryStart?.({
+      attempt: event.attempt,
+      maxAttempts: event.maxAttempts,
+      delayMs: event.delayMs,
+      errorMessage: event.errorMessage,
+    });
+  }
+  if (event.type === "auto_retry_end") {
+    ui.retryEnd?.({
+      success: event.success,
+      attempt: event.attempt,
+      finalError: event.finalError,
+    });
+  }
+}
+
+export function closeAssistantReply({ ui, state }) {
+  if (!state.assistantReplyOpen) return;
+  ui.assistantReplyEnd?.();
+  state.assistantReplyOpen = false;
+}
+
+function handleAssistantMessageEvent(event, { ui, state }) {
+  if (event.type === "text_delta") {
+    state.draft += event.delta;
+    state.assistantReplyOpen = true;
+    ui.textDelta(event.delta);
+  }
+  if (event.type === "thinking_start") {
+    state.thinkingText = "";
+    ui.thinkingStart();
+  }
+  if (event.type === "thinking_delta") {
+    state.thinkingText += event.delta;
+    ui.thinkingDelta(event.delta);
+  }
+  if (event.type === "thinking_end" && state.thinkingText) {
+    const tokens = Math.round(state.thinkingText.length / 4);
+    ui.thinkingEnd(tokens);
+    state.thinkingAccumulator += state.thinkingText;
+    state.thinkingText = "";
+  }
+}