@pasko70/pibo 3.4.4 → 3.5.1

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";
@@ -17,6 +18,35 @@ const RUN_REMINDER_MAX_PROVIDER_ROUNDS = 64;
 const RUN_REMINDER_MAX_ACTIVE_TOKENS = 2_000_000;
 export const RUN_REMINDER_MAX_DURATION_MS = 15 * 60 * 1000;
 const RUN_REMINDER_MAX_REPEATED_TOOL_CALLS = 12;
+const RUNTIME_QUEUE_MAX_MESSAGE_BYTES = 1024 * 1024;
+const RUNTIME_QUEUE_MAX_MESSAGES = 64;
+const RUNTIME_QUEUE_MAX_BYTES = 4 * 1024 * 1024;
+const RUNTIME_QUEUE_MAX_WAIT_MS = 10 * 60 * 1000;
+export class RuntimeQueueCapacityError extends Error {
+    dimension;
+    current;
+    limit;
+    code = "runtime_capacity_unavailable";
+    constructor(dimension, current, limit) {
+        super(`Session runtime queue ${dimension} capacity reached (current=${capacityDimensionCurrent(dimension, current)}, limit=${limit}).`);
+        this.dimension = dimension;
+        this.current = current;
+        this.limit = limit;
+        this.name = "RuntimeQueueCapacityError";
+    }
+}
+function capacityDimensionCurrent(dimension, current) {
+    if (dimension === "message_bytes")
+        return current.messageBytes;
+    if (dimension === "queue_count")
+        return current.queueCount;
+    if (dimension === "queue_bytes")
+        return current.queueBytes;
+    return current.oldestWaitMs;
+}
+function isRunReminderMessage(event) {
+    return event.source === "service" && event.text.startsWith("<pibo_run_notification>");
+}
 function serializedToolArgs(value) {
     try {
         return JSON.stringify(value) ?? String(value);
@@ -146,6 +176,7 @@ export class RuntimeRoutedSession {
     modelFallbacks;
     suppressProviderFailures = false;
     pendingProviderFailure;
+    runReminderDeferredWarning;
     unsubscribe;
     constructor(piboSessionId, runtimeSession, emit, pluginRegistry, options = {}) {
         this.piboSessionId = piboSessionId;
@@ -166,8 +197,30 @@ export class RuntimeRoutedSession {
         if (this.sessionIdentityOperationInFlight && !this.forkCandidatesRequest) {
             throw new Error("Pibo session cannot accept messages while a session identity operation is in progress.");
         }
+        if (isRunReminderMessage(event))
+            this.removeQueuedMessages(isRunReminderMessage);
+        const now = this.options.now?.() ?? Date.now();
+        // Run reminders are coalesced service work. They remain bounded on admission,
+        // but cannot age-poison the ordinary message budget while an active turn runs.
+        const messages = this.queue.filter((item) => item.kind === "message" && !isRunReminderMessage(item.event));
+        const messageBytes = Buffer.byteLength(event.text);
+        const queueBytes = messages.reduce((total, item) => total + Buffer.byteLength(item.event.text), messageBytes);
+        const oldestWaitMs = messages.reduce((oldest, item) => Math.max(oldest, now - item.acceptedAt), 0);
+        const current = { messageBytes, queueCount: messages.length, queueBytes, oldestWaitMs };
+        if (messageBytes > RUNTIME_QUEUE_MAX_MESSAGE_BYTES) {
+            throw new RuntimeQueueCapacityError("message_bytes", current, RUNTIME_QUEUE_MAX_MESSAGE_BYTES);
+        }
+        if (messages.length >= RUNTIME_QUEUE_MAX_MESSAGES) {
+            throw new RuntimeQueueCapacityError("queue_count", current, RUNTIME_QUEUE_MAX_MESSAGES);
+        }
+        if (queueBytes > RUNTIME_QUEUE_MAX_BYTES) {
+            throw new RuntimeQueueCapacityError("queue_bytes", current, RUNTIME_QUEUE_MAX_BYTES);
+        }
+        if (oldestWaitMs >= RUNTIME_QUEUE_MAX_WAIT_MS) {
+            throw new RuntimeQueueCapacityError("oldest_wait_age", current, RUNTIME_QUEUE_MAX_WAIT_MS);
+        }
         onAccepted();
-        this.queue.push({ kind: "message", event });
+        this.queue.push({ kind: "message", event, acceptedAt: now });
         const output = {
             type: "message_queued",
             piboSessionId: this.piboSessionId,
@@ -310,7 +363,9 @@ export class RuntimeRoutedSession {
             thinkingLevel,
             fastMode: status.fastMode?.mode === "fast",
             retry: status.retry,
-            warnings: status.warnings,
+            warnings: this.runReminderDeferredWarning
+                ? [...new Set([...(status.warnings ?? []), this.runReminderDeferredWarning])]
+                : status.warnings,
             errors: status.errors,
             ...(pendingApprovals.length > 0
                 ? { pendingApprovals: pendingApprovals.map((request) => structuredClone(request)) }
@@ -329,7 +384,9 @@ export class RuntimeRoutedSession {
             activeModel: status.activeModel,
             contextUsage: status.contextUsage,
             providerUsage: status.providerUsage,
-            warnings: status.warnings,
+            warnings: this.runReminderDeferredWarning
+                ? [...new Set([...(status.warnings ?? []), this.runReminderDeferredWarning])]
+                : status.warnings,
             errors: status.errors,
         };
     }
@@ -376,8 +433,13 @@ export class RuntimeRoutedSession {
         }
         removedMessages.reverse();
         this.notifyMessagesInterrupted(removedMessages, "queued message removed");
+        if (removedMessages.length > 0)
+            this.notifyState();
         return removedMessages.length;
     }
+    setRunReminderDeferredWarning(message) {
+        this.runReminderDeferredWarning = message;
+    }
     getCurrentSession() {
         const getCurrentSession = this.runtimeSession.controls?.getCurrentSession;
         if (!getCurrentSession)
@@ -593,6 +655,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 () => {
@@ -618,24 +681,23 @@ export class RuntimeRoutedSession {
         }
         return false;
     }
+    runtimeAssistantIndices = new Map();
     handleRuntimeEvent(event) {
         switch (event.type) {
             case "assistant_delta":
-                this.emit(this.withActiveMessage({
-                    type: "assistant_delta",
+            case "assistant_message": {
+                const output = this.withActiveMessage({
+                    type: event.type,
                     piboSessionId: this.piboSessionId,
                     text: event.text,
                     contentIndex: event.contentIndex,
-                }));
-                return;
-            case "assistant_message":
-                this.emit(this.withActiveMessage({
-                    type: "assistant_message",
-                    piboSessionId: this.piboSessionId,
-                    text: event.text,
-                    contentIndex: event.contentIndex,
-                }));
+                });
+                if ((output.type === "assistant_delta" || output.type === "assistant_message") && event.contentIndex !== undefined && output.assistantIndex !== undefined) {
+                    this.runtimeAssistantIndices.set(event.contentIndex, output.assistantIndex);
+                }
+                this.emit(output);
                 return;
+            }
             case "reasoning_started":
                 this.emit(this.withActiveMessage({
                     type: "thinking_started",
@@ -677,6 +739,12 @@ export class RuntimeRoutedSession {
                 this.emit(this.withActiveMessage({
                     type: "assistant_usage",
                     piboSessionId: this.piboSessionId,
+                    ...(event.inferenceId ? { inferenceId: event.inferenceId } : {}),
+                    ...(event.target ? { inferenceTarget: event.target.type === "assistant"
+                            ? (this.runtimeAssistantIndices.has(event.target.contentIndex)
+                                ? { type: "assistant", assistantIndex: this.runtimeAssistantIndices.get(event.target.contentIndex) }
+                                : { type: "turn" })
+                            : event.target } : {}),
                     inputTokens: event.usage.inputTokens,
                     outputTokens: event.usage.outputTokens,
                     cacheReadTokens: event.usage.cacheReadTokens,
@@ -710,6 +778,7 @@ export class RuntimeRoutedSession {
                     result: event.result,
                     aborted: event.aborted,
                     errorMessage: event.errorMessage,
+                    compactionStats: event.compactionStats,
                 }));
                 return;
             case "approval_requested":
@@ -815,11 +884,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,
@@ -845,7 +932,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,
@@ -907,14 +994,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);
@@ -963,6 +1042,7 @@ export class RuntimeRoutedSession {
         const inFlight = {
             event,
             cancelled: false,
+            capacityAbort: new AbortController(),
             settled: new Promise((resolve) => { resolveSettled = resolve; }),
             resolveSettled: () => { resolveSettled?.(); },
         };
@@ -1129,8 +1209,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();
@@ -1187,6 +1271,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}`;
@@ -1262,6 +1347,7 @@ export class RuntimeRoutedSession {
     }
     resetContentIndices() {
         this.closeActiveContentParts();
+        this.runtimeAssistantIndices.clear();
         this.nextAssistantIndex = 0;
         this.nextThinkingIndex = 0;
     }

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

@@ -245,6 +245,9 @@ function newPendingTurn(kind = "turn") {
         compactionEnded: false,
         startedTools: new Map(),
         completedTools: new Set(),
+        usageSnapshots: new Set(),
+        usageItemOffset: 0,
+        nextUsageIndex: 0,
     };
 }
 export class CodexNativeTurnController {
@@ -611,7 +614,30 @@ export class CodexNativeTurnController {
         const params = this.scopedTurnParams(value, "thread token usage");
         if (!params)
             return;
-        params.pending.usage = validateTokenUsage(params.record.tokenUsage);
+        const snapshot = requiredRecord(params.record.tokenUsage, "thread token usage");
+        const usage = validateTokenUsage(snapshot);
+        const total = tokenUsageBreakdown(snapshot.total, "cumulative thread usage");
+        const key = JSON.stringify(total);
+        const pending = params.pending;
+        // Codex repeats snapshots for quota/replay notifications. Equal last usage
+        // alone is not a duplicate: two real requests may use identical token counts.
+        if (pending.usageSnapshots.has(key))
+            return;
+        pending.usageSnapshots.add(key);
+        const newItems = pending.itemOrder.slice(pending.usageItemOffset);
+        pending.usageItemOffset = pending.itemOrder.length;
+        let target = { type: "turn" };
+        // A usage update closes the observed output span. Only newly introduced
+        // items belong to it; late tool completions cannot steal another step's usage.
+        // Several tools in one response share one record, anchored at its last output.
+        for (const id of newItems) {
+            const item = pending.items.get(id);
+            if (TOOL_ITEM_TYPES.has(item.type))
+                target = { type: "tool", toolCallId: id };
+            else if (item.type === "agentMessage")
+                target = { type: "assistant", contentIndex: this.assistantIndex(pending, id) };
+        }
+        this.emit({ type: "usage", usage, inferenceId: `${pending.turnId}:usage:${pending.nextUsageIndex++}`, target });
     }
     handleThreadStatus(value) {
         const params = requiredRecord(value, "thread status notification");
@@ -845,8 +871,6 @@ export class CodexNativeTurnController {
         for (const item of turn.items)
             this.completeItem(pending, item);
         this.finishIncompleteItems(pending, turn.status);
-        if (pending.usage)
-            this.emit({ type: "usage", usage: pending.usage });
         const persistedItems = pending.itemOrder
             .map((itemId) => pending.items.get(itemId))
             .filter((item) => item !== undefined);

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 });
             }

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,16 +35,15 @@ 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;
-    if (inlinePayload && typeof inlinePayload === "object" && !Array.isArray(inlinePayload) && typeof inlinePayload.type === "string") {
+    if (inlinePayload
+        && typeof inlinePayload === "object"
+        && !Array.isArray(inlinePayload)
+        && inlinePayload.type === row.type
+        && typeof inlinePayload.piboSessionId === "string"
+        && inlinePayload.piboSessionId === row.session_id) {
         return compactObject({
             ...inlinePayload,
             renderSequence: numberAttribute(attributes, "renderSequence") ?? inlinePayload.renderSequence,
@@ -73,6 +90,8 @@ function outputPayloadFromV2Row(row, attributes, persistedPayload) {
             ...base,
             type: "assistant_usage",
             usageIndex: numberAttribute(attributes, "usageIndex"),
+            inferenceId: stringAttribute(attributes, "inferenceId"),
+            inferenceTarget: attributes.inferenceTarget,
             inputTokens: numberAttribute(attributes, "inputTokens"),
             outputTokens: numberAttribute(attributes, "outputTokens"),
             cacheReadTokens: numberAttribute(attributes, "cacheReadTokens"),
@@ -112,7 +131,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 +140,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 +155,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;

package/dist/apps/chat/data/event-command-service.js

@@ -1,6 +1,9 @@
 import { randomUUID } from "node:crypto";
 import { isLiveOnlyOutputEvent } from "../output-event-policy.js";
 import { compactObject, nextSessionSequence, previewForPayload, storedChatEventFromV2Row } from "./chat-data-mappers.js";
+export function chatClientTransactionKey(roomId, actorId, clientTxnId) {
+    return `chat:user.accepted:${roomId ?? ""}:${actorId ?? ""}:${clientTxnId}`;
+}
 export class ChatEventCommandService {
     store;
     constructor(store) {
@@ -9,10 +12,7 @@ export class ChatEventCommandService {
     appendEvent(input) {
         const createdAt = input.createdAt ?? new Date().toISOString();
         const eventId = input.eventId ?? `ce_${randomUUID()}`;
-        const idempotencyKey = input.clientTxnId ? `chat:user.accepted:${input.roomId ?? ""}:${input.actorId ?? ""}:${input.clientTxnId}` : `chat:event:${eventId}`;
-        const existing = input.clientTxnId ? this.findByClientTxn(input.roomId, input.actorId, input.clientTxnId) : undefined;
-        if (existing)
-            return existing;
+        const idempotencyKey = input.clientTxnId ? chatClientTransactionKey(input.roomId, input.actorId, input.clientTxnId) : `chat:event:${eventId}`;
         const stored = this.store.eventLog.appendEvent({
             sessionId: input.piboSessionId,
             sessionSequence: input.piboSessionId ? nextSessionSequence(this.store, input.piboSessionId) : undefined,
@@ -30,21 +30,7 @@ export class ChatEventCommandService {
             createdAt,
             indexedAt: createdAt,
         });
-        return storedChatEventFromV2Row({
-            stream_id: stored.streamId,
-            session_id: stored.sessionId ?? null,
-            session_sequence: stored.sessionSequence ?? null,
-            room_id: stored.roomId ?? null,
-            type: stored.type,
-            actor_type: stored.actorType ?? null,
-            actor_id: stored.actorId ?? null,
-            event_id: stored.eventId ?? null,
-            idempotency_key: stored.idempotencyKey ?? null,
-            retention_class: stored.retentionClass,
-            preview_text: stored.previewText ?? null,
-            attributes_json: JSON.stringify(stored.attributes),
-            created_at: stored.createdAt,
-        });
+        return chatEventFromStoredRow(stored);
     }
     appendOutputEvent(event, _input = {}) {
         // Runtime output ingestion is owned by ChatDataIngestService. Avoid a second event_log insert here.
@@ -55,8 +41,14 @@ export class ChatEventCommandService {
     findByClientTxn(roomId, actorId, clientTxnId) {
         if (!roomId || !actorId)
             return undefined;
-        const row = this.store.db.prepare("SELECT * FROM event_log WHERE room_id = ? AND actor_id = ? AND json_extract(attributes_json, '$.clientTxnId') = ? ORDER BY stream_id ASC LIMIT 1").get(roomId, actorId, clientTxnId);
-        return row ? storedChatEventFromV2Row(row) : undefined;
+        // Empty IDs are not valid HTTP transaction keys. Retain the legacy direct-call
+        // lookup contract without adding a scan fallback to ordinary indexed misses.
+        if (clientTxnId === "") {
+            const row = this.store.db.prepare("SELECT * FROM event_log WHERE room_id = ? AND actor_id = ? AND json_extract(attributes_json, '$.clientTxnId') = ? ORDER BY stream_id ASC LIMIT 1").get(roomId, actorId, clientTxnId);
+            return row ? storedChatEventFromV2Row(row) : undefined;
+        }
+        const row = this.store.eventLog.findByIdempotencyKey(chatClientTransactionKey(roomId, actorId, clientTxnId));
+        return row ? chatEventFromStoredRow(row) : undefined;
     }
     deleteSessions(piboSessionIds) {
         if (!piboSessionIds.length)
@@ -73,3 +65,20 @@ export class ChatEventCommandService {
         return Number(result.changes ?? 0);
     }
 }
+function chatEventFromStoredRow(stored) {
+    return storedChatEventFromV2Row({
+        stream_id: stored.streamId,
+        session_id: stored.sessionId ?? null,
+        session_sequence: stored.sessionSequence ?? null,
+        room_id: stored.roomId ?? null,
+        type: stored.type,
+        actor_type: stored.actorType ?? null,
+        actor_id: stored.actorId ?? null,
+        event_id: stored.eventId ?? null,
+        idempotency_key: stored.idempotencyKey ?? null,
+        retention_class: stored.retentionClass,
+        preview_text: stored.previewText ?? null,
+        attributes_json: JSON.stringify(stored.attributes),
+        created_at: stored.createdAt,
+    });
+}