@pasko70/pibo 1.7.12 → 1.8.0

package/dist/core/session-router.js

@@ -20,6 +20,7 @@ import { withWorkflowSessionKind } from "../sessions/workflow-session-kind.js";
 import { PiboRuntimeTelemetryRecorder } from "./runtime-telemetry.js";
 import { createPiboProviderTelemetryExtension } from "./provider-telemetry.js";
 const DEFAULT_SUBAGENT_REPLY_TIMEOUT_MS = 10 * 60 * 1000;
+const DEFAULT_ROUTED_SESSION_IDLE_TIMEOUT_MS = 30 * 60 * 1000;
 export const RALPH_RUNTIME_RETRY_DEFAULTS = {
     enabled: true,
     maxRetries: 7,
@@ -132,6 +133,8 @@ export class PiboSessionRouter {
     signalRegistry;
     runtimeRegistry;
     scheduledRunReminders = new Map();
+    idleSessionTimers = new Map();
+    routedSessionIdleTimeoutMs;
     baseProfile;
     pluginRegistry;
     sessionStore;
@@ -146,6 +149,12 @@ export class PiboSessionRouter {
         this.telemetryRecorder = this.telemetryStore
             ? new PiboRuntimeTelemetryRecorder(this.telemetryStore, undefined, { providerEventMode: providerEventTelemetryModeFromEnv() })
             : undefined;
+        const idleTimeoutMs = options.routedSessionIdleTimeoutMs;
+        this.routedSessionIdleTimeoutMs = idleTimeoutMs === false
+            ? false
+            : typeof idleTimeoutMs === "number" && Number.isFinite(idleTimeoutMs) && idleTimeoutMs > 0
+                ? idleTimeoutMs
+                : DEFAULT_ROUTED_SESSION_IDLE_TIMEOUT_MS;
         const defaultProfileName = selectDefaultPiboProfileName(this.pluginRegistry);
         this.baseProfile = options.profile ?? createPiboProfileFromRegistryOrDefault(this.pluginRegistry, defaultProfileName);
         this.reliabilityStore = options.reliabilityStore ?? (options.persistSession === false ? undefined : createDefaultPiboReliabilityStore());
@@ -165,20 +174,29 @@ export class PiboSessionRouter {
     }
     async emit(event) {
         const session = await this.getOrCreateSession(event.piboSessionId);
-        if (event.type === "message") {
-            return session.enqueueMessage(event);
-        }
-        const output = await session.executeAction(event);
-        if (event.action === "abort") {
-            this.signalRegistry.project({ type: "session_interrupted", piboSessionId: event.piboSessionId, reason: "abort action" });
-        }
-        if (event.action === "dispose") {
-            this.disposeSignalSubtree(event.piboSessionId, "dispose action");
+        this.clearIdleSessionTimer(event.piboSessionId);
+        try {
+            if (event.type === "message") {
+                return session.enqueueMessage(event);
+            }
+            const output = await session.executeAction(event);
+            if (event.action === "abort") {
+                this.signalRegistry.project({ type: "session_interrupted", piboSessionId: event.piboSessionId, reason: "abort action" });
+            }
+            if (event.action === "dispose") {
+                await this.disposeSessionSubtree(event.piboSessionId, "dispose action", { cancelRuns: true });
+            }
+            else if (event.action === "kill" || event.action === "kill_all") {
+                await this.disposeSessionSubtree(event.piboSessionId, `${event.action} action`, { cancelRuns: event.action === "kill_all" });
+            }
+            else if (shouldResetSessionAfterAction(event.action)) {
+                await this.resetCachedSession(event.piboSessionId, "provider auth changed");
+            }
+            return output;
         }
-        else if (shouldResetSessionAfterAction(event.action)) {
-            await this.resetCachedSession(event.piboSessionId, "provider auth changed");
+        finally {
+            this.scheduleIdleSessionEvictionIfIdle(event.piboSessionId);
         }
-        return output;
     }
     async killSession(piboSessionId, options) {
         const killed = [];
@@ -190,23 +208,32 @@ export class PiboSessionRouter {
                 const runs = this.runRegistry.cancelControllerRuns(piboSessionId);
                 cancelledRuns.push(...runs.map((r) => r.runId));
             }
-            await this.runtimeRegistry.closeControllerSessions(piboSessionId, { force: true });
             this.signalRegistry.project({ type: "session_interrupted", piboSessionId, reason: "kill" });
             const children = await this.killChildSessions(piboSessionId, options);
             killed.push(...children.killed);
             cancelledRuns.push(...children.cancelledRuns);
+            await this.disposeSessionSubtree(piboSessionId, "kill", { cancelRuns: false });
         }
         return { killed, cancelledRuns };
     }
-    disposeSignalSubtree(piboSessionId, reason) {
-        const descendants = this.descendantSessionIds(piboSessionId);
-        for (const id of [piboSessionId, ...descendants]) {
-            this.runRegistry.cancelControllerRuns(id);
-            void this.runtimeRegistry.closeControllerSessions(id, { force: true });
-            this.signalRegistry.project({ type: "session_disposed", piboSessionId: id, reason });
+    async disposeSessionSubtree(piboSessionId, reason, options) {
+        const ids = [piboSessionId, ...this.descendantSessionIds(piboSessionId)];
+        const sessions = [];
+        for (const id of ids) {
+            if (options.cancelRuns)
+                this.runRegistry.cancelControllerRuns(id);
+            this.clearIdleSessionTimer(id);
             this.scheduledRunReminders.delete(id);
+            const cached = this.sessions.get(id);
+            if (cached)
+                sessions.push(cached);
             this.sessions.delete(id);
         }
+        await Promise.all(ids.map((id) => this.runtimeRegistry.closeControllerSessions(id, { force: true })));
+        await Promise.all(sessions.map((session) => session.dispose()));
+        for (const id of ids) {
+            this.signalRegistry.project({ type: "session_disposed", piboSessionId: id, reason });
+        }
     }
     descendantSessionIds(parentId) {
         const output = [];
@@ -327,6 +354,9 @@ export class PiboSessionRouter {
     async disposeAll() {
         const sessions = [...this.sessions.values()];
         this.sessions.clear();
+        for (const timer of this.idleSessionTimers.values())
+            clearTimeout(timer);
+        this.idleSessionTimers.clear();
         this.runRegistry.cancelAll("Pibo session router was disposed.");
         for (const session of sessions)
             this.signalRegistry.project({ type: "session_disposed", piboSessionId: session.getStatus().piboSessionId, reason: "router disposed" });
@@ -334,10 +364,54 @@ export class PiboSessionRouter {
         await this.runtimeRegistry.closeAll({ force: true });
         await Promise.all(sessions.map((session) => session.dispose()));
     }
+    clearIdleSessionTimer(piboSessionId) {
+        const timer = this.idleSessionTimers.get(piboSessionId);
+        if (timer)
+            clearTimeout(timer);
+        this.idleSessionTimers.delete(piboSessionId);
+    }
+    scheduleIdleSessionEvictionIfIdle(piboSessionId) {
+        if (this.routedSessionIdleTimeoutMs === false)
+            return;
+        const session = this.sessions.get(piboSessionId);
+        if (!session)
+            return;
+        const status = session.getStatus();
+        if (status.disposed || status.processing || status.streaming || status.queuedMessages > 0) {
+            this.clearIdleSessionTimer(piboSessionId);
+            return;
+        }
+        this.clearIdleSessionTimer(piboSessionId);
+        const timer = setTimeout(() => {
+            this.idleSessionTimers.delete(piboSessionId);
+            void this.evictIdleSession(piboSessionId, session).catch((error) => {
+                const message = error instanceof Error ? error.message : String(error);
+                this.emitOutput({
+                    type: "session_error",
+                    piboSessionId,
+                    error: `Failed to dispose idle routed runtime: ${message}`,
+                    errorDetails: runtimeSessionErrorDetails(message),
+                });
+            });
+        }, this.routedSessionIdleTimeoutMs);
+        timer.unref();
+        this.idleSessionTimers.set(piboSessionId, timer);
+    }
+    async evictIdleSession(piboSessionId, expected) {
+        const current = this.sessions.get(piboSessionId);
+        if (current !== expected)
+            return;
+        const status = current.getStatus();
+        if (status.disposed || status.processing || status.streaming || status.queuedMessages > 0)
+            return;
+        await this.resetCachedSession(piboSessionId, "routed runtime idle timeout");
+    }
     async getOrCreateSession(piboSessionId) {
         const existing = this.sessions.get(piboSessionId);
-        if (existing)
+        if (existing) {
+            this.clearIdleSessionTimer(piboSessionId);
             return existing;
+        }
         const pending = this.pendingSessions.get(piboSessionId);
         if (pending)
             return pending;
@@ -388,7 +462,16 @@ export class PiboSessionRouter {
         const initialFastMode = resolvePiboSessionInitialFastMode(piboSession) ?? selectRequestedFastMode(profileForSession(profile, piboSession.piSessionId, parentPiSessionId), modelDefaults) ?? false;
         const session = new RoutedSession(piboSession.id, runtime, this.emitOutput, this.pluginRegistry, this.options.forwardPiEvents ?? false, this.telemetryRecorder
             ? (id, event, context) => this.telemetryRecorder?.recordPiEvent(id, event, { session: this.sessionStore.get(id), status: context.status, activeEventId: context.activeEventId })
-            : undefined, initialFastMode, (result, event) => this.handleSessionOperation(result, event), (id, opts) => this.killChildSessions(id, opts), (state) => this.signalRegistry.project({ type: "session_processing_changed", piboSessionId: piboSession.id, processing: state.processing, queuedMessages: state.queuedMessages }));
+            : undefined, initialFastMode, (result, event) => this.handleSessionOperation(result, event), (id, opts) => this.killChildSessions(id, opts), (state) => {
+            this.signalRegistry.project({ type: "session_processing_changed", piboSessionId: piboSession.id, processing: state.processing, queuedMessages: state.queuedMessages });
+            if (state.disposed || state.processing || state.queuedMessages > 0)
+                this.clearIdleSessionTimer(piboSession.id);
+            else
+                this.scheduleIdleSessionEvictionIfIdle(piboSession.id);
+        }, (messages, reason) => this.telemetryRecorder?.recordMessagesInterrupted(messages, {
+            session: this.sessionStore.get(piboSession.id),
+            status: this.sessions.get(piboSession.id)?.getStatus(),
+        }, reason));
         this.sessions.set(piboSession.id, session);
         return session;
     }
@@ -447,6 +530,7 @@ export class PiboSessionRouter {
     }
     async resetCachedSession(piboSessionId, reason) {
         const cached = this.sessions.get(piboSessionId);
+        this.clearIdleSessionTimer(piboSessionId);
         this.sessions.delete(piboSessionId);
         await this.runtimeRegistry.closeControllerSessions(piboSessionId, { force: true });
         await cached?.dispose();

package/dist/data/telemetry.js

@@ -17,6 +17,61 @@ export class TelemetryStore {
     getTurnTimeline(turnIdOrEventId, input = {}) {
         return getTelemetryTurnTimeline(this.db, turnIdOrEventId, input);
     }
+    getOpenPhaseForTurn(turnId, name) {
+        const row = this.db.prepare(`
+			SELECT * FROM telemetry_phases
+			WHERE turn_id = ? AND name = ? AND status = 'open'
+			ORDER BY COALESCE(last_progress_at, started_at) DESC, created_at DESC
+			LIMIT 1
+		`).get(turnId, name);
+        return row ? phaseFromRow(row) : undefined;
+    }
+    countPhasesForTurn(turnId, name) {
+        const row = this.db.prepare("SELECT COUNT(*) AS count FROM telemetry_phases WHERE turn_id = ? AND name = ?").get(turnId, name);
+        return Number(row.count);
+    }
+    listOpenPhasesForTurn(turnId) {
+        const rows = this.db.prepare(`
+			SELECT * FROM telemetry_phases
+			WHERE turn_id = ? AND status = 'open'
+			ORDER BY started_at ASC, created_at ASC
+		`).all(turnId);
+        return rows.map(phaseFromRow);
+    }
+    getLatestProviderRequestForTurn(turnId) {
+        const row = this.db.prepare(`
+			SELECT * FROM telemetry_provider_requests
+			WHERE turn_id = ?
+			ORDER BY started_at DESC, created_at DESC
+			LIMIT 1
+		`).get(turnId);
+        return row ? providerRequestFromRow(row) : undefined;
+    }
+    getActiveProviderRequestForTurn(turnId) {
+        const row = this.db.prepare(`
+			SELECT * FROM telemetry_provider_requests
+			WHERE turn_id = ? AND status NOT IN ('completed', 'error', 'aborted', 'timeout')
+			ORDER BY started_at DESC, created_at DESC
+			LIMIT 1
+		`).get(turnId);
+        return row ? providerRequestFromRow(row) : undefined;
+    }
+    listActiveProviderRequestsForTurn(turnId) {
+        const rows = this.db.prepare(`
+			SELECT * FROM telemetry_provider_requests
+			WHERE turn_id = ? AND status NOT IN ('completed', 'error', 'aborted', 'timeout')
+			ORDER BY started_at ASC, created_at ASC
+		`).all(turnId);
+        return rows.map(providerRequestFromRow);
+    }
+    listActiveToolCallsForTurn(turnId) {
+        const rows = this.db.prepare(`
+			SELECT * FROM telemetry_tool_calls
+			WHERE turn_id = ? AND status NOT IN ('ok', 'error', 'aborted', 'timeout')
+			ORDER BY created_at ASC
+		`).all(turnId);
+        return rows.map(toolCallFromRow);
+    }
     listProviderEventsPage(providerRequestId, input = {}) {
         return listTelemetryProviderEventsPage(this.db, providerRequestId, input);
     }
@@ -176,6 +231,53 @@ export class TelemetryStore {
         const normalizedDelta = input.normalizedEventDelta ?? (input.normalizedType ? 1 : 0);
         this.incrementProviderCounters(input.providerRequestId, input.eventType, receivedAt, byteSize, parseStatus, normalizedDelta);
     }
+    recordProviderProgress(input) {
+        const existing = this.getProviderRequest(input.providerRequestId);
+        if (!existing)
+            return undefined;
+        const eventTypeCounts = { ...existing.eventTypeCounts };
+        for (const [eventType, delta] of Object.entries(input.eventTypeCounts ?? {})) {
+            if (!Number.isFinite(delta) || delta <= 0)
+                continue;
+            const current = typeof eventTypeCounts[eventType] === "number" ? eventTypeCounts[eventType] : 0;
+            eventTypeCounts[eventType] = current + delta;
+        }
+        const rawEventCount = Math.max(0, input.rawEventCount ?? 0);
+        const normalizedEventCount = Math.max(0, input.normalizedEventCount ?? 0);
+        const parseErrorCount = Math.max(0, input.parseErrorCount ?? 0);
+        const unknownEventCount = Math.max(0, input.unknownEventCount ?? 0);
+        const bytesReceived = Math.max(0, input.bytesReceived ?? 0);
+        const updatedAt = input.updatedAt ?? input.lastNormalizedEventAt ?? input.lastRawEventAt ?? new Date().toISOString();
+        this.db.prepare(`
+			UPDATE telemetry_provider_requests SET
+				status = CASE WHEN status IN ('completed', 'error', 'aborted', 'timeout') THEN status ELSE COALESCE(?, status) END,
+				last_raw_event_at = COALESCE(?, last_raw_event_at),
+				last_normalized_event_at = COALESCE(?, last_normalized_event_at),
+				upstream_response_id = COALESCE(?, upstream_response_id),
+				raw_event_count = raw_event_count + ?,
+				normalized_event_count = normalized_event_count + ?,
+				parse_error_count = parse_error_count + ?,
+				unknown_event_count = unknown_event_count + ?,
+				bytes_received = CASE WHEN ? = 0 THEN bytes_received ELSE COALESCE(bytes_received, 0) + ? END,
+				event_type_counts_json = ?,
+				updated_at = ?
+			WHERE provider_request_id = ?
+		`).run(input.status ?? null, input.lastRawEventAt ?? null, input.lastNormalizedEventAt ?? null, input.upstreamResponseId ?? null, rawEventCount, normalizedEventCount, parseErrorCount, unknownEventCount, bytesReceived, bytesReceived, JSON.stringify(eventTypeCounts), updatedAt, input.providerRequestId);
+        return {
+            ...existing,
+            status: isTerminalProviderRequestStatus(existing.status) ? existing.status : input.status ?? existing.status,
+            lastRawEventAt: input.lastRawEventAt ?? existing.lastRawEventAt,
+            lastNormalizedEventAt: input.lastNormalizedEventAt ?? existing.lastNormalizedEventAt,
+            upstreamResponseId: input.upstreamResponseId ?? existing.upstreamResponseId,
+            rawEventCount: existing.rawEventCount + rawEventCount,
+            normalizedEventCount: existing.normalizedEventCount + normalizedEventCount,
+            parseErrorCount: existing.parseErrorCount + parseErrorCount,
+            unknownEventCount: existing.unknownEventCount + unknownEventCount,
+            bytesReceived: bytesReceived > 0 ? (existing.bytesReceived ?? 0) + bytesReceived : existing.bytesReceived,
+            eventTypeCounts,
+            updatedAt,
+        };
+    }
     appendProviderEventSummary(input) {
         const now = input.updatedAt ?? new Date().toISOString();
         const receivedAt = input.receivedAt ?? now;
@@ -293,34 +395,15 @@ export class TelemetryStore {
         return row.next_sequence;
     }
     incrementProviderCounters(providerRequestId, eventType, receivedAt, byteSize, parseStatus, normalizedDelta) {
-        const existing = this.getProviderRequest(providerRequestId);
-        if (!existing)
-            return;
-        const eventTypeCounts = { ...existing.eventTypeCounts };
-        const currentCount = typeof eventTypeCounts[eventType] === "number" ? eventTypeCounts[eventType] : 0;
-        eventTypeCounts[eventType] = currentCount + 1;
-        this.upsertProviderRequest({
+        this.recordProviderProgress({
             providerRequestId,
-            piboSessionId: existing.piboSessionId,
-            rootSessionId: existing.rootSessionId,
-            roomId: existing.roomId,
-            turnId: existing.turnId,
-            phaseId: existing.phaseId,
-            provider: existing.provider,
-            api: existing.api,
-            model: existing.model,
-            transport: existing.transport,
-            serviceTier: existing.serviceTier,
-            status: existing.status,
             lastRawEventAt: receivedAt,
-            rawEventCount: existing.rawEventCount + 1,
-            normalizedEventCount: existing.normalizedEventCount + normalizedDelta,
-            parseErrorCount: existing.parseErrorCount + (parseStatus === "invalid_json" ? 1 : 0),
-            unknownEventCount: existing.unknownEventCount + (parseStatus === "unknown_type" ? 1 : 0),
-            bytesReceived: (existing.bytesReceived ?? 0) + byteSize,
-            eventTypeCounts,
-            captureMode: existing.captureMode,
-            retentionClass: existing.retentionClass,
+            rawEventCount: 1,
+            normalizedEventCount: normalizedDelta,
+            parseErrorCount: parseStatus === "invalid_json" ? 1 : 0,
+            unknownEventCount: parseStatus === "unknown_type" ? 1 : 0,
+            bytesReceived: byteSize,
+            eventTypeCounts: { [eventType]: 1 },
             updatedAt: receivedAt,
         });
     }
@@ -347,6 +430,9 @@ export class BestEffortTelemetryService {
     recordProviderEventSummary(input) {
         this.safe(() => this.store?.recordProviderEventSummary(input));
     }
+    recordProviderProgress(input) {
+        return this.safe(() => this.store?.recordProviderProgress(input));
+    }
     appendProviderEventSummary(input) {
         return this.safe(() => this.store?.appendProviderEventSummary(input));
     }
@@ -363,6 +449,9 @@ export class BestEffortTelemetryService {
         }
     }
 }
+function isTerminalProviderRequestStatus(status) {
+    return status === "completed" || status === "error" || status === "aborted" || status === "timeout";
+}
 function fail(message) {
     throw new Error(message);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pasko70/pibo",
-  "version": "1.7.12",
+  "version": "1.8.0",
   "type": "module",
   "imports": {
     "vscode": "./src/apps/chat-vscode/extension/src/vscode-shim.js"