march-cli 0.1.41 → 0.1.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "march-cli",
-  "version": "0.1.41",
+  "version": "0.1.42",
   "description": "March CLI — terminal-native coding agent with context reconstruction",
   "type": "module",
   "main": "./src/main.mjs",

package/src/agent/runner.mjs

@@ -18,7 +18,7 @@ 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 { MODEL_STREAM_IDLE_TIMEOUT_CODE, runRunnerTurn } from "./turn/turn-runner.mjs";
 import { beginLoggedTurn } from "./turn/turn-logging.mjs";
 import { appendFastVariants, createFastModelEntry, fromFastEntryModel, isFastProvider } from "./runner/fast-model.mjs";
 import { registerSuperGrokProvider } from "../supergrok/provider.mjs";
@@ -142,6 +142,7 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
         turnLog.endSuccess(result);
         return result;
       } catch (err) {
+        if (err?.code === MODEL_STREAM_IDLE_TIMEOUT_CODE) nextTurnContextMode = "continueExistingPiTranscript";
         notifyTurnEndDetached(turnNotifier, {
           status: "error",
           sessionName: engine.sessionName,

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

@@ -12,6 +12,8 @@ export function createTurnEventState() {
     assistantContextParts: [],
     activeToolContextPart: null,
     toolCalls: [],
+    lastAssistantStopReason: null,
+    lastAssistantErrorMessage: null,
   };
 }
 
@@ -19,6 +21,10 @@ export function handleRunnerSessionEvent(event, { ui, engine, state }) {
   if (event.type === "message_update" && event.assistantMessageEvent) {
     handleAssistantMessageEvent(event.assistantMessageEvent, { ui, state });
   }
+  if (event.type === "message_end" && event.message?.role === "assistant") {
+    state.lastAssistantStopReason = event.message.stopReason ?? null;
+    state.lastAssistantErrorMessage = event.message.errorMessage ?? null;
+  }
   if (event.type === "tool_execution_start") {
     closeAssistantReply({ ui, state });
     appendToolStartContext(state, event.toolName, event.args);

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

@@ -2,6 +2,8 @@ import { formatRecallHints } from "../../memory/markdown-store.mjs";
 import { resolveImageAttachmentReferences } from "../../session/attachment-references.mjs";
 import { closeAssistantReply, compactAssistantContext, createTurnEventState, handleRunnerSessionEvent } from "./turn-events.mjs";
 
+export const MODEL_STREAM_IDLE_TIMEOUT_CODE = "MODEL_STREAM_IDLE_TIMEOUT";
+
 export async function runRunnerTurn({
   prompt,
   userMessage,
@@ -26,17 +28,33 @@ export async function runRunnerTurn({
   const activeSession = sessionBinding.get();
   const turnState = createTurnEventState();
   const midTurnRecallHints = [];
+  const idleWatchdog = createModelStreamIdleWatchdog({ session: activeSession, logger, setPhase });
   ui.turnStart();
   setPhase?.("subscribed");
   logger?.event("turn.ui.start");
 
   const unsubscribe = activeSession.subscribe((event) => {
     logSessionEvent(logger, event);
-    if (event.type === "tool_execution_start") setPhase?.(`tool_running:${event.toolName ?? "unknown"}`);
-    if (event.type === "tool_execution_end") setPhase?.("model_streaming");
-    if (event.type === "auto_retry_start") setPhase?.("retry_wait");
-    if (event.type === "auto_retry_end") setPhase?.("model_streaming");
-    if (event.type === "message_update") setPhase?.("model_streaming");
+    if (event.type === "tool_execution_start") {
+      idleWatchdog.pause();
+      setPhase?.(`tool_running:${event.toolName ?? "unknown"}`);
+    }
+    if (event.type === "tool_execution_end") {
+      setPhase?.("model_streaming");
+      idleWatchdog.arm("tool_execution_end");
+    }
+    if (event.type === "auto_retry_start") {
+      idleWatchdog.pause();
+      setPhase?.("retry_wait");
+    }
+    if (event.type === "auto_retry_end") {
+      setPhase?.("model_streaming");
+      idleWatchdog.arm("auto_retry_end");
+    }
+    if (event.type === "message_update") {
+      setPhase?.("model_streaming");
+      idleWatchdog.arm("message_update");
+    }
     handleRunnerSessionEvent(event, { ui, engine, state: turnState });
     if (event.type === "tool_execution_start") {
       const hints = flushAssistantRecall({ memoryStore, engine, turnState, currentProject });
@@ -59,11 +77,14 @@ export async function runRunnerTurn({
     logger?.event("model.prompt.start", { contextMode });
     try {
       if (contextMode === "rebuild") resetPiMessageHistory(activeSession);
-      await activeSession.prompt(
+      idleWatchdog.arm("model_request");
+      await idleWatchdog.watch(activeSession.prompt(
         contextMode === "continueExistingPiTranscript" ? (userMessage ?? prompt) : prompt,
         attachmentReferences.images.length > 0 ? { images: attachmentReferences.images } : undefined,
-      );
+      ));
+      throwIfAssistantEndedWithError(turnState);
     } finally {
+      idleWatchdog.clear();
       setModelCallKind("model");
       logger?.event("model.prompt.end");
     }
@@ -86,11 +107,70 @@ export async function runRunnerTurn({
     return { draft: turnState.draft };
   } finally {
     logger?.event("turn.ui.end");
+    idleWatchdog.clear();
     ui.turnEnd();
     unsubscribe();
   }
 }
 
+function createModelStreamIdleWatchdog({ session, logger, setPhase }) {
+  const timeoutMs = getModelStreamIdleTimeoutMs();
+  let timer = null;
+  let timedOut = false;
+  let rejectIdle = null;
+  const idlePromise = new Promise((_, reject) => {
+    rejectIdle = reject;
+  });
+
+  return {
+    arm(reason) {
+      if (timeoutMs <= 0 || timedOut) return;
+      clearTimer();
+      timer = setTimeout(() => {
+        timedOut = true;
+        setPhase?.("model_idle_timeout");
+        logger?.event("model.stream.idle_timeout", { timeoutMs, reason });
+        try { session.abortRetry?.(); } catch {}
+        try { session.abort?.(); } catch {}
+        rejectIdle(createModelStreamIdleTimeoutError(timeoutMs, reason));
+      }, timeoutMs);
+    },
+    pause: clearTimer,
+    clear: clearTimer,
+    async watch(promise) {
+      const guarded = Promise.resolve(promise);
+      guarded.catch(() => {});
+      return await Promise.race([guarded, idlePromise]);
+    },
+  };
+
+  function clearTimer() {
+    if (!timer) return;
+    clearTimeout(timer);
+    timer = null;
+  }
+}
+
+function createModelStreamIdleTimeoutError(timeoutMs, reason) {
+  const error = new Error(`Model stream idle timeout after ${timeoutMs}ms (${reason}); aborted the current turn`);
+  error.code = MODEL_STREAM_IDLE_TIMEOUT_CODE;
+  return error;
+}
+
+function getModelStreamIdleTimeoutMs() {
+  const raw = process.env.MARCH_MODEL_STREAM_IDLE_TIMEOUT_MS;
+  if (raw === "0" || raw === "false" || raw === "no") return 0;
+  const parsed = raw ? Number.parseInt(raw, 10) : 18000;
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 18000;
+}
+
+function throwIfAssistantEndedWithError(turnState) {
+  if (turnState.lastAssistantStopReason !== "error") return;
+  const error = new Error(turnState.lastAssistantErrorMessage || "Model provider returned an error");
+  error.code = "MODEL_PROVIDER_ERROR";
+  throw error;
+}
+
 function queueMidTurnRecallHints(session, hints, logger) {
   const content = formatRecallHints("assistant", hints);
   if (!content) return;