@pasko70/pibo 3.4.3 → 3.5.0

package/dist/agent-runtime/routed-session.js

@@ -1,3 +1,4 @@
+import { previouslyClearedMessages } from "../core/events.js";
 import { PiboSteeringUnavailableError, } from "../core/events.js";
 import { PIBO_PROVIDER_RECOVERY_PROMPT, isPiboProviderFallbackError } from "../core/provider-recovery.js";
 import { normalizeSessionErrorDetails, runtimeSessionErrorDetails } from "../core/session-errors.js";
@@ -166,8 +167,14 @@ export class RuntimeRoutedSession {
         if (this.sessionIdentityOperationInFlight && !this.forkCandidatesRequest) {
             throw new Error("Pibo session cannot accept messages while a session identity operation is in progress.");
         }
+        const messages = this.queue.filter(item => item.kind === "message");
+        const bytes = Buffer.byteLength(event.text);
+        if (bytes > 1024 * 1024 || messages.length >= 64 || messages.reduce((total, item) => total + Buffer.byteLength(item.event.text), bytes) > 4 * 1024 * 1024
+            || messages.some(item => Date.now() - item.acceptedAt >= 10 * 60 * 1000)) {
+            throw Object.assign(new Error("Session runtime queue count, byte or wait-age capacity reached."), { code: "runtime_capacity_unavailable" });
+        }
         onAccepted();
-        this.queue.push({ kind: "message", event });
+        this.queue.push({ kind: "message", event, acceptedAt: Date.now() });
         const output = {
             type: "message_queued",
             piboSessionId: this.piboSessionId,
@@ -297,6 +304,8 @@ export class RuntimeRoutedSession {
                 revision: binding.revision,
             },
             queuedMessages: this.queue.length,
+            activeEventId: this.activeMessage?.id ?? this.activeExecutionEvent?.id,
+            queuedEventIds: this.queue.map((item) => item.event.id ?? ""),
             processing: this.disposed ? false : this.processing,
             streaming: this.disposed ? false : status.streaming,
             activeTools: [...status.enabledTools],
@@ -591,6 +600,7 @@ export class RuntimeRoutedSession {
         if (inFlight?.event.id === eventId) {
             if (!inFlight.cancellation) {
                 inFlight.cancelled = true;
+                inFlight.capacityAbort.abort(new Error("Message cancelled while waiting for capacity."));
                 this.notifyMessagesInterrupted([inFlight.event], "message cancelled");
                 const active = this.activeMessage?.id === eventId;
                 inFlight.cancellation = (async () => {
@@ -708,6 +718,7 @@ export class RuntimeRoutedSession {
                     result: event.result,
                     aborted: event.aborted,
                     errorMessage: event.errorMessage,
+                    compactionStats: event.compactionStats,
                 }));
                 return;
             case "approval_requested":
@@ -813,11 +824,29 @@ export class RuntimeRoutedSession {
             this.notifyState();
         }
     }
+    async promptWithinCapacity(event, inFlight, input) {
+        const provider = this.runtimeSession.getStatus().activeModel?.provider ?? this.runtimeSession.runtimeInstanceId;
+        const lease = await this.options.acquireProviderCapacity?.(provider, inFlight.capacityAbort.signal);
+        try {
+            if (this.disposed || inFlight.cancelled)
+                return;
+            if (!inFlight.started) {
+                inFlight.started = true;
+                this.emit({ type: "message_started", piboSessionId: this.piboSessionId, eventId: event.id, text: event.text, source: event.source, provenance: event.provenance });
+            }
+            if (this.disposed || inFlight.cancelled)
+                return;
+            await this.runtimeSession.prompt(input);
+        }
+        finally {
+            lease?.release();
+        }
+    }
     async promptWithModelFallbacks(event, inFlight) {
         const canSetModel = Boolean(this.runtimeSession.controls?.setModel);
         const fallbackModels = this.modelFallbacks.filter((model) => !sameModel(model, this.primaryModel));
         if (!canSetModel || fallbackModels.length === 0) {
-            await this.runtimeSession.prompt({
+            await this.promptWithinCapacity(event, inFlight, {
                 text: event.text,
                 source: promptSource(event.source),
                 capabilityScope: event.capabilityScope,
@@ -843,7 +872,7 @@ export class RuntimeRoutedSession {
                 this.pendingProviderFailure = undefined;
                 let promptError;
                 try {
-                    await this.runtimeSession.prompt({
+                    await this.promptWithinCapacity(event, inFlight, {
                         text: attempt === 0 ? event.text : PIBO_PROVIDER_RECOVERY_PROMPT,
                         source: attempt === 0 ? promptSource(event.source) : "rpc",
                         capabilityScope: event.capabilityScope,
@@ -905,14 +934,6 @@ export class RuntimeRoutedSession {
             this.activeMessageFailed = false;
             this.beginRunReminderTurnGuard(event);
             this.resetContentIndices();
-            this.emit({
-                type: "message_started",
-                piboSessionId: this.piboSessionId,
-                eventId: event.id,
-                text: event.text,
-                source: event.source,
-                provenance: event.provenance,
-            });
             if (inFlight.cancelled)
                 return;
             await this.promptWithModelFallbacks(event, inFlight);
@@ -961,6 +982,7 @@ export class RuntimeRoutedSession {
         const inFlight = {
             event,
             cancelled: false,
+            capacityAbort: new AbortController(),
             settled: new Promise((resolve) => { resolveSettled = resolve; }),
             resolveSettled: () => { resolveSettled?.(); },
         };
@@ -1127,8 +1149,12 @@ export class RuntimeRoutedSession {
                 ? await this.options.logoutRuntimeAuth(input)
                 : await this.pluginRegistry.logoutAgentRuntimeAuth(this.runtimeSession.runtimeInstanceId, input),
             getProviderUsage: () => this.getActionProviderUsage(),
-            clearQueue: () => this.clearQueue(),
+            clearQueue: () => this.clearQueue() + previouslyClearedMessages(event),
             abort: async () => {
+                if (this.inFlightMessage && !this.inFlightMessage.started) {
+                    await this.cancelMessage(this.inFlightMessage.event.id);
+                    return;
+                }
                 if (this.activeMessage)
                     this.notifyMessagesInterrupted([this.activeMessage], "abort requested");
                 await this.runtimeSession.abort();
@@ -1185,6 +1211,7 @@ export class RuntimeRoutedSession {
         if (this.disposed)
             return false;
         const activeMessage = this.activeMessage;
+        this.inFlightMessage?.capacityAbort.abort(new Error(reason));
         this.notifyMessagesInterrupted(this.activeAndQueuedMessages(), reason);
         if (activeMessage) {
             const error = `Session disposed while a message was active: ${reason}`;

package/dist/agent-runtimes/codex-native/adapter.js

@@ -16,6 +16,7 @@ import { CodexNativeResourceDelivery } from "./resource-delivery.js";
 import { CODEX_NATIVE_MODEL_OPTIONS_SCHEMA, CODEX_NATIVE_MODEL_PROVIDER_ID, CODEX_NATIVE_REASONING_VALUES, CodexNativeSessionSettingsController, parseCodexNativeProfileOptions, readCodexNativeModelCatalog, readCodexNativePersistedSettings, toAgentRuntimeModelCatalog, } from "./models.js";
 import { CodexNativeAuthController } from "./auth.js";
 import { injectPortableHistoryIntoCodex } from "./portable-history.js";
+import { readCodexNativeProviderUsage } from "./provider-usage.js";
 import { CODEX_FIRST_USE_METADATA_KEY, CODEX_FIRST_USE_METADATA_VERSION, assertCodexNativeFirstUseMessageId, assertCodexNativeFirstUseDeliveryReceiptTurn, assertCodexNativePendingFirstUseRequest, assertCodexNativePendingFirstUseTurn, beginCodexNativeFirstUseAttempt, codexNativeFirstUseDeliveryReceipt, codexNativePendingFirstUseOwnerLiveness, endCodexNativeFirstUseAttempt, hashCanonicalCodexNativeFirstUsePrompt, isExactCodexNativeFirstUseDeliveryReplay, readCodexNativeFirstUseDeliveryReceipt, readCodexNativePendingFirstUse, } from "./first-use.js";
 export { CODEX_NATIVE_ADAPTER_ID } from "./thread.js";
 export const CODEX_NATIVE_ADAPTER_VERSION = "1.0.0";
@@ -490,6 +491,16 @@ export class CodexNativeThreadSession {
             ],
         };
     }
+    async getStatusSnapshot() {
+        const status = this.getStatus();
+        try {
+            const providerUsage = await readCodexNativeProviderUsage(this.process.client);
+            return providerUsage ? { ...status, providerUsage } : status;
+        }
+        catch {
+            return status;
+        }
+    }
     getNativeCompatibilityHandle() {
         return this.process.client;
     }
@@ -615,8 +626,10 @@ export class CodexNativeThreadSession {
         let reboundSettings = false;
         let phase = "stopping the previous process";
         try {
-            await previousProcess.close();
+            await previousProcess.stop();
             this.resourceProcessUnavailable = true;
+            // Generation cleanup may race with exiting MCP children and must not block App Server replacement.
+            void previousProcess.close().catch(() => { });
             phase = "starting the replacement process";
             next = await this.reloadProcess();
             phase = "resuming the native thread";

package/dist/agent-runtimes/codex-native/models.js

@@ -393,11 +393,11 @@ function setBoundedPending(map, threadId, value) {
     map.set(threadId, value);
 }
 function parseContextUsage(value) {
-    if (!isRecord(value.tokenUsage) || !isRecord(value.tokenUsage.total)) {
-        throw new CodexNativeModelProtocolError("Codex token-usage notification is missing total usage.");
+    if (!isRecord(value.tokenUsage) || !isRecord(value.tokenUsage.last)) {
+        throw new CodexNativeModelProtocolError("Codex token-usage notification is missing last response usage.");
     }
-    const total = value.tokenUsage.total;
-    const tokens = requiredNonNegativeNumber(total.totalTokens, "total token usage");
+    const last = value.tokenUsage.last;
+    const tokens = requiredNonNegativeNumber(last.totalTokens, "last response token usage");
     const contextWindow = value.tokenUsage.modelContextWindow === undefined || value.tokenUsage.modelContextWindow === null
         ? undefined
         : requiredNonNegativeNumber(value.tokenUsage.modelContextWindow, "model context window");

package/dist/agent-runtimes/codex-native/process.js

@@ -6,6 +6,8 @@ import { protectPrivatePathsSync } from "../../core/private-path.js";
 import { CodexAppServerClient } from "./client.js";
 import { CODEX_APP_SERVER_PROTOCOL_NAME, CODEX_APP_SERVER_SUPPORTED_RANGE, CODEX_APP_SERVER_VERSION, } from "./protocol-version.js";
 const MAX_VERSION_OUTPUT_BYTES = 64 * 1024;
+const SESSION_PATH_CLEANUP_MAX_RETRIES = 10;
+const SESSION_PATH_CLEANUP_RETRY_DELAY_MS = 50;
 const PRIVATE_DIRECTORY_MODE = 0o700;
 const PRIVATE_FILE_MODE = 0o600;
 const INSTANCE_CONFIG = [
@@ -161,7 +163,12 @@ export async function prepareCodexNativeSessionPaths(input) {
     }
 }
 export async function disposeCodexNativeSessionPaths(paths) {
-    await rm(paths.generationRoot, { recursive: true, force: true });
+    await rm(paths.generationRoot, {
+        recursive: true,
+        force: true,
+        maxRetries: SESSION_PATH_CLEANUP_MAX_RETRIES,
+        retryDelay: SESSION_PATH_CLEANUP_RETRY_DELAY_MS,
+    });
     await rmdir(paths.sessionRoot).catch((error) => {
         if (error.code !== "ENOTEMPTY" && error.code !== "ENOENT")
             throw error;
@@ -393,23 +400,35 @@ export async function diagnoseCodexNativeRuntime(config, runtimeInstanceId, opti
 export class CodexNativeAppServerProcess {
     client;
     paths;
-    closePromise;
-    constructor(client, paths) {
+    disposePaths;
+    stopPromise;
+    cleanupPromise;
+    pathsDisposed = false;
+    constructor(client, paths, disposePaths = disposeCodexNativeSessionPaths) {
         this.client = client;
         this.paths = paths;
+        this.disposePaths = disposePaths;
+    }
+    async stop() {
+        if (!this.stopPromise)
+            this.stopPromise = this.client.close();
+        await this.stopPromise;
     }
     async close() {
-        if (!this.closePromise) {
-            this.closePromise = (async () => {
-                try {
-                    await this.client.close();
-                }
-                finally {
-                    await disposeCodexNativeSessionPaths(this.paths);
-                }
-            })();
+        await this.stop();
+        if (this.pathsDisposed)
+            return;
+        if (!this.cleanupPromise)
+            this.cleanupPromise = this.disposePaths(this.paths);
+        const cleanup = this.cleanupPromise;
+        try {
+            await cleanup;
+            this.pathsDisposed = true;
+        }
+        finally {
+            if (this.cleanupPromise === cleanup)
+                this.cleanupPromise = undefined;
         }
-        await this.closePromise;
     }
 }
 export async function startCodexNativeAppServer(input) {

package/dist/agent-runtimes/codex-native/provider-usage.js

@@ -0,0 +1,115 @@
+const PROVIDER_ID = "openai-codex";
+const MAX_RATE_LIMIT_BUCKETS = 32;
+const RATE_LIMIT_REQUEST_TIMEOUT_MS = 5_000;
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function optionalString(value, label) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "string")
+        throw new Error(`Codex ${label} is invalid.`);
+    return value;
+}
+function optionalNumber(value, label) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "number" || !Number.isFinite(value))
+        throw new Error(`Codex ${label} is invalid.`);
+    return value;
+}
+function formatWindowDuration(minutes, fallback) {
+    if (minutes === undefined || minutes <= 0)
+        return fallback;
+    if (minutes % (7 * 24 * 60) === 0)
+        return `${minutes / (7 * 24 * 60)}w`;
+    if (minutes % (24 * 60) === 0)
+        return `${minutes / (24 * 60)}d`;
+    if (minutes % 60 === 0)
+        return `${minutes / 60}h`;
+    return `${minutes}m`;
+}
+function normalizeWindow(value, fallbackLabel, prefix) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (!isRecord(value))
+        throw new Error("Codex rate-limit window is invalid.");
+    const used = optionalNumber(value.usedPercent, "rate-limit percentage");
+    if (used === undefined)
+        throw new Error("Codex rate-limit percentage is missing.");
+    const usedPercent = Math.max(0, Math.min(100, used));
+    const duration = optionalNumber(value.windowDurationMins, "rate-limit duration");
+    const resetsAtSeconds = optionalNumber(value.resetsAt, "rate-limit reset time");
+    const windowLabel = `${formatWindowDuration(duration, fallbackLabel)} limit`;
+    return {
+        label: prefix ? `${prefix} ${windowLabel}` : windowLabel,
+        usedPercent,
+        remainingPercent: 100 - usedPercent,
+        ...(resetsAtSeconds !== undefined ? { resetsAt: new Date(resetsAtSeconds * 1_000).toISOString() } : {}),
+    };
+}
+function snapshotLabel(snapshot, fallback) {
+    return optionalString(snapshot.limitName, "rate-limit name") ?? fallback;
+}
+function snapshotLimits(snapshot, prefix) {
+    return [
+        normalizeWindow(snapshot.primary, "primary", prefix),
+        normalizeWindow(snapshot.secondary, "weekly", prefix),
+    ].filter((entry) => Boolean(entry));
+}
+function snapshotCredits(snapshot) {
+    if (snapshot.credits === undefined || snapshot.credits === null)
+        return undefined;
+    if (!isRecord(snapshot.credits) || typeof snapshot.credits.hasCredits !== "boolean" || typeof snapshot.credits.unlimited !== "boolean") {
+        throw new Error("Codex credit snapshot is invalid.");
+    }
+    if (!snapshot.credits.hasCredits)
+        return undefined;
+    return {
+        unlimited: snapshot.credits.unlimited,
+        balance: optionalString(snapshot.credits.balance, "credit balance"),
+    };
+}
+export function normalizeCodexNativeProviderUsage(value) {
+    if (!isRecord(value) || !isRecord(value.rateLimits))
+        throw new Error("Codex rate-limit response is invalid.");
+    const response = value;
+    const primary = response.rateLimits;
+    const limits = [...snapshotLimits(primary)];
+    let planType = optionalString(primary.planType, "plan type");
+    let credits = snapshotCredits(primary);
+    const primaryLimitId = optionalString(primary.limitId, "rate-limit id");
+    const additional = response.rateLimitsByLimitId;
+    if (additional !== undefined && additional !== null) {
+        if (!isRecord(additional))
+            throw new Error("Codex rate-limit bucket map is invalid.");
+        const entries = Object.entries(additional);
+        if (entries.length > MAX_RATE_LIMIT_BUCKETS)
+            throw new Error("Codex returned too many rate-limit buckets.");
+        for (const [limitId, rawSnapshot] of entries) {
+            if (limitId === primaryLimitId)
+                continue;
+            if (!isRecord(rawSnapshot))
+                throw new Error("Codex rate-limit bucket is invalid.");
+            const snapshot = rawSnapshot;
+            const prefix = snapshotLabel(snapshot, limitId);
+            limits.push(...snapshotLimits(snapshot, prefix));
+            planType ??= optionalString(snapshot.planType, "plan type");
+            credits ??= snapshotCredits(snapshot);
+        }
+    }
+    if (limits.length === 0 && !credits)
+        return undefined;
+    return {
+        provider: PROVIDER_ID,
+        ...(planType ? { planType } : {}),
+        limits,
+        ...(credits ? { credits } : {}),
+    };
+}
+export async function readCodexNativeProviderUsage(client) {
+    return normalizeCodexNativeProviderUsage(await client.request("account/rateLimits/read", null, {
+        timeoutMs: RATE_LIMIT_REQUEST_TIMEOUT_MS,
+        retryOverloaded: false,
+    }));
+}

package/dist/agent-runtimes/pi/adapter.js

@@ -253,6 +253,7 @@ export function semanticEventFromPibo(event) {
                 result: event.result,
                 aborted: event.aborted,
                 errorMessage: event.errorMessage,
+                compactionStats: event.compactionStats,
             };
         case "session_error":
             return { type: "error", message: event.error, details: event.errorDetails };

package/dist/agent-runtimes/pi/routed-session.js

@@ -863,8 +863,6 @@ export class RoutedSession {
             if (assistantMessageEnded && !assistantMessageFailed)
                 this.flushPendingProviderWebSearchFinishes();
             const usageEvent = assistantMessageEnded ? normalizeAssistantUsageEvent(this.piboSessionId, candidate?.message) : undefined;
-            if (usageEvent)
-                this.emit(this.withActiveMessage(usageEvent));
             // Pi gets the first chance to recover through its short retry/compaction loop.
             // Keep the final error pending so the routed turn can continue durable recovery.
             if (assistantMessageEnded && normalized?.type === "session_error") {
@@ -889,6 +887,8 @@ export class RoutedSession {
                     this.emit(this.withActiveMessage(normalized));
                 }
             }
+            if (usageEvent)
+                this.emit(this.withActiveMessage(usageEvent));
             if (this.forwardPiEvents) {
                 this.emit({ type: "pi_event", piboSessionId: this.piboSessionId, event });
             }
@@ -1149,6 +1149,8 @@ export class RoutedSession {
         return {
             piboSessionId: this.piboSessionId,
             queuedMessages: this.queue.length,
+            activeEventId: this.activeMessage?.id ?? this.activeExecutionEvent?.id,
+            queuedEventIds: this.queue.map((item) => item.event.id ?? ""),
             processing: this.disposed ? false : this.processing,
             streaming: this.disposed ? false : this.runtime.session.isStreaming,
             activeTools: enabledTools,

package/dist/apps/chat/bounded-event-stream.js

@@ -0,0 +1,98 @@
+/** Owns the only application queue; HWM zero prevents a second hidden stream queue. */
+export class BoundedEventStream {
+    onClose;
+    maximumBytes;
+    maximumAgeMs;
+    maximumFrames;
+    stream;
+    writer;
+    controller;
+    queue = [];
+    bytes = 0;
+    stopped = false;
+    finishing = false;
+    pendingPull;
+    capacityWaiter;
+    timer;
+    constructor(onClose, maximumBytes = 2 * 1024 * 1024, maximumAgeMs = 5000, maximumFrames = 4096) {
+        this.onClose = onClose;
+        this.maximumBytes = maximumBytes;
+        this.maximumAgeMs = maximumAgeMs;
+        this.maximumFrames = maximumFrames;
+        this.stream = new ReadableStream({
+            start: controller => { this.controller = controller; },
+            pull: () => {
+                const frame = this.queue.shift();
+                if (frame) {
+                    this.bytes -= frame.value.byteLength;
+                    this.controller.enqueue(frame.value);
+                    this.releaseCapacity();
+                    if (this.finishing && !this.queue.length)
+                        this.stop("complete");
+                    return;
+                }
+                if (this.finishing || this.stopped) {
+                    this.stop("complete");
+                    return;
+                }
+                return new Promise(resolve => { this.pendingPull = resolve; });
+            },
+            cancel: () => this.stop("cancel"),
+        }, { highWaterMark: 0 });
+        const self = this;
+        this.writer = { enqueue: value => { this.enqueue(value); }, close: () => this.finish(), error: () => this.stop("error"), get desiredSize() { return self.stopped ? null : self.maximumBytes - self.bytes; } };
+        this.timer = setInterval(() => { if (this.queue.length && performance.now() - this.queue[0].at > this.maximumAgeMs)
+            this.stop("slow_age"); }, Math.min(1000, Math.max(5, maximumAgeMs / 2)));
+        this.timer.unref();
+    }
+    get closed() { return this.stopped || this.finishing; }
+    enqueue(value) {
+        if (this.closed)
+            return;
+        if (value.byteLength > this.maximumBytes || this.bytes + value.byteLength > this.maximumBytes || this.queue.length >= this.maximumFrames) {
+            this.stop("slow_bytes");
+            return;
+        }
+        if (this.pendingPull) {
+            const resolve = this.pendingPull;
+            this.pendingPull = undefined;
+            this.controller.enqueue(value);
+            resolve();
+            return;
+        }
+        this.queue.push({ value, at: performance.now() });
+        this.bytes += value.byteLength;
+    }
+    async waitForCapacity() { if (this.closed)
+        return false; if (this.bytes < this.maximumBytes / 2)
+        return true; return new Promise(resolve => { this.capacityWaiter = resolve; }); }
+    releaseCapacity() { if (this.bytes < this.maximumBytes / 2) {
+        this.capacityWaiter?.(!this.closed);
+        this.capacityWaiter = undefined;
+    } }
+    finish() { if (this.stopped)
+        return; this.finishing = true; if (!this.queue.length)
+        this.stop("complete"); }
+    fail() { this.stop("error"); }
+    stop(reason) {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        clearInterval(this.timer);
+        this.queue.length = 0;
+        this.bytes = 0;
+        try {
+            if (reason === "complete")
+                this.controller.close();
+            else if (reason !== "cancel")
+                this.controller.error(Error("Event stream budget exhausted; reconnect using the last received cursor."));
+        }
+        catch { }
+        this.pendingPull?.();
+        this.pendingPull = undefined;
+        this.capacityWaiter?.(false);
+        this.capacityWaiter = undefined;
+        this.onClose(reason);
+    }
+    status() { return { frames: this.queue.length, bytes: this.bytes, oldestAgeMs: this.queue.length ? performance.now() - this.queue[0].at : 0, closed: this.closed }; }
+}

package/dist/apps/chat/chat-settings-routes.js

@@ -8,7 +8,7 @@ import { parseToolMetricTokenCalculation } from "../../shared/tool-call-token-se
 import { PiboWebHttpError, readJsonBody, responseJson } from "../../web/http.js";
 import { CHAT_WEB_API_PREFIX } from "./chat-api-routes.js";
 import { normalizeBasePromptMarkdown, normalizeBasePromptMode, normalizeCompactionPromptMarkdown, normalizeCompactionPromptMode, updateChatModelDefaults, } from "./chat-request-normalizers.js";
-import { pruneTelemetryOlderThan } from "./telemetry-retention-service.js";
+import { pruneTelemetryOlderThanAsync } from "./telemetry-retention-service.js";
 export function chatSettingsRoute(pathname, method) {
     if (pathname === `${CHAT_WEB_API_PREFIX}/model-defaults` && method === "PATCH")
         return { kind: "model-defaults" };
@@ -70,8 +70,8 @@ export async function handleChatSettingsRoute(input) {
         const days = sanitizeTelemetryRetentionDays(body.days);
         if (!days)
             throw new PiboWebHttpError("Invalid telemetry retention days", 400);
-        const result = pruneTelemetryOlderThan({ dataStore: input.dataStore, days, apply: body.dryRun !== true });
-        if (result.applied)
+        const result = await pruneTelemetryOlderThanAsync({ dataStore: input.dataStore, days, apply: body.dryRun !== true, signal: request.signal });
+        if (result.applied && result.completed !== false)
             updateTelemetryRetentionLastPrunedAt(new Date().toISOString());
         return responseJson({ telemetryRetention: result });
     }

package/dist/apps/chat/data/chat-data-mappers.js

@@ -3,13 +3,31 @@ import { roomWorkspaceFromMetadata } from "../types/rooms.js";
 import { tracePayloadRefForStoredPayload } from "../trace-v2.js";
 import { qualifiedToolNodeId } from "../../../shared/trace-tool-identity.js";
 const MAX_TRACE_EVENT_HYDRATION_BYTES = 1024 * 1024;
-export function storedPiboEventFromV2Row(row, payloadStore) {
+export function storedPiboEventFromV2Row(row, payloadStore, hydrationBytes = MAX_TRACE_EVENT_HYDRATION_BYTES) {
+    if (typeof hydrationBytes !== "number" || !Number.isFinite(hydrationBytes))
+        hydrationBytes = MAX_TRACE_EVENT_HYDRATION_BYTES;
     const attributes = parseJsonObject(row.attributes_json);
-    const payload = outputPayloadFromV2Row(row, attributes, readPersistedPayload(row, payloadStore));
+    if (hydrationBytes < MAX_TRACE_EVENT_HYDRATION_BYTES && typeof attributes.inlineText === "string" && Buffer.byteLength(attributes.inlineText) > hydrationBytes)
+        attributes.inlineText = row.preview_text ?? "";
+    const payload = outputPayloadFromV2Row(row, attributes, readPersistedPayload(row, payloadStore, hydrationBytes));
     if (!payload)
         return undefined;
+    const storedPayloadRef = storedPayloadReference(row, attributes, payloadStore);
+    const renderSequence = numberAttribute(attributes, "renderSequence") ?? payload.renderSequence;
+    return { id: String(row.stream_id), piboSessionId: row.session_id ?? undefined, eventSequence: row.session_sequence ?? undefined, renderSequence, eventId: row.event_id ?? undefined, streamId: row.stream_id, storedPayloadRef, type: row.type, createdAt: row.created_at, payload };
+}
+export function storedChatEventFromV2Row(row, payloadStore, hydrationBytes = MAX_TRACE_EVENT_HYDRATION_BYTES) {
+    if (typeof hydrationBytes !== "number" || !Number.isFinite(hydrationBytes))
+        hydrationBytes = MAX_TRACE_EVENT_HYDRATION_BYTES;
+    const attributes = parseJsonObject(row.attributes_json);
+    if (hydrationBytes < MAX_TRACE_EVENT_HYDRATION_BYTES && typeof attributes.inlineText === "string" && Buffer.byteLength(attributes.inlineText) > hydrationBytes)
+        attributes.inlineText = row.preview_text ?? "";
+    const storedPayloadRef = storedPayloadReference(row, attributes, payloadStore);
+    return { storedPayloadRef, streamId: row.stream_id, roomId: row.room_id ?? undefined, piboSessionId: row.session_id ?? undefined, eventId: row.event_id ?? `evt_${row.stream_id}`, eventType: row.type, actorType: actorTypeValue(row.actor_type), actorId: row.actor_id ?? undefined, clientTxnId: typeof attributes.clientTxnId === "string" ? attributes.clientTxnId : undefined, createdAt: row.created_at, retentionClass: retentionClassValue(row.retention_class), payload: (outputPayloadFromV2Row(row, attributes, readPersistedPayload(row, payloadStore, hydrationBytes)) ?? null) };
+}
+function storedPayloadReference(row, attributes, payloadStore) {
     const payloadIdentity = tracePayloadIdentityForEvent(row, attributes);
-    const storedPayloadRef = row.payload_ref && row.session_id && payloadStore && payloadIdentity
+    return row.payload_ref && row.session_id && payloadStore && payloadIdentity
         ? tracePayloadRefForStoredPayload({
             payloadStore,
             piboSessionId: row.session_id,
@@ -17,12 +35,6 @@ export function storedPiboEventFromV2Row(row, payloadStore) {
             ...payloadIdentity,
         })
         : undefined;
-    const renderSequence = numberAttribute(attributes, "renderSequence") ?? payload.renderSequence;
-    return { id: String(row.stream_id), piboSessionId: row.session_id ?? undefined, eventSequence: row.session_sequence ?? undefined, renderSequence, eventId: row.event_id ?? undefined, streamId: row.stream_id, storedPayloadRef, type: row.type, createdAt: row.created_at, payload };
-}
-export function storedChatEventFromV2Row(row, payloadStore) {
-    const attributes = parseJsonObject(row.attributes_json);
-    return { streamId: row.stream_id, roomId: row.room_id ?? undefined, piboSessionId: row.session_id ?? undefined, eventId: row.event_id ?? `evt_${row.stream_id}`, eventType: row.type, actorType: actorTypeValue(row.actor_type), actorId: row.actor_id ?? undefined, clientTxnId: typeof attributes.clientTxnId === "string" ? attributes.clientTxnId : undefined, createdAt: row.created_at, retentionClass: retentionClassValue(row.retention_class), payload: (outputPayloadFromV2Row(row, attributes, readPersistedPayload(row, payloadStore)) ?? null) };
 }
 function outputPayloadFromV2Row(row, attributes, persistedPayload) {
     const inlinePayload = attributes.inlinePayload ?? persistedPayload;
@@ -112,7 +124,7 @@ function outputPayloadFromV2Row(row, attributes, persistedPayload) {
     if (row.type === "compaction_start")
         return { ...base, type: "compaction_start", compactionIndex: numberAttribute(attributes, "compactionIndex"), reason: stringAttribute(attributes, "reason") ?? row.preview_text ?? "unknown" };
     if (row.type === "compaction_end")
-        return { ...base, type: "compaction_end", compactionIndex: numberAttribute(attributes, "compactionIndex"), reason: stringAttribute(attributes, "reason") ?? row.preview_text ?? "unknown", result: inlinePayload, aborted: booleanAttribute(attributes, "aborted") ?? false, errorMessage: stringAttribute(attributes, "errorMessage") };
+        return { ...base, type: "compaction_end", compactionIndex: numberAttribute(attributes, "compactionIndex"), reason: stringAttribute(attributes, "reason") ?? row.preview_text ?? "unknown", result: inlinePayload, aborted: booleanAttribute(attributes, "aborted") ?? false, errorMessage: stringAttribute(attributes, "errorMessage"), compactionStats: isRecord(attributes.compactionStats) ? attributes.compactionStats : undefined };
     if (row.type === "session_error") {
         const error = stringAttribute(attributes, "error") ?? row.preview_text ?? "Error";
         return { ...base, type: "session_error", error, errorDetails: normalizeSessionErrorDetails(error, isRecord(attributes.errorDetails) ? attributes.errorDetails : undefined) };
@@ -121,14 +133,14 @@ function outputPayloadFromV2Row(row, attributes, persistedPayload) {
         return { type: "user.message.accepted", piboSessionId, roomId: row.room_id ?? undefined, text: stringAttribute(attributes, "inlineText") ?? row.preview_text ?? "", clientTxnId: stringAttribute(attributes, "clientTxnId") };
     return { ...base, type: row.type };
 }
-function readPersistedPayload(row, payloadStore) {
+function readPersistedPayload(row, payloadStore, hydrationBytes = MAX_TRACE_EVENT_HYDRATION_BYTES) {
     if (!row.payload_ref || !payloadStore)
         return undefined;
     try {
         const metadata = payloadStore.getPayload(row.payload_ref);
-        if (!metadata || metadata.byteSize > MAX_TRACE_EVENT_HYDRATION_BYTES)
+        if (!metadata || metadata.byteSize > hydrationBytes)
             return undefined;
-        const text = Buffer.from(payloadStore.readPayloadBytesBounded(row.payload_ref, MAX_TRACE_EVENT_HYDRATION_BYTES)).toString("utf8");
+        const text = Buffer.from(payloadStore.readPayloadBytesBounded(row.payload_ref, hydrationBytes)).toString("utf8");
         return metadata.contentType.includes("json") ? JSON.parse(text) : text;
     }
     catch {
@@ -136,6 +148,13 @@ function readPersistedPayload(row, payloadStore) {
     }
 }
 function tracePayloadIdentityForEvent(row, attributes) {
+    const semanticId = stringAttribute(attributes, "semanticEventId") ?? row.event_id;
+    if (semanticId && (row.type === "assistant_message" || row.type === "thinking_finished")) {
+        const thinking = row.type === "thinking_finished";
+        const index = numberAttribute(attributes, thinking ? "thinkingIndex" : "assistantIndex") ?? numberAttribute(attributes, "contentIndex");
+        const identity = index === undefined ? semanticId : `${semanticId}:${thinking ? "thinking" : "assistant"}:${index}`;
+        return { nodeId: `${thinking ? "reasoning" : "assistant"}:${identity}`, payloadKind: thinking ? "reasoning" : "output" };
+    }
     const toolCallId = stringAttribute(attributes, "toolCallId");
     if (!toolCallId)
         return undefined;