npm - @pasko70/pibo - Versions diffs - 3.4.4 → 3.5.0 - Mend

@pasko70/pibo 3.4.4 → 3.5.0

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 (79) hide show

package/dist/agent-runtime/routed-session.js +37 -12
package/dist/agent-runtimes/pi/adapter.js +1 -0
package/dist/agent-runtimes/pi/routed-session.js +2 -2
package/dist/apps/chat/bounded-event-stream.js +98 -0
package/dist/apps/chat/chat-settings-routes.js +3 -3
package/dist/apps/chat/data/chat-data-mappers.js +32 -13
package/dist/apps/chat/data/event-command-service.js +30 -21
package/dist/apps/chat/data/history-query-service.js +34 -25
package/dist/apps/chat/data/read-state-service.js +13 -0
package/dist/apps/chat/data/session-query-service.js +19 -11
package/dist/apps/chat/data/timeline-query-service.js +19 -7
package/dist/apps/chat/message-command-dispatcher.js +134 -0
package/dist/apps/chat/output-compactor.js +9 -0
package/dist/apps/chat/output-event-policy.js +9 -1
package/dist/apps/chat/stream.js +21 -3
package/dist/apps/chat/telemetry-retention-service.js +113 -8
package/dist/apps/chat/trace-response-cache.js +46 -0
package/dist/apps/chat/trace-v2.js +12 -6
package/dist/apps/chat/trace.js +1 -1
package/dist/apps/chat/web-app.js +608 -281
package/dist/apps/chat-ui/assets/{dist-Bf2KScPo.js → dist-BG0n7zLd.js} +1 -1
package/dist/apps/chat-ui/assets/{dist-23lt_7qm.js → dist-D6TjFhAm.js} +1 -1
package/dist/apps/chat-ui/assets/{dist-V06sfuZa.js → dist-D79vyxSX.js} +1 -1
package/dist/apps/chat-ui/assets/{dist-CH3SvpYV.js → dist-DFZ8cwh0.js} +1 -1
package/dist/apps/chat-ui/assets/{dist-DsgL8w-W.js → dist-cOjokPrK.js} +1 -1
package/dist/apps/chat-ui/assets/index-RMHUTJ62.js +229 -0
package/dist/apps/chat-ui/assets/{index-BOceJ0jM.css → index-hEkrlRk-.css} +1 -1
package/dist/apps/chat-ui/index.html +2 -2
package/dist/apps/chat-vscode-web/assets/index-xacbCyTx.js +44 -0
package/dist/apps/chat-vscode-web/index.html +1 -1
package/dist/compute/pool/seeds.js +25 -3
package/dist/core/events.js +4 -0
package/dist/core/output-render-sequence.js +2 -0
package/dist/core/provider-capacity.js +33 -0
package/dist/core/provider-telemetry.js +21 -6
package/dist/core/runtime-capacity.js +174 -0
package/dist/core/runtime-telemetry.js +40 -12
package/dist/core/session-router.js +79 -2
package/dist/data/async-chat-reads.js +38 -0
package/dist/data/async-chat-storage.js +91 -0
package/dist/data/async-telemetry-maintenance.js +9 -0
package/dist/data/bounded-worker-client.js +256 -0
package/dist/data/chat-read-projections.js +159 -0
package/dist/data/chat-read-worker.js +73 -0
package/dist/data/chat-storage-worker.js +146 -0
package/dist/data/ingest-service.js +79 -14
package/dist/data/message-command-store.js +148 -0
package/dist/data/payload-store.js +92 -11
package/dist/data/pibo-store.js +10 -8
package/dist/data/schema.js +16 -2
package/dist/data/session-store.js +3 -1
package/dist/data/storage-backup.js +278 -0
package/dist/data/telemetry-capture.js +188 -0
package/dist/data/telemetry-command.js +3 -0
package/dist/data/telemetry-maintenance-worker.js +40 -0
package/dist/data/telemetry-maintenance.js +110 -0
package/dist/data/telemetry-retention.js +16 -7
package/dist/data/telemetry-worker.js +111 -0
package/dist/data/telemetry-writer.js +150 -83
package/dist/data/telemetry.js +5 -0
package/dist/debug/index.js +52 -0
package/dist/debug/storage-backup.js +33 -0
package/dist/debug/telemetry-capture.js +66 -0
package/dist/gateway/server.js +2 -0
package/dist/providers/openai-gpt56.js +11 -6
package/dist/session-ui/terminalRows.js +48 -6
package/dist/sessions/pibo-data-store.js +1 -0
package/dist/shared/debug-features.js +4 -0
package/dist/shared/model-inference-metrics.js +23 -0
package/dist/shared/trace-event-projection.js +59 -2
package/dist/shared/trace-history.js +9 -0
package/dist/shared/trace-live-reducer.js +1 -0
package/dist/shared/trace-patch-nodes.js +19 -0
package/dist/web/channel.js +3 -0
package/dist/web/http.js +36 -3
package/npm-shrinkwrap.json +2 -2
package/package.json +1 -1
package/dist/apps/chat-ui/assets/index-BOemYq-V.js +0 -228
package/dist/apps/chat-vscode-web/assets/index-CMwTB8o8.js +0 -43

package/dist/apps/chat-vscode-web/index.html CHANGED Viewed

@@ -5,7 +5,7 @@
 		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
 		<meta name="theme-color" content="#101d22" />
 		<title>Pibo</title>
-		<script type="module" crossorigin src="/apps/chat-vscode/assets/index-CMwTB8o8.js"></script>
+		<script type="module" crossorigin src="/apps/chat-vscode/assets/index-xacbCyTx.js"></script>
 		<link rel="stylesheet" crossorigin href="/apps/chat-vscode/assets/index-b18ZkEo0.css">
 	</head>
 	<body>

package/dist/compute/pool/seeds.js CHANGED Viewed

@@ -68,7 +68,7 @@ export async function prepareDeploymentSeed(input) {
         await copySeedNonDatabaseFiles(input.config.seedSourceHome, homePath, input.mode, input.config.root);
         const copiedDatabases = await backupSeedDatabases(input.config.seedSourceHome, homePath, input.mode);
         if (input.config.seedSourcePiHome && existsSync(input.config.seedSourcePiHome)) {
-            await copyPiRuntimeAuth(input.config.seedSourcePiHome, piHomePath);
+            await copyPiRuntimeSeed(input.config.seedSourcePiHome, piHomePath);
         }
         if (input.mode === "full" && input.config.seedSourceWorkspace && existsSync(input.config.seedSourceWorkspace)) {
             await cp(input.config.seedSourceWorkspace, workspacePath, { recursive: true, force: true, preserveTimestamps: true });
@@ -160,11 +160,33 @@ async function backupSeedDatabases(sourceHome, destinationHome, mode) {
     }
     return copied.sort();
 }
-async function copyPiRuntimeAuth(sourcePiHome, destinationPiHome) {
+async function copyPiRuntimeSeed(sourcePiHome, destinationPiHome) {
     const sourceAgent = resolve(sourcePiHome, "agent");
     const destinationAgent = resolve(destinationPiHome, "agent");
     await mkdir(destinationAgent, { recursive: true, mode: 0o700 });
-    for (const name of ["auth.json", "models-store.json"]) {
+    // OAuth refresh tokens belong to one credential store. Cloning them into isolated
+    // slots makes token rotation race with the source login and other slots.
+    const authPath = resolve(sourceAgent, "auth.json");
+    if (existsSync(authPath)) {
+        let parsed;
+        try {
+            parsed = JSON.parse(await readFile(authPath, "utf8"));
+        }
+        catch {
+            throw new Error("Cannot read the Pi credential seed.");
+        }
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            throw new Error("Invalid Pi credential seed.");
+        const apiKeys = Object.fromEntries(Object.entries(parsed).flatMap(([provider, value]) => {
+            if (!value || typeof value !== "object" || value.type !== "api_key" || typeof value.key !== "string")
+                return [];
+            return [[provider, { type: "api_key", key: value.key }]];
+        }));
+        if (Object.keys(apiKeys).length) {
+            await writeFile(resolve(destinationAgent, "auth.json"), `${JSON.stringify(apiKeys)}\n`, { mode: 0o600 });
+        }
+    }
+    for (const name of ["models-store.json"]) {
         const source = resolve(sourceAgent, name);
         if (!existsSync(source))
             continue;

package/dist/core/events.js CHANGED Viewed

@@ -4,3 +4,7 @@ export class PiboSteeringUnavailableError extends Error {
         this.name = "PiboSteeringUnavailableError";
     }
 }
+/** Only queue-clear actions can carry an already-completed ingress count. */
+export function previouslyClearedMessages(event) {
+    return event.action === "clear_queue" && Number.isSafeInteger(event.clearedBeforeRuntime) && event.clearedBeforeRuntime > 0 ? event.clearedBeforeRuntime : 0;
+}

package/dist/core/output-render-sequence.js CHANGED Viewed

@@ -383,6 +383,7 @@ function validOutputPartIndex(value) {
 export function outputIdentityFingerprint(event) {
     const payload = { ...event };
     delete payload.renderSequence;
+    delete payload.compactionStats;
     return createHash("sha256").update(stableJson(payload)).digest("hex");
 }
 export function outputPartFingerprint(event) {
@@ -393,6 +394,7 @@ export function outputPartFingerprint(event) {
     delete payload.usageIndex;
     delete payload.compactionIndex;
     delete payload.contentIndex;
+    delete payload.compactionStats;
     return createHash("sha256").update(stableJson(payload)).digest("hex");
 }
 function stableJson(value) {

package/dist/core/provider-capacity.js ADDED Viewed

@@ -0,0 +1,33 @@
+/** Pi's request boundary releases before tool work, so parents cannot pin slots while awaiting children. */
+export function createProviderCapacityExtension(capacity, room, nested = false) {
+    return pi => {
+        let lease;
+        let removeAbort;
+        const release = () => { removeAbort?.(); removeAbort = undefined; lease?.release(); lease = undefined; };
+        pi.on("before_provider_request", async (_event, ctx) => {
+            // Retries replace a previous failed HTTP request, never overlap its reservation.
+            release();
+            const signal = ctx.signal;
+            try {
+                lease = await capacity.acquireProvider(ctx.model?.provider ?? "pi-unknown", room, signal, nested);
+                if (signal?.aborted) {
+                    release();
+                    return;
+                }
+                signal?.addEventListener("abort", release, { once: true });
+                removeAbort = () => signal?.removeEventListener("abort", release);
+            }
+            catch (error) {
+                // Extension errors are observational in Pi. Abort explicitly so a rejected wait cannot send anyway.
+                ctx.abort();
+                throw error;
+            }
+        });
+        pi.on("after_provider_response", event => { if (event.status >= 400)
+            release(); });
+        pi.on("message_end", event => { if (event.message.role === "assistant")
+            release(); });
+        pi.on("agent_end", release);
+        pi.on("session_shutdown", release);
+    };
+}

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

@@ -11,7 +11,8 @@ export class PiboProviderTelemetryRecorder {
     }
     recordRequestStart(payload, options = {}) {
         const capturedOptions = { ...options, at: options.at ?? new Date().toISOString() };
-        return this.schedule(() => this.recordRequestStartNow(providerPayloadSnapshot(payload), capturedOptions));
+        const captured = providerPayloadSnapshot(payload);
+        return this.schedule({ kind: "start", payload: captured, options: capturedOptions }, () => this.recordRequestStartNow(captured, capturedOptions));
     }
     recordRequestStartNow(payload, options) {
         if (!this.options.store)
@@ -79,7 +80,7 @@ export class PiboProviderTelemetryRecorder {
     }
     recordResponse(input) {
         const captured = { status: input.status, at: input.at ?? new Date().toISOString() };
-        return this.schedule(() => this.recordResponseNow(captured));
+        return this.schedule({ kind: "response", input: captured }, () => this.recordResponseNow(captured));
     }
     recordResponseNow(input) {
         if (!this.options.store)
@@ -141,7 +142,7 @@ export class PiboProviderTelemetryRecorder {
             return undefined;
         const captured = providerAssistantMessageSnapshot(message);
         const capturedOptions = { ...options, at: options.at ?? new Date().toISOString() };
-        return this.schedule(() => this.recordMessageEndNow(captured, capturedOptions));
+        return this.schedule({ kind: "end", message: captured, options: capturedOptions }, () => this.recordMessageEndNow(captured, capturedOptions));
     }
     recordMessageEndNow(message, options) {
         if (!this.options.store)
@@ -159,11 +160,25 @@ export class PiboProviderTelemetryRecorder {
         return this.finishActiveProviderRequest(status, options.at ?? new Date().toISOString(), summary, errorMessage, errorDetails?.category ?? errorDetails?.errorClass);
     }
     recordShutdown(reason, at = new Date().toISOString()) {
-        return this.schedule(() => this.finishActiveProviderRequest("aborted", at, reason, undefined, "runtime_abort"));
+        return this.schedule({ kind: "shutdown", at, reason }, () => this.finishActiveProviderRequest("aborted", at, reason, undefined, "runtime_abort"));
     }
-    schedule(write) {
+    executeTelemetryCommand(command) {
+        switch (command.kind) {
+            case "start":
+                this.recordRequestStartNow(command.payload, command.options);
+                break;
+            case "response":
+                this.recordResponseNow(command.input);
+                break;
+            case "end":
+                this.recordMessageEndNow(command.message, command.options);
+                break;
+            case "shutdown": this.finishActiveProviderRequest("aborted", command.at, command.reason, undefined, "runtime_abort");
+        }
+    }
+    schedule(command, write) {
         if (this.options.writer) {
-            this.options.writer.enqueue(write, this.options.onError);
+            this.options.writer.record({ recorder: "provider", command, session: { ...this.options.session, metadata: { chatRoomId: this.options.session.metadata?.chatRoomId ?? null, rootSessionId: this.options.session.metadata?.rootSessionId ?? null } }, model: this.options.model }, write, this.options.onError);
             return undefined;
         }
         return write();

package/dist/core/runtime-capacity.js ADDED Viewed

@@ -0,0 +1,174 @@
+export function resolveRuntimeCapacityOptions(env = process.env) {
+    const read = (name, fallback) => {
+        if (!env[name]?.trim())
+            return fallback;
+        const n = Number(env[name]);
+        if (!Number.isSafeInteger(n) || n < 1)
+            throw new Error(`${name} must be a positive integer.`);
+        return n;
+    };
+    return {
+        coldStarts: read("PIBO_GATEWAY_MAX_COLD_STARTS", 2), providerTurns: read("PIBO_GATEWAY_MAX_PROVIDER_TURNS", 10),
+        providerTurnsPerRoom: read("PIBO_GATEWAY_MAX_PROVIDER_TURNS_PER_ROOM", 5), maxWaiting: read("PIBO_GATEWAY_MAX_RUNTIME_WAITERS", 64),
+        maxWaitMs: read("PIBO_GATEWAY_MAX_RUNTIME_WAIT_MS", 60_000), maxRuntimes: read("PIBO_GATEWAY_MAX_ACTIVE_RUNTIMES", 32),
+    };
+}
+/** Bounded room round-robin. Cancellation removes a waiter without consuming a slot. */
+export class FairCapacityPool {
+    limit;
+    perRoom;
+    maxWaiting;
+    maxWaitMs;
+    reserved;
+    rooms = new Map();
+    activeRooms = new Map();
+    active = 0;
+    generalActive = 0;
+    generalRooms = new Map();
+    waiting = 0;
+    closed = false;
+    constructor(limit, perRoom, maxWaiting, maxWaitMs, reserved = 0) {
+        this.limit = limit;
+        this.perRoom = perRoom;
+        this.maxWaiting = maxWaiting;
+        this.maxWaitMs = maxWaitMs;
+        this.reserved = reserved;
+        if (!Number.isSafeInteger(reserved) || reserved < 0 || reserved >= limit)
+            throw new Error("Reserved capacity must leave at least one normal slot.");
+        for (const n of [limit, perRoom, maxWaiting, maxWaitMs])
+            if (!Number.isSafeInteger(n) || n < 1)
+                throw new Error("Capacity limits must be positive integers.");
+    }
+    acquire(room, signal, reserved = false) {
+        if (this.closed)
+            return Promise.reject(capacityError("Runtime capacity is closed."));
+        if (signal?.aborted)
+            return Promise.reject(signal.reason ?? capacityError("Capacity wait cancelled."));
+        if (this.waiting >= this.maxWaiting - (reserved ? 0 : Math.min(this.reserved, this.maxWaiting - 1)))
+            return Promise.reject(capacityError("Runtime capacity wait queue is full."));
+        return new Promise((resolve, reject) => {
+            let timer;
+            const cancel = () => {
+                const queue = this.rooms.get(room);
+                const index = queue?.indexOf(waiter) ?? -1;
+                if (index < 0)
+                    return;
+                queue.splice(index, 1);
+                this.waiting--;
+                if (!queue.length)
+                    this.rooms.delete(room);
+                waiter.cleanup();
+                reject(signal?.aborted ? signal.reason : capacityError("Runtime capacity wait deadline exceeded."));
+                this.drain();
+            };
+            const waiter = { room, reserved, queuedAt: Date.now(), resolve, reject, cleanup: () => { clearTimeout(timer); signal?.removeEventListener("abort", cancel); } };
+            const queue = this.rooms.get(room) ?? [];
+            queue.push(waiter);
+            this.rooms.set(room, queue);
+            this.waiting++;
+            timer = setTimeout(cancel, this.maxWaitMs);
+            timer.unref?.();
+            signal?.addEventListener("abort", cancel, { once: true });
+            this.drain();
+        });
+    }
+    snapshot() {
+        let oldest = 0;
+        for (const queue of this.rooms.values())
+            oldest = Math.max(oldest, Date.now() - queue[0].queuedAt);
+        return { active: this.active, waiting: this.waiting, limit: this.limit, perRoom: this.perRoom, reserved: this.reserved, maxWaiting: this.maxWaiting, maxWaitMs: this.maxWaitMs, oldestWaitMs: oldest };
+    }
+    close() {
+        this.closed = true;
+        for (const queue of this.rooms.values())
+            for (const waiter of queue) {
+                waiter.cleanup();
+                waiter.reject(capacityError("Runtime capacity is closed."));
+            }
+        this.rooms.clear();
+        this.waiting = 0;
+    }
+    drain() {
+        while (!this.closed && this.active < this.limit) {
+            const eligible = (waiter) => (this.activeRooms.get(waiter.room) ?? 0) < this.perRoom && (waiter.reserved ||
+                (this.generalActive < this.limit - this.reserved && (this.generalRooms.get(waiter.room) ?? 0) < this.perRoom - Math.min(this.reserved, 1, this.perRoom - 1)));
+            const entry = [...this.rooms].find(([, queue]) => queue.some(eligible));
+            if (!entry)
+                return;
+            const [room, queue] = entry;
+            const [waiter] = queue.splice(queue.findIndex(eligible), 1);
+            this.rooms.delete(room);
+            if (queue.length)
+                this.rooms.set(room, queue);
+            if (!waiter.reserved) {
+                this.generalActive++;
+                this.generalRooms.set(room, (this.generalRooms.get(room) ?? 0) + 1);
+            }
+            this.waiting--;
+            this.active++;
+            this.activeRooms.set(room, (this.activeRooms.get(room) ?? 0) + 1);
+            waiter.cleanup();
+            let released = false;
+            waiter.resolve({ release: () => {
+                    if (released)
+                        return;
+                    released = true;
+                    this.active--;
+                    if (!waiter.reserved) {
+                        this.generalActive--;
+                        const general = this.generalRooms.get(room) - 1;
+                        if (general)
+                            this.generalRooms.set(room, general);
+                        else
+                            this.generalRooms.delete(room);
+                    }
+                    const count = this.activeRooms.get(room) - 1;
+                    if (count)
+                        this.activeRooms.set(room, count);
+                    else
+                        this.activeRooms.delete(room);
+                    this.drain();
+                } });
+        }
+    }
+}
+export class RuntimeCapacity {
+    starts;
+    maxRuntimes;
+    providers = new Map();
+    closed = false;
+    options;
+    constructor(options = {}) {
+        this.options = { ...resolveRuntimeCapacityOptions(), ...options };
+        for (const n of Object.values(this.options))
+            if (!Number.isSafeInteger(n) || n < 1)
+                throw new Error("Runtime capacity limits must be positive integers.");
+        this.maxRuntimes = this.options.maxRuntimes;
+        this.starts = new FairCapacityPool(this.options.coldStarts, 1, this.options.maxWaiting, this.options.maxWaitMs);
+    }
+    async acquireProvider(provider, room, signal, nested = false) {
+        if (this.closed)
+            throw capacityError("Runtime capacity is closed.");
+        let pool = this.providers.get(provider);
+        if (!pool) {
+            if (this.providers.size >= 64)
+                throw capacityError("Active provider capacity registry is full.");
+            pool = new FairCapacityPool(this.options.providerTurns, this.options.providerTurnsPerRoom, this.options.maxWaiting, this.options.maxWaitMs, Math.min(2, this.options.providerTurns - 1));
+            this.providers.set(provider, pool);
+        }
+        try {
+            const lease = await pool.acquire(room, signal, nested);
+            return { release: () => { lease.release(); this.removeIdleProvider(provider, pool); } };
+        }
+        catch (error) {
+            this.removeIdleProvider(provider, pool);
+            throw error;
+        }
+    }
+    snapshot() { return { coldStarts: this.starts.snapshot(), maxRuntimes: this.maxRuntimes, providers: [...this.providers].map(([provider, pool]) => ({ provider, ...pool.snapshot() })) }; }
+    close() { this.closed = true; this.starts.close(); for (const pool of this.providers.values())
+        pool.close(); this.providers.clear(); }
+    removeIdleProvider(provider, pool) { const state = pool.snapshot(); if (!state.active && !state.waiting && this.providers.get(provider) === pool)
+        this.providers.delete(provider); }
+}
+function capacityError(message) { return Object.assign(new Error(message), { code: "runtime_capacity_unavailable" }); }

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

@@ -1,5 +1,13 @@
 import { BestEffortTelemetryService, } from "../data/telemetry.js";
 import { isTerminalProviderStatus } from "./provider-telemetry.js";
+/** Diagnostic cache only: terminal events clear their keys; the cap also contains orphaned/incomplete histories. */
+class TelemetryProgressMap extends Map {
+    set(key, value) {
+        if (!this.has(key) && this.size >= 1024)
+            this.delete(this.keys().next().value);
+        return super.set(key, value);
+    }
+}
 const TERMINAL_TURN_STATUSES = new Set(["ok", "error", "aborted", "timeout"]);
 const DEFAULT_PROGRESS_FLUSH_INTERVAL_MS = 1_000;
 export class PiboRuntimeTelemetryRecorder {
@@ -9,10 +17,11 @@ export class PiboRuntimeTelemetryRecorder {
     providerEventMode;
     progressFlushIntervalMs;
     writer;
-    pendingProviderProgress = new Map();
-    providerRequestCache = new Map();
-    lastProviderFlushAtMs = new Map();
-    lastProgressWriteAtMs = new Map();
+    phaseSequences = new TelemetryProgressMap();
+    pendingProviderProgress = new TelemetryProgressMap();
+    providerRequestCache = new TelemetryProgressMap();
+    lastProviderFlushAtMs = new TelemetryProgressMap();
+    lastProgressWriteAtMs = new TelemetryProgressMap();
     constructor(store, onError, options = {}) {
         this.store = store;
         this.onError = onError;
@@ -29,7 +38,7 @@ export class PiboRuntimeTelemetryRecorder {
             return;
         const captured = captureTelemetryContext(context);
         const capturedEvent = telemetryOutputEventSnapshot(event);
-        this.schedule(() => this.recordOutputUnsafe(capturedEvent, captured));
+        this.schedule({ kind: "output", event: capturedEvent, context: captured }, () => this.recordOutputUnsafe(capturedEvent, captured));
     }
     recordPiEvent(piboSessionId, event, context = {}) {
         if (!this.store)
@@ -38,20 +47,29 @@ export class PiboRuntimeTelemetryRecorder {
         if (!summary)
             return;
         const captured = captureTelemetryContext(context);
-        this.schedule(() => this.recordPiEventSummaryUnsafe(piboSessionId, summary, captured));
+        this.schedule({ kind: "pi", piboSessionId, summary, context: captured }, () => this.recordPiEventSummaryUnsafe(piboSessionId, summary, captured));
     }
     recordMessagesInterrupted(messages, context = {}, reason = "message interrupted") {
         if (!this.store)
             return;
         const captured = captureTelemetryContext(context);
         const interrupted = messages.flatMap((message) => message.id ? [{ piboSessionId: message.piboSessionId, eventId: message.id }] : []);
-        this.schedule(() => {
+        this.schedule({ kind: "interrupted", messages: interrupted, context: captured, reason }, () => {
             for (const message of interrupted) {
                 this.recordTurnTerminal(message, captured, "aborted", "abort", reason, "runtime_abort");
             }
         });
     }
-    schedule(write) {
+    executeTelemetryCommand(command) {
+        if (command.kind === "output")
+            this.recordOutputUnsafe(command.event, command.context);
+        else if (command.kind === "pi")
+            this.recordPiEventSummaryUnsafe(command.piboSessionId, command.summary, command.context);
+        else
+            for (const message of command.messages)
+                this.recordTurnTerminal(message, command.context, "aborted", "abort", command.reason, "runtime_abort");
+    }
+    schedule(command, write) {
         const guarded = () => {
             try {
                 write();
@@ -61,7 +79,7 @@ export class PiboRuntimeTelemetryRecorder {
             }
         };
         if (this.writer)
-            this.writer.enqueue(guarded, this.onError);
+            this.writer.record({ recorder: "runtime", command, providerEventMode: this.providerEventMode, progressFlushIntervalMs: this.progressFlushIntervalMs }, guarded, this.onError);
         else
             guarded();
     }
@@ -581,6 +599,10 @@ export class PiboRuntimeTelemetryRecorder {
             counters: options.counters,
             summary,
         });
+        if (phase && !existing) {
+            const key = phaseId(turn.turnId, phaseName);
+            this.phaseSequences.set(key, (this.phaseSequences.get(key) ?? 0) + 1);
+        }
         if (options.updateTurn) {
             this.telemetry.upsertTurn({
                 turnId: turn.turnId,
@@ -602,7 +624,8 @@ export class PiboRuntimeTelemetryRecorder {
     }
     nextPhaseId(turnId, phaseName) {
         const base = phaseId(turnId, phaseName);
-        const count = this.store?.countPhasesForTurn(turnId, phaseName) ?? 0;
+        const count = this.phaseSequences.get(base) ?? this.store?.countPhasesForTurn(turnId, phaseName) ?? 0;
+        this.phaseSequences.set(base, count);
         if (count === 0)
             return base;
         return `${base}:${count + 1}`;
@@ -718,6 +741,9 @@ export class PiboRuntimeTelemetryRecorder {
         this.lastProviderFlushAtMs.delete(turnId);
     }
     clearTurnProgress(turnId) {
+        for (const key of this.phaseSequences.keys())
+            if (key.startsWith(`${turnId}:`))
+                this.phaseSequences.delete(key);
         this.clearProviderProgress(turnId);
         const prefix = `${turnId}:`;
         for (const key of this.lastProgressWriteAtMs.keys()) {
@@ -1069,6 +1095,8 @@ function telemetryOutputEventSnapshot(event) {
         return { ...event, result: event.isError ? safeErrorMessage(event.result) : undefined };
     if (event.type === "execution_result")
         return { ...event, result: undefined };
+    if (event.type === "assistant_delta" || event.type === "thinking_delta" || event.type === "assistant_message" || event.type === "message_queued" || event.type === "message_started")
+        return { ...event, text: "" };
     return { ...event };
 }
 function captureTelemetryContext(context) {
@@ -1076,8 +1104,8 @@ function captureTelemetryContext(context) {
     const atMs = context.atMs ?? (Number.isFinite(parsedAtMs) ? parsedAtMs : Date.now());
     return {
         ...context,
-        session: context.session ? { ...context.session, metadata: context.session.metadata ? { ...context.session.metadata } : undefined } : undefined,
-        status: context.status ? { ...context.status, activeTools: [...context.status.activeTools], enabledTools: [...context.status.enabledTools] } : undefined,
+        session: context.session ? { ...context.session, metadata: context.session.metadata ? { chatRoomId: context.session.metadata.chatRoomId, rootSessionId: context.session.metadata.rootSessionId } : undefined } : undefined,
+        status: context.status ? { ...context.status, activeTools: [], enabledTools: [] } : undefined,
         at: context.at ?? new Date(atMs).toISOString(),
         atMs,
     };

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

@@ -1,3 +1,6 @@
+import { previouslyClearedMessages } from "./events.js";
+import { createProviderCapacityExtension } from "./provider-capacity.js";
+import { RuntimeCapacity } from "./runtime-capacity.js";
 import { randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
 import { InitialSessionContext, } from "./profiles.js";
@@ -333,6 +336,10 @@ function providerEventTelemetryModeFromEnv(env = process.env) {
 export class PiboSessionRouter {
     options;
     sessions = new Map();
+    capacity;
+    creatingRuntimes = 0;
+    initializationTimings = [];
+    pendingStartAborts = new Map();
     pendingSessions = new Map();
     listeners = new Set();
     outputRenderSequencer;
@@ -378,6 +385,7 @@ export class PiboSessionRouter {
     closing = false;
     constructor(options = {}) {
         this.options = options;
+        this.capacity = new RuntimeCapacity(options.runtimeCapacity);
         this.pluginRegistry = options.pluginRegistry ?? createDefaultPiboPluginRegistry();
         // Historical custom registries supplied only actions/profiles while runtime creation was implicit.
         // Preserve that composition contract during the adapter migration without branching on adapter ids.
@@ -450,6 +458,16 @@ export class PiboSessionRouter {
     async emit(event) {
         if (this.closing)
             throw new Error("Pibo session router is disposed.");
+        if (event.type === "execution" && !this.sessions.has(event.piboSessionId) && (event.action === "abort" || event.action === "clear_queue")) {
+            this.resolvePiboSession(event.piboSessionId);
+            if (event.action === "abort") {
+                this.invalidateRunReminders([event.piboSessionId]);
+                this.pendingStartAborts.get(event.piboSessionId)?.abort(Object.assign(new Error("Runtime start aborted before message dispatch."), { code: "runtime_start_cancelled" }));
+            }
+            const output = { type: "execution_result", piboSessionId: event.piboSessionId, eventId: event.id, action: event.action, result: event.action === "abort" ? { aborted: true } : { cleared: previouslyClearedMessages(event) } };
+            this.emitOutput(output);
+            return output;
+        }
         let messageSignalAccepted = false;
         const acceptMessageSignal = () => {
             if (event.type !== "message" || !event.id || messageSignalAccepted)
@@ -1126,6 +1144,7 @@ export class PiboSessionRouter {
         if (this.disposePromise)
             return this.disposePromise;
         this.closing = true;
+        this.capacity.close();
         this.disposePromise = this.disposeAllUnsafe();
         return this.disposePromise;
     }
@@ -1245,16 +1264,65 @@ export class PiboSessionRouter {
         const pending = this.pendingSessions.get(piboSessionId);
         if (pending)
             return pending;
-        const created = this.createRoutedSession(piboSessionId);
+        const startAbort = new AbortController();
+        this.pendingStartAborts.set(piboSessionId, startAbort);
+        const created = this.createRoutedSessionWithinCapacity(piboSessionId, startAbort.signal);
         this.pendingSessions.set(piboSessionId, created);
         try {
             return await created;
         }
         finally {
             this.pendingSessions.delete(piboSessionId);
+            if (this.pendingStartAborts.get(piboSessionId) === startAbort)
+                this.pendingStartAborts.delete(piboSessionId);
+        }
+    }
+    getRuntimeCapacityStatus() { return { ...this.capacity.snapshot(), telemetry: this.telemetryWriter?.status(), activeRuntimes: this.sessions.size, initializingRuntimes: this.creatingRuntimes, recentInitializations: this.initializationTimings.map(item => ({ ...item, phases: { ...item.phases } })) }; }
+    async createRoutedSessionWithinCapacity(piboSessionId, signal) {
+        const stored = this.resolvePiboSession(piboSessionId);
+        const room = typeof stored.metadata?.chatRoomId === "string" ? stored.metadata.chatRoomId : piboSessionId;
+        const queuedAt = performance.now();
+        const lease = await this.capacity.starts.acquire(room, signal);
+        const startedAt = performance.now();
+        const phases = {};
+        let outcome = "failed";
+        try {
+            signal.throwIfAborted();
+            if (this.closing || this.quiescingSessions.has(piboSessionId))
+                throw new Error("Runtime start cancelled during session shutdown.");
+            if (this.sessions.size + this.creatingRuntimes >= this.capacity.maxRuntimes) {
+                const idle = [...this.sessions].find(([id, session]) => { if (this.pendingSessions.has(id))
+                    return false; const status = session.getStatus(); return !status.disposed && !status.processing && !status.streaming && status.queuedMessages === 0; });
+                if (idle)
+                    await this.evictIdleSession(idle[0], idle[1]);
+            }
+            if (this.sessions.size + this.creatingRuntimes >= this.capacity.maxRuntimes)
+                throw Object.assign(new Error("Active runtime capacity reached."), { code: "runtime_capacity_unavailable" });
+            this.creatingRuntimes++;
+            try {
+                const session = await this.createRoutedSession(piboSessionId, phases);
+                if (signal.aborted) {
+                    if (this.sessions.get(piboSessionId) === session)
+                        this.sessions.delete(piboSessionId);
+                    await this.disposeRoutedSession(piboSessionId, session, "cold start aborted");
+                    throw signal.reason;
+                }
+                outcome = "ready";
+                return session;
+            }
+            finally {
+                this.creatingRuntimes--;
+            }
+        }
+        finally {
+            lease.release();
+            this.initializationTimings.push({ sessionId: piboSessionId, waitMs: startedAt - queuedAt, totalMs: performance.now() - startedAt, phases, outcome });
+            if (this.initializationTimings.length > 32)
+                this.initializationTimings.shift();
         }
     }
-    async createRoutedSession(piboSessionId) {
+    async createRoutedSession(piboSessionId, phases = {}) {
+        let phaseStarted = performance.now();
         const piboSession = this.resolvePiboSession(piboSessionId);
         let session;
         this.signalRegistry.project({ type: "session_created", session: piboSession });
@@ -1313,6 +1381,8 @@ export class PiboSessionRouter {
         if (invalidProfile) {
             throw new Error(`Runtime profile validation failed: ${invalidProfile.message}`);
         }
+        phases.bindingAndProfileMs = performance.now() - phaseStarted;
+        phaseStarted = performance.now();
         let historyHandoff;
         if (persistedHistoryHandoff?.mode === "import") {
             if (!runtimeAdapter.descriptor.capabilities.historyImport) {
@@ -1336,6 +1406,8 @@ export class PiboSessionRouter {
         else if (persistedHistoryHandoff?.mode === "fresh") {
             historyHandoff = { mode: "fresh" };
         }
+        phases.portableHistoryMs = performance.now() - phaseStarted;
+        phaseStarted = performance.now();
         const initialFastMode = resolvePiboSessionInitialFastMode(piboSession) ?? selectRequestedFastMode(sessionProfile, modelDefaults) ?? false;
         const agentsController = this.createAgentsController(piboSession.id);
         const runToolController = this.createRunToolController(piboSession.id);
@@ -1380,6 +1452,8 @@ export class PiboSessionRouter {
                 this.portableToolSessions.delete(piboSession.id);
             throw error;
         }
+        phases.resourcesAndToolsMs = performance.now() - phaseStarted;
+        phaseStarted = performance.now();
         const bindingSync = { expectedRevision: binding.revision };
         const runtimeBindingPersistence = createAgentRuntimeBindingPersistence(this.sessionStore, {
             piboSessionId: piboSession.id,
@@ -1423,6 +1497,7 @@ export class PiboSessionRouter {
                         thinkingLevel: initialThinkingLevel ?? this.options.thinkingLevel,
                         retryDefaults: resolvePiboSessionRetryDefaults(piboSession.kind, this.options.retryDefaults),
                         extensionFactories: [
+                            createProviderCapacityExtension(this.capacity, piboRoomIdFromMetadata(piboSession.metadata) ?? piboSession.id, Boolean(piboSession.parentId)),
                             ...(telemetryExtension ? [telemetryExtension] : []),
                             ...(this.options.extensionFactories ?? []),
                         ],
@@ -1492,6 +1567,7 @@ export class PiboSessionRouter {
                 this.runtimeResourceSessions.delete(piboSession.id);
             throw error;
         }
+        phases.adapterOpenAndBindingMs = performance.now() - phaseStarted;
         const resourceInspection = resources.getInspection();
         const statusResources = {
             enabledSkills: [...new Set(resourceInspection.skills.map((skill) => skill.name))],
@@ -1533,6 +1609,7 @@ export class PiboSessionRouter {
                 this.handleInterruptedRunReminders(messages);
             },
             messagePreflight: this.options.messagePreflight,
+            acquireProviderCapacity: runtimeAdapter.descriptor.id === "pi" ? undefined : (provider, signal) => this.capacity.acquireProvider(provider, typeof piboSession.metadata?.chatRoomId === "string" ? piboSession.metadata.chatRoomId : piboSession.id, signal, Boolean(piboSession.parentId)),
             modelFallbacks,
             getRuntimeAuthStatus: () => runtimeRegistry.getAgentRuntimeAuthStatus(binding.runtimeInstanceId),
             startRuntimeAuth: async (input) => {