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

@pasko70/pibo 3.4.4 → 3.5.1

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

package/dist/agent-runtime/routed-session.js +111 -25
package/dist/agent-runtimes/codex-native/turn.js +27 -3
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 +40 -14
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 +37 -3
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 +149 -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 +645 -297
package/dist/apps/chat-ui/assets/{dist-V06sfuZa.js → dist-B-auLrzD.js} +1 -1
package/dist/apps/chat-ui/assets/{dist-CH3SvpYV.js → dist-BA_dsINH.js} +1 -1
package/dist/apps/chat-ui/assets/{dist-23lt_7qm.js → dist-eJZar_0-.js} +1 -1
package/dist/apps/chat-ui/assets/{dist-Bf2KScPo.js → dist-wNNR2Bci.js} +1 -1
package/dist/apps/chat-ui/assets/{dist-DsgL8w-W.js → dist-zcmEsIEp.js} +1 -1
package/dist/apps/chat-ui/assets/index-DEkbN5Vo.js +229 -0
package/dist/apps/chat-ui/assets/index-DZK6Tzil.css +1 -0
package/dist/apps/chat-ui/index.html +2 -2
package/dist/apps/chat-vscode-web/assets/index-DZgW1fCB.js +44 -0
package/dist/apps/chat-vscode-web/index.html +1 -1
package/dist/cli-session/localSessionSource.js +3 -2
package/dist/compute/pool/seeds.js +25 -3
package/dist/core/events.js +4 -0
package/dist/core/output-render-sequence.js +65 -6
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 +178 -13
package/dist/data/async-chat-reads.js +38 -0
package/dist/data/async-chat-storage.js +96 -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 +167 -0
package/dist/data/ingest-service.js +152 -18
package/dist/data/message-command-store.js +290 -0
package/dist/data/payload-store.js +92 -11
package/dist/data/pibo-store.js +10 -8
package/dist/data/schema.js +39 -4
package/dist/data/session-store.js +3 -1
package/dist/data/storage-backup.js +278 -0
package/dist/data/storage-maintenance.js +344 -0
package/dist/data/storage-verification-worker.js +25 -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 +207 -1
package/dist/debug/message-queue.js +108 -0
package/dist/debug/output-collision-repair.js +140 -0
package/dist/debug/output-integrity.js +38 -2
package/dist/debug/output-repair.js +1 -0
package/dist/debug/storage-backup.js +41 -0
package/dist/debug/storage-maintenance.js +78 -0
package/dist/debug/telemetry-capture.js +66 -0
package/dist/gateway/cli.js +71 -7
package/dist/gateway/server.js +3 -0
package/dist/providers/openai-gpt56.js +11 -6
package/dist/reliability/store.js +119 -23
package/dist/session-ui/terminalRows.js +54 -13
package/dist/sessions/pibo-data-store.js +19 -14
package/dist/shared/debug-features.js +4 -0
package/dist/shared/model-inference-metrics.js +23 -0
package/dist/shared/trace-event-projection.js +69 -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 +117 -12
package/dist/web/http.js +135 -41
package/npm-shrinkwrap.json +2 -2
package/package.json +1 -1
package/dist/apps/chat-ui/assets/index-BOceJ0jM.css +0 -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-DZgW1fCB.js"></script>
 		<link rel="stylesheet" crossorigin href="/apps/chat-vscode/assets/index-b18ZkEo0.css">
 	</head>
 	<body>

package/dist/cli-session/localSessionSource.js CHANGED Viewed

@@ -641,7 +641,7 @@ export class LocalCliSessionSource {
             if (delivery.persisted)
                 continue;
             try {
-                this.ingestOutputEvent(session, delivery.event);
+                this.ingestOutputEvent(session, delivery.event, retryContext.attempt > 1 ? "durable-replay" : "live");
             }
             catch (error) {
                 errors.push(error instanceof Error ? error : new Error(String(error)));
@@ -753,7 +753,7 @@ export class LocalCliSessionSource {
             // Persistence is best-effort; live local rendering still proceeds through router events.
         }
     }
-    ingestOutputEvent(session, event) {
+    ingestOutputEvent(session, event, phase) {
         if (!this.ingestService)
             return;
         this.ingestService.ingestOutputEvent({
@@ -762,6 +762,7 @@ export class LocalCliSessionSource {
             actorId: session.profile,
             event,
             createdAt: this.now(),
+            persistenceProvenance: { producer: "local-cli", projection: "product-history", phase },
         });
     }
     buildStatus(session) {

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

@@ -109,9 +109,10 @@ export class OutputRenderSequencer {
         const suppliedPart = transition.suppliedIndex === undefined
             ? undefined
             : parts.find((part) => part.index === transition.suppliedIndex);
-        if (transition.suppliedIndex !== undefined && (transition.canonicalIndex || suppliedPart)) {
+        if (transition.suppliedIndex !== undefined && (transition.canonicalIndex
+            || (suppliedPart && (!suppliedPart.closed || suppliedPart.identityFingerprint === transition.identityFingerprint)))) {
             this.highWaterStore?.observeOutputPart?.({ ...transition, index: transition.suppliedIndex });
-            this.recordOutputPart(parts, transition.suppliedIndex, transition.terminal);
+            this.recordOutputPart(parts, transition.suppliedIndex, transition.terminal, transition.identityFingerprint);
             this.trimOutputParts(state);
             return event;
         }
@@ -122,18 +123,20 @@ export class OutputRenderSequencer {
         const index = latestOpen
             ? localIndex
             : this.highWaterStore?.claimOrAttachOutputPart?.({ ...transition, proposedIndex: localIndex }) ?? localIndex;
-        this.recordOutputPart(parts, index, transition.terminal);
+        this.recordOutputPart(parts, index, transition.terminal, transition.identityFingerprint);
         this.trimOutputParts(state);
         return withOutputPartIndex(event, transition.kind, index);
     }
-    recordOutputPart(parts, index, terminal) {
+    recordOutputPart(parts, index, terminal, identityFingerprint) {
         let part = parts.find((candidate) => candidate.index === index);
         if (!part) {
-            part = { index, closed: false };
+            part = { index, closed: false, identityFingerprint };
             parts.push(part);
         }
-        if (terminal)
+        if (terminal) {
             part.closed = true;
+            part.identityFingerprint = identityFingerprint;
+        }
     }
     trimOutputParts(state) {
         let total = 0;
@@ -380,11 +383,66 @@ function outputPartTransition(event, activeEventId) {
 function validOutputPartIndex(value) {
     return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
 }
+export const OUTPUT_IDENTITY_FINGERPRINT_VERSION = 2;
 export function outputIdentityFingerprint(event) {
+    return createHash("sha256").update(stableJson(outputIdentityPayload(event))).digest("hex");
+}
+/** Exact v1 algorithm retained only for comparing pre-v2 persisted fingerprints. */
+export function legacyOutputIdentityFingerprint(event) {
     const payload = { ...event };
     delete payload.renderSequence;
+    delete payload.compactionStats;
     return createHash("sha256").update(stableJson(payload)).digest("hex");
 }
+export function legacyOutputIdentityFingerprintCandidates(event) {
+    const variants = [{ ...event }];
+    const assistant = event.type === "assistant_delta" || event.type === "assistant_message";
+    const thinking = event.type === "thinking_started" || event.type === "thinking_delta" || event.type === "thinking_finished";
+    const index = assistant ? event.assistantIndex ?? event.contentIndex : thinking ? event.thinkingIndex ?? event.contentIndex : undefined;
+    if (index !== undefined && (assistant || thinking)) {
+        for (const attribute of assistant ? ["assistantIndex", "contentIndex"] : ["thinkingIndex", "contentIndex"]) {
+            const variant = { ...event };
+            delete variant.assistantIndex;
+            delete variant.thinkingIndex;
+            delete variant.contentIndex;
+            variant[attribute] = index;
+            variants.push(variant);
+        }
+    }
+    for (const variant of [...variants]) {
+        if ("provenance" in variant) {
+            const withoutProvenance = { ...variant };
+            delete withoutProvenance.provenance;
+            variants.push(withoutProvenance);
+        }
+    }
+    return [...new Set(variants.map((variant) => legacyOutputIdentityFingerprint(variant)))];
+}
+/** Redacted, bounded evidence for diagnosing a fingerprint mismatch without retaining values. */
+export function outputIdentityFieldDigests(event) {
+    return Object.fromEntries(Object.entries(outputIdentityPayload(event))
+        .slice(0, 64)
+        .map(([field, value]) => [field, createHash("sha256").update(stableJson(value)).digest("hex").slice(0, 16)]));
+}
+function outputIdentityPayload(event) {
+    const payload = { ...event };
+    delete payload.renderSequence;
+    delete payload.compactionStats;
+    // Delivery provenance describes how equivalent output reached persistence; it
+    // is diagnostic metadata rather than semantic message content.
+    delete payload.provenance;
+    if (event.type === "assistant_delta" || event.type === "assistant_message") {
+        delete payload.assistantIndex;
+        delete payload.contentIndex;
+        payload.outputPartIndex = event.assistantIndex ?? event.contentIndex ?? 0;
+    }
+    else if (event.type === "thinking_started" || event.type === "thinking_delta" || event.type === "thinking_finished") {
+        delete payload.thinkingIndex;
+        delete payload.contentIndex;
+        payload.outputPartIndex = event.thinkingIndex ?? event.contentIndex ?? 0;
+    }
+    return payload;
+}
 export function outputPartFingerprint(event) {
     const payload = { ...event };
     delete payload.renderSequence;
@@ -393,6 +451,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,
     };