npm - @pasko70/pibo - Versions diffs - 1.11.2 → 1.11.3 - Mend

@pasko70/pibo 1.11.2 → 1.11.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (30) hide show

package/dist/apps/chat-ui/index.html CHANGED Viewed

@@ -11,10 +11,10 @@
     <link rel="manifest" href="/apps/chat/manifest.webmanifest" />
     <link rel="apple-touch-icon" href="/apps/chat/assets/pwa-images/ios/180.png" />
     <title>Pibo Web Chat</title>
-    <script type="module" crossorigin src="/apps/chat/assets/index-vcg8JNj9.js"></script>
+    <script type="module" crossorigin src="/apps/chat/assets/index-DT80TM0S.js"></script>
     <link rel="modulepreload" crossorigin href="/apps/chat/assets/rolldown-runtime-S-ySWqyJ.js">
     <link rel="modulepreload" crossorigin href="/apps/chat/assets/dist-SVPsM5Oi.js">
-    <link rel="stylesheet" crossorigin href="/apps/chat/assets/index-DNeE4HrG.css">
+    <link rel="stylesheet" crossorigin href="/apps/chat/assets/index-CYLZe0Y0.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/apps/vscode-artifacts/latest.vsix CHANGED Viewed

Binary file

package/dist/apps/vscode-artifacts/{pibo-vscode-ext-1.11.2.vsix → pibo-vscode-ext-1.11.3.vsix} RENAMED Viewed

Binary file

package/dist/core/routed-session.js CHANGED Viewed

@@ -6,6 +6,13 @@ import { expandInlineSkills } from "./skill-expansion.js";
 import { PIBO_CONTEXT_GUARD_RESUME_MESSAGE_TYPE, PIBO_CONTEXT_GUARD_RESUME_PROMPT, cancelPiboAssistantContextGuardRecovery, claimPiboAssistantContextGuardRecovery, waitForPiboAssistantContextGuardRecovery, } from "./context-guard.js";
 import { PIBO_PROVIDER_RECOVERY_MESSAGE_TYPE, PIBO_PROVIDER_RECOVERY_PROMPT, PiboProviderRecoveryCancelledError, isRetryablePiboAssistantError, isRetryablePiboProviderError, resolvePiboProviderRecoverySettings, waitForPiboProviderRecovery, } from "./provider-recovery.js";
 const FAST_SERVICE_TIER = "priority";
+const RUN_REMINDER_CAPABILITY_TOOLS = new Set([
+    "pibo_run_status",
+    "pibo_run_wait",
+    "pibo_run_read",
+    "pibo_run_cancel",
+    "pibo_run_ack",
+]);
 function modelSupportsFastServiceTier(model) {
     if (!model)
         return false;
@@ -420,14 +427,18 @@ export class RoutedSession {
     onKillChildren;
     onStateChange;
     onMessagesInterrupted;
+    messagePreflight;
     queue = [];
     processing = false;
     disposed = false;
     disposePromise;
+    runtimeDisposePromise;
+    forceDisposalStarted = false;
     drainPromise;
     fastMode = false;
     fastModePatchedAgents = new WeakSet();
     activeMessage;
+    activeExecutionEvent;
     activeAssistantIndex;
     nextAssistantIndex = 0;
     activeThinkingIndex;
@@ -437,10 +448,11 @@ export class RoutedSession {
     activeMessageFailed = false;
     providerRecoveryCancelled = false;
     providerRecoveryAbortController;
+    activeCapabilityScope;
     unsubscribe;
     recoverySession;
     isContinuePatched = false;
-    constructor(piboSessionId, runtime, emit, pluginRegistry, forwardPiEvents, onPiEventTelemetry, initialFastMode, onSessionOperation, onKillChildren, onStateChange, onMessagesInterrupted) {
+    constructor(piboSessionId, runtime, emit, pluginRegistry, forwardPiEvents, onPiEventTelemetry, initialFastMode, onSessionOperation, onKillChildren, onStateChange, onMessagesInterrupted, messagePreflight) {
         this.piboSessionId = piboSessionId;
         this.runtime = runtime;
         this.emit = emit;
@@ -451,6 +463,7 @@ export class RoutedSession {
         this.onKillChildren = onKillChildren;
         this.onStateChange = onStateChange;
         this.onMessagesInterrupted = onMessagesInterrupted;
+        this.messagePreflight = messagePreflight;
         this.fastMode = initialFastMode && this.fastModeSupported();
         this.bindRuntimeSession();
         this.patchFastModeProviderRequest();
@@ -534,7 +547,7 @@ export class RoutedSession {
         this.recoverySession = session;
         claimPiboAssistantContextGuardRecovery(session);
         this.unsubscribe = session.subscribe((event) => {
-            this.onPiEventTelemetry?.(this.piboSessionId, event, { status: this.getStatus(), activeEventId: this.activeMessage?.id });
+            this.onPiEventTelemetry?.(this.piboSessionId, event, { status: this.getStatus(), activeEventId: this.activeMessage?.id ?? this.activeExecutionEvent?.id });
             const model = this.runtime.session.model;
             const normalized = normalizePiEvent(this.piboSessionId, event, { contextWindow: numberValue(model?.contextWindow) });
             const candidate = event && typeof event === "object" ? event : undefined;
@@ -575,6 +588,11 @@ export class RoutedSession {
         this.providerRecoveryAbortController?.abort();
         this.providerRecoveryAbortController = undefined;
     }
+    async waitForPiAgentSettlement(session) {
+        const waitForIdle = session.waitForIdle;
+        if (waitForIdle)
+            await waitForIdle.call(session);
+    }
     async resumeContextGuardRecovery(session) {
         while (await waitForPiboAssistantContextGuardRecovery(session)) {
             try {
@@ -583,6 +601,7 @@ export class RoutedSession {
                     content: [{ type: "text", text: PIBO_CONTEXT_GUARD_RESUME_PROMPT }],
                     display: false,
                 }, { triggerTurn: true });
+                await this.waitForPiAgentSettlement(session);
             }
             catch (error) {
                 const resumeError = error instanceof Error ? error : new Error(String(error));
@@ -647,12 +666,14 @@ export class RoutedSession {
         if (!event || typeof event !== "object")
             return;
         const candidate = event;
+        const eventId = this.activeMessage?.id ?? this.activeExecutionEvent?.id;
         if (candidate.type === "compaction_start") {
-            this.emit({
+            this.emit(this.withActiveMessage({
                 type: "compaction_start",
                 piboSessionId: this.piboSessionId,
+                eventId,
                 reason: typeof candidate.reason === "string" ? candidate.reason : "unknown",
-            });
+            }));
         }
         if (candidate.type === "compaction_end") {
             if (candidate.result && candidate.aborted !== true) {
@@ -663,14 +684,15 @@ export class RoutedSession {
                 this.activeThinkingIndex = undefined;
                 this.nextThinkingIndex = 0;
             }
-            this.emit({
+            this.emit(this.withActiveMessage({
                 type: "compaction_end",
                 piboSessionId: this.piboSessionId,
+                eventId,
                 reason: typeof candidate.reason === "string" ? candidate.reason : "unknown",
                 result: candidate.result,
                 aborted: candidate.aborted === true,
                 errorMessage: typeof candidate.errorMessage === "string" ? candidate.errorMessage : undefined,
-            });
+            }));
         }
     }
     enqueueMessage(event) {
@@ -683,6 +705,7 @@ export class RoutedSession {
             queuedMessages: this.queue.length,
             text: event.text,
             source: event.source,
+            provenance: event.provenance,
         };
         this.emit(output);
         this.onStateChange?.({ processing: this.processing, queuedMessages: this.queue.length, disposed: this.disposed });
@@ -732,6 +755,11 @@ export class RoutedSession {
         this.emit(output);
         return output;
     }
+    getActiveMessage() {
+        if (!this.activeMessage)
+            return undefined;
+        return { id: this.activeMessage.id, source: this.activeMessage.source, provenance: this.activeMessage.provenance };
+    }
     getStatus() {
         const enabledTools = this.runtime.session.getActiveToolNames();
         const thinkingLevel = this.runtime.session.thinkingLevel;
@@ -739,8 +767,8 @@ export class RoutedSession {
         return {
             piboSessionId: this.piboSessionId,
             queuedMessages: this.queue.length,
-            processing: this.processing,
-            streaming: this.runtime.session.isStreaming,
+            processing: this.disposed ? false : this.processing,
+            streaming: this.disposed ? false : this.runtime.session.isStreaming,
             activeTools: enabledTools,
             enabledTools,
             cwd: this.runtime.cwd,
@@ -784,6 +812,13 @@ export class RoutedSession {
         this.notifyMessagesInterrupted(removedMessages, "queued message removed");
         return removedMessages.length;
     }
+    restoreMessageCapabilityScope() {
+        const active = this.activeCapabilityScope;
+        if (!active)
+            return;
+        this.activeCapabilityScope = undefined;
+        active.session.setActiveToolsByName(active.restoreToolNames);
+    }
     getCurrentSession() {
         return this.createSessionSnapshot();
     }
@@ -908,13 +943,29 @@ export class RoutedSession {
         this.disposePromise = this.disposeUnsafe();
         return this.disposePromise;
     }
-    async disposeUnsafe() {
-        if (this.disposed)
+    forceDispose(reason = "session disposal timed out") {
+        this.transitionToDisposed(reason);
+        if (this.forceDisposalStarted)
             return;
+        this.forceDisposalStarted = true;
+        const abort = this.runtime.session.abort;
+        if (abort) {
+            try {
+                void Promise.resolve(abort.call(this.runtime.session)).catch(() => { });
+            }
+            catch {
+                // Forced runtime disposal must still run when abort throws synchronously.
+            }
+        }
+        void this.disposeRuntime().catch(() => { });
+    }
+    transitionToDisposed(reason) {
+        if (this.disposed)
+            return false;
         const activeMessage = this.activeMessage;
-        this.notifyMessagesInterrupted(this.activeAndQueuedMessages(), "session disposed");
+        this.notifyMessagesInterrupted(this.activeAndQueuedMessages(), reason);
         if (activeMessage) {
-            const error = "Session disposed while a message was active.";
+            const error = `Session disposed while a message was active: ${reason}`;
             this.emit({
                 type: "session_error",
                 piboSessionId: this.piboSessionId,
@@ -925,22 +976,38 @@ export class RoutedSession {
         }
         this.cancelProviderRecovery();
         this.queue.length = 0;
-        this.onStateChange?.({ processing: this.processing, queuedMessages: this.queue.length, disposed: true });
+        this.onStateChange?.({ processing: false, queuedMessages: this.queue.length, disposed: true });
         this.unsubscribe?.();
         this.unsubscribe = undefined;
         if (this.recoverySession) {
-            this.cancelContextGuardRecovery("Context guard recovery cancelled because the routed session was disposed");
+            this.cancelContextGuardRecovery(`Context guard recovery cancelled because ${reason}`);
             this.recoverySession = undefined;
         }
         this.disposed = true;
+        return true;
+    }
+    disposeRuntime() {
+        if (!this.runtimeDisposePromise) {
+            try {
+                this.runtimeDisposePromise = Promise.resolve(this.runtime.dispose());
+            }
+            catch (error) {
+                this.runtimeDisposePromise = Promise.reject(error);
+            }
+        }
+        return this.runtimeDisposePromise;
+    }
+    async disposeUnsafe() {
+        if (!this.transitionToDisposed("session disposed"))
+            return;
         const abort = this.runtime.session.abort;
-        if (abort)
-            await Promise.allSettled([abort.call(this.runtime.session)]);
         try {
+            if (abort)
+                await Promise.allSettled([Promise.resolve().then(() => abort.call(this.runtime.session))]);
             await this.drainPromise;
         }
         finally {
-            await this.runtime.dispose();
+            await this.disposeRuntime();
         }
     }
     async kill() {
@@ -1004,14 +1071,35 @@ export class RoutedSession {
         }
     }
     async processQueuedMessage(event) {
-        this.emit({
-            type: "message_started",
-            piboSessionId: this.piboSessionId,
-            eventId: event.id,
-            text: event.text,
-            source: event.source,
-        });
         try {
+            const preflight = await this.messagePreflight?.(event);
+            if (this.disposed)
+                return;
+            if (preflight && !preflight.allowed) {
+                this.emit({
+                    type: "session_error",
+                    piboSessionId: this.piboSessionId,
+                    eventId: event.id,
+                    error: preflight.reason ?? "Queued message is no longer authorized",
+                    errorDetails: {
+                        category: "loop_lifecycle",
+                        errorClass: "runtime_abort",
+                        code: preflight.code ?? "message_preflight_rejected",
+                        origin: "runtime",
+                        retryable: false,
+                    },
+                    provenance: event.provenance,
+                });
+                return;
+            }
+            this.emit({
+                type: "message_started",
+                piboSessionId: this.piboSessionId,
+                eventId: event.id,
+                text: event.text,
+                source: event.source,
+                provenance: event.provenance,
+            });
             this.activeMessage = event;
             this.providerRecoveryCancelled = false;
             this.pendingAssistantError = undefined;
@@ -1022,10 +1110,20 @@ export class RoutedSession {
             this.activeThinkingIndex = undefined;
             this.nextThinkingIndex = 0;
             const session = this.runtime.session;
+            this.applyMessageCapabilityScope(event, session);
             const expandedText = expandInlineSkills(event.text, session.resourceLoader.getSkills().skills);
             await session.prompt(expandedText, { source: promptSource(event.source) });
+            if (this.disposed)
+                return;
+            await this.waitForPiAgentSettlement(session);
+            if (this.disposed)
+                return;
             await this.resumeContextGuardRecovery(session);
+            if (this.disposed)
+                return;
             await this.recoverTransientProviderErrors(session);
+            if (this.disposed)
+                return;
             this.flushPendingAssistantError();
             if (!this.activeMessageFailed) {
                 this.emit({
@@ -1033,6 +1131,7 @@ export class RoutedSession {
                     piboSessionId: this.piboSessionId,
                     eventId: event.id,
                     source: event.source,
+                    provenance: event.provenance,
                 });
             }
         }
@@ -1046,9 +1145,11 @@ export class RoutedSession {
                 eventId: event.id,
                 error: message,
                 errorDetails: runtimeSessionErrorDetails(message),
+                provenance: event.provenance,
             });
         }
         finally {
+            this.restoreMessageCapabilityScope();
             this.activeMessage = undefined;
             this.providerRecoveryCancelled = false;
             this.pendingAssistantError = undefined;
@@ -1060,9 +1161,20 @@ export class RoutedSession {
             this.nextThinkingIndex = 0;
         }
     }
+    applyMessageCapabilityScope(event, session) {
+        if (event.capabilityScope !== "run-reminder")
+            return;
+        const restoreToolNames = session.getActiveToolNames();
+        const scopedToolNames = restoreToolNames.filter((name) => RUN_REMINDER_CAPABILITY_TOOLS.has(name));
+        this.activeCapabilityScope = { session, restoreToolNames };
+        session.setActiveToolsByName(scopedToolNames);
+    }
     async processQueuedCompact(event) {
+        this.activeExecutionEvent = event;
         try {
             const result = await this.runAction(event);
+            if (this.disposed)
+                return;
             this.emit({
                 type: "execution_result",
                 piboSessionId: this.piboSessionId,
@@ -1072,6 +1184,8 @@ export class RoutedSession {
             });
         }
         catch (error) {
+            if (this.disposed)
+                return;
             const message = errorMessage(error);
             this.emit({
                 type: "session_error",
@@ -1081,6 +1195,9 @@ export class RoutedSession {
                 errorDetails: runtimeSessionErrorDetails(message),
             });
         }
+        finally {
+            this.activeExecutionEvent = undefined;
+        }
     }
     enqueueCompactAction(event) {
         this.queue.push({ kind: "compact", event });
@@ -1242,6 +1359,8 @@ export class RoutedSession {
         }
         if (this.activeMessage?.id &&
             (event.type === "assistant_usage" ||
+                event.type === "compaction_start" ||
+                event.type === "compaction_end" ||
                 event.type === "tool_call" ||
                 event.type === "tool_execution_started" ||
                 event.type === "tool_execution_updated" ||

package/dist/core/runtime-telemetry.js CHANGED Viewed

@@ -94,6 +94,12 @@ export class PiboRuntimeTelemetryRecorder {
                 this.finishOpenPhasesByName(turn?.turnId, "reasoning", "ok", telemetryTimestamp(context));
                 return;
             }
+            case "compaction_start":
+                this.recordCompactionStart(event, context);
+                return;
+            case "compaction_end":
+                this.recordCompactionEnd(event, context);
+                return;
             case "tool_call":
                 this.recordToolArgsPhase(event, context);
                 return;
@@ -249,6 +255,89 @@ export class PiboRuntimeTelemetryRecorder {
             this.recordTurnTerminal(event, context, "aborted", "abort", `${event.action} requested`);
             return;
         }
+        if (event.action === "compact") {
+            this.recordCompactExecutionResult(event, context);
+        }
+    }
+    recordCompactExecutionResult(event, context) {
+        if (!event.eventId)
+            return;
+        const existing = this.store?.getTurn(turnIdForEvent(event.eventId));
+        if (existing && !TERMINAL_TURN_STATUSES.has(existing.status)) {
+            this.recordTurnTerminal(event, context, "ok", "finish", "manual compaction finished");
+        }
+    }
+    recordCompactionStart(event, context) {
+        const turn = this.turnContextForEvent(event.piboSessionId, event.eventId, undefined, context)
+            ?? this.activeTurnContext(event.piboSessionId, context);
+        if (!turn)
+            return;
+        let storedTurn = this.store?.getTurn(turn.turnId);
+        if (storedTurn && TERMINAL_TURN_STATUSES.has(storedTurn.status))
+            return;
+        const now = telemetryTimestamp(context);
+        if (!storedTurn && event.eventId) {
+            turn.source = "system";
+            storedTurn = this.telemetry.upsertTurn({
+                turnId: turn.turnId,
+                piboSessionId: turn.piboSessionId,
+                rootSessionId: turn.rootSessionId,
+                roomId: turn.roomId,
+                inputEventId: turn.eventId,
+                eventId: turn.eventId,
+                source: turn.source,
+                status: "running",
+                currentPhase: "compaction",
+                queuedAt: now,
+                startedAt: now,
+                lastProgressAt: now,
+                queueDepth: turn.queueDepth,
+                summary: `${event.reason} compaction started`,
+                metadata: sessionMetadata(context.session),
+            });
+        }
+        for (const phase of this.store?.listOpenPhasesForTurn(turn.turnId) ?? []) {
+            if (phase.name === "compaction")
+                continue;
+            this.telemetry.finishPhase(phase.phaseId, { status: "ok", endedAt: now, lastProgressAt: now });
+        }
+        this.startOrProgressPhase(turn, "compaction", now, `${event.reason} compaction started`, {
+            updateTurn: true,
+            counters: { reason: event.reason },
+        });
+    }
+    recordCompactionEnd(event, context) {
+        const turn = this.turnContextForEvent(event.piboSessionId, event.eventId, undefined, context)
+            ?? this.activeTurnContext(event.piboSessionId, context);
+        if (!turn)
+            return;
+        const now = telemetryTimestamp(context);
+        const status = event.aborted ? "aborted" : event.errorMessage ? "error" : "ok";
+        const summary = event.errorMessage
+            ? `${event.reason} compaction failed: ${event.errorMessage}`
+            : event.aborted
+                ? `${event.reason} compaction aborted`
+                : `${event.reason} compaction finished`;
+        this.finishOpenPhasesByName(turn.turnId, "compaction", status, now, safeSummary(summary));
+        const storedTurn = this.store?.getTurn(turn.turnId);
+        if (storedTurn?.source === "system" && (status === "error" || status === "aborted")) {
+            this.recordTurnTerminal(event, context, status === "aborted" ? "aborted" : "error", status === "aborted" ? "abort" : "error", summary, "compaction");
+            return;
+        }
+        if (storedTurn && !TERMINAL_TURN_STATUSES.has(storedTurn.status)) {
+            this.telemetry.upsertTurn({
+                turnId: turn.turnId,
+                piboSessionId: turn.piboSessionId,
+                rootSessionId: turn.rootSessionId,
+                roomId: turn.roomId,
+                eventId: turn.eventId,
+                status: "running",
+                currentPhase: "compaction",
+                lastProgressAt: now,
+                queueDepth: turn.queueDepth,
+                summary: safeSummary(summary),
+            });
+        }
     }
     recordProviderStreamProgress(event, context, phaseName, summary, force = false) {
         const turn = event.eventId
@@ -489,6 +578,7 @@ export class PiboRuntimeTelemetryRecorder {
             providerRequestId: options.providerRequestId,
             toolCallId: options.toolCallId,
             eventId: turn.eventId,
+            counters: options.counters,
             summary,
         });
         if (options.updateTurn) {

package/dist/core/runtime.js CHANGED Viewed

@@ -287,6 +287,7 @@ export async function createPiboRuntime(options = {}) {
                 piboSessionId: options.sessionContext?.piboSessionId ?? profile.sessionId,
                 piboRoomId: options.sessionContext?.piboRoomId,
                 profileName: profile.profileName,
+                getActiveMessage: options.sessionContext?.getActiveMessage,
             },
         }, options.subagentRunner, options.runToolController, runtimeToolController);
         const modelDefaults = options.modelDefaults ?? loadPiboModelDefaults(runtimeCwd);