shennian 0.2.86 → 0.2.88

package/dist/src/session/handlers/chat.js

@@ -49,6 +49,18 @@ function buildRelayAgentPayload(event, sessionId, extra = {}) {
     }
     return { ...event, sessionId, ...extra };
 }
+const SESSION_ACTIVITY_HEARTBEAT_INTERVAL_MS = 30_000;
+function runPhaseFromAgentEvent(event) {
+    if (event.state === 'heartbeat')
+        return event.runPhase ?? null;
+    if (event.state === 'tool-call' || event.state === 'tool-result')
+        return 'tool_running';
+    if (event.state === 'delta')
+        return event.thinking ? 'thinking' : 'streaming_text';
+    if (event.state === 'init' || event.state === 'start')
+        return 'thinking';
+    return null;
+}
 function formatAgentSendFailure(agentType, err) {
     const raw = err instanceof Error ? err.message : String(err);
     if (agentType === 'pi' &&
@@ -132,8 +144,6 @@ function normalizeExternalChannel(value) {
         noRestore: raw.noRestore === undefined || raw.noRestore === null ? null : Boolean(raw.noRestore),
         downloadAttachments: raw.downloadAttachments === undefined || raw.downloadAttachments === null ? null : Boolean(raw.downloadAttachments),
         downloadAttachmentsDir: typeof raw.downloadAttachmentsDir === 'string' ? raw.downloadAttachmentsDir : null,
-        cloudOcrUrl: typeof raw.cloudOcrUrl === 'string' ? raw.cloudOcrUrl : null,
-        cloudOcrMode: typeof raw.cloudOcrMode === 'string' ? raw.cloudOcrMode : null,
     };
 }
 function externalChannelEnabled(channel) {
@@ -194,6 +204,38 @@ function bindAdapterEvents(runtime, sessionId, agentType, adapter) {
             id: `agent-evt-${event.runId}-${event.seq}`,
         });
     }
+    function stopActivityHeartbeat(activeSession) {
+        if (!activeSession?.heartbeatTimer)
+            return;
+        clearInterval(activeSession.heartbeatTimer);
+        activeSession.heartbeatTimer = null;
+    }
+    function sendActivityHeartbeat(activeSession) {
+        if (!activeSession.currentRunId || !activeSession.currentRunPhase)
+            return;
+        const seq = activeSession.heartbeatSeq++;
+        runtime.client.sendAgentEvent({
+            type: 'event',
+            event: 'agent',
+            payload: {
+                state: 'heartbeat',
+                sessionId,
+                runId: activeSession.currentRunId,
+                seq,
+                runPhase: activeSession.currentRunPhase,
+            },
+            seq,
+            id: `agent-heartbeat-${activeSession.currentRunId}-${seq}-${Date.now()}`,
+        });
+    }
+    function ensureActivityHeartbeat(activeSession) {
+        if (!activeSession || activeSession.heartbeatTimer)
+            return;
+        activeSession.heartbeatTimer = setInterval(() => {
+            sendActivityHeartbeat(activeSession);
+        }, SESSION_ACTIVITY_HEARTBEAT_INTERVAL_MS);
+        activeSession.heartbeatTimer.unref?.();
+    }
     function flushTextBuffer(activeSession) {
         const textBuffer = activeSession?.pendingTextEvent;
         if (!activeSession || !textBuffer || !textBuffer.text)
@@ -209,9 +251,16 @@ function bindAdapterEvents(runtime, sessionId, agentType, adapter) {
     }
     adapter.on('agentEvent', (event) => {
         const activeSession = runtime.sessions.get(sessionId);
+        const runPhase = runPhaseFromAgentEvent(event);
+        const isTerminalEvent = event.state === 'final' || event.state === 'error' || event.state === 'aborted';
         if (activeSession) {
-            activeSession.currentRunId = event.runId;
             activeSession.nextEventSeq = event.seq + 1;
+            if (!isTerminalEvent)
+                activeSession.currentRunId = event.runId;
+            if (!isTerminalEvent && runPhase) {
+                activeSession.currentRunPhase = runPhase;
+                ensureActivityHeartbeat(activeSession);
+            }
             if (event.agentSessionId)
                 activeSession.agentSessionId = event.agentSessionId;
         }
@@ -328,10 +377,12 @@ function bindAdapterEvents(runtime, sessionId, agentType, adapter) {
         else if (event.state === 'tool-call' || event.state === 'tool-result' || event.state === 'approval-pending') {
             flushTextBuffer(activeSession);
         }
-        if ((event.state === 'final' || event.state === 'error' || event.state === 'aborted') &&
+        if (isTerminalEvent &&
             activeSession?.currentRunId === event.runId) {
             activeSession.currentRunId = null;
+            activeSession.currentRunPhase = null;
             activeSession.nextEventSeq = 0;
+            stopActivityHeartbeat(activeSession);
             runtime.chatQueue?.noteTerminal(sessionId);
         }
         sendAgentEvent(event, extra);
@@ -355,6 +406,10 @@ function rememberProcessedReqId(runtime, reqId) {
     }
 }
 async function disposeSession(session) {
+    if (session.heartbeatTimer) {
+        clearInterval(session.heartbeatTimer);
+        session.heartbeatTimer = null;
+    }
     session.adapter.removeAllListeners();
     await session.adapter.stop().catch(() => { });
 }
@@ -372,7 +427,10 @@ async function createActiveSession(runtime, sessionId, agentType, resolvedWorkDi
         agentSessionId: incomingAgentSid ?? null,
         lastActiveAt: Date.now(),
         currentRunId: null,
+        currentRunPhase: null,
         nextEventSeq: 0,
+        heartbeatSeq: 0,
+        heartbeatTimer: null,
         pendingTextEvent: null,
         externalChannel: externalChannel ?? null,
         externalReplyTarget: externalReplyTarget ?? null,
@@ -394,7 +452,12 @@ function emitSyntheticAbort(runtime, sessionId) {
     runtime.runTextAcc.delete(`${sessionId}:${runId}`);
     session.pendingTextEvent = null;
     session.currentRunId = null;
+    session.currentRunPhase = null;
     session.nextEventSeq = 0;
+    if (session.heartbeatTimer) {
+        clearInterval(session.heartbeatTimer);
+        session.heartbeatTimer = null;
+    }
     runtime.client.sendAgentEvent({
         type: 'event',
         event: 'agent',

package/dist/src/session/manager.js

@@ -228,6 +228,10 @@ export class SessionManager {
             }
         }
         if (oldest) {
+            if (oldest.session.heartbeatTimer) {
+                clearInterval(oldest.session.heartbeatTimer);
+                oldest.session.heartbeatTimer = null;
+            }
             oldest.session.adapter.removeAllListeners();
             oldest.session.adapter.stop().catch(() => { });
             this.sessions.delete(oldest.key);
@@ -242,6 +246,10 @@ export class SessionManager {
     }
     cleanup() {
         for (const [, session] of this.sessions) {
+            if (session.heartbeatTimer) {
+                clearInterval(session.heartbeatTimer);
+                session.heartbeatTimer = null;
+            }
             session.adapter.stop().catch(() => { });
         }
         this.sessions.clear();

package/dist/src/session/types.d.ts

@@ -1,4 +1,4 @@
-import type { AgentType, ExternalChannelSessionStatus } from '@shennian/wire';
+import type { AgentType, ExternalChannelSessionStatus, SessionRunPhase } from '@shennian/wire';
 import type { AgentAdapter } from '../agents/adapter.js';
 import type { CliRelayClient } from '../relay/client.js';
 import type { NativeSessionFusionService } from '../native-fusion/service.js';
@@ -11,7 +11,10 @@ export type ActiveSession = {
     agentSessionId: string | null;
     lastActiveAt: number;
     currentRunId: string | null;
+    currentRunPhase: SessionRunPhase | null;
     nextEventSeq: number;
+    heartbeatSeq: number;
+    heartbeatTimer: ReturnType<typeof setInterval> | null;
     pendingTextEvent: {
         runId: string;
         seq: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shennian",
-  "version": "0.2.86",
+  "version": "0.2.88",
   "description": "Shennian — AI Agent Control Plane CLI",
   "type": "module",
   "bin": {