@pasko70/pibo 2.5.2 → 3.0.0

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

@@ -3,6 +3,8 @@ import { closeSync, existsSync, openSync, readFileSync, readSync, readdirSync, s
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { parseSessionEntries, SessionManager } from "@earendil-works/pi-coding-agent";
+import { historyReconciliationDigest } from "../../agent-runtime/history.js";
+import { TRACE_RECONCILIATION_ENTRY_CAP } from "../../shared/trace-limits.js";
 export const PI_HISTORY_TAIL_MAX_BYTES = 2 * 1024 * 1024;
 export const PI_HISTORY_PAGE_MAX_BYTES = 512 * 1024;
 export const PI_HISTORY_SCAN_MAX_BYTES = 16 * 1024 * 1024;
@@ -76,11 +78,35 @@ export async function readPiAgentRuntimeHistory(runtimeInstanceId, input) {
         beforeTimestamp: input.beforeTimestamp ?? decoded.beforeTimestamp,
         limit: input.limit,
     });
+    const historyScopeId = `pi:${runtimeInstanceId}:${input.binding.nativeSessionId ?? "unbound"}`;
+    const completeProof = inspection.sizeBytes !== undefined && inspection.sizeBytes <= PI_HISTORY_SCAN_MAX_BYTES
+        ? readPiTranscriptEntriesWithPositions(inspection.locator.value, PI_HISTORY_SCAN_MAX_BYTES, TRACE_RECONCILIATION_ENTRY_CAP)
+        : undefined;
+    const proofEntries = completeProof
+        ? piSessionEntriesToAgentRuntimeHistoryEntries(completeProof.entries, completeProof.entryPositions, historyScopeId)
+        : undefined;
+    const proofEntriesByPosition = proofEntries
+        ? new Map(proofEntries.map((entry) => [entry.historyPosition, entry]))
+        : undefined;
+    const entries = proofEntriesByPosition
+        ? page.entryPositions.flatMap((position) => {
+            const entry = proofEntriesByPosition.get(position);
+            return entry ? [entry] : [];
+        })
+        : piSessionEntriesToAgentRuntimeHistoryEntries(page.entries, page.entryPositions, historyScopeId);
     return {
         runtimeInstanceId,
         adapterId: "pi",
         source: "native",
-        entries: piSessionEntriesToAgentRuntimeHistoryEntries(page.entries),
+        entries,
+        reconciliationProof: completeProof && proofEntries
+            ? {
+                complete: true,
+                scopeId: historyScopeId,
+                fullScope: { entryCount: proofEntries.length, digest: historyReconciliationDigest(proofEntries) },
+                entries: proofEntries,
+            }
+            : { complete: false, scopeId: historyScopeId, entries },
         orderOffset: page.startByte,
         nextCursor: page.hasOlder && page.nextBeforeByte !== undefined
             ? encodePiHistoryCursor({ beforeByte: page.nextBeforeByte, beforeTimestamp: input.beforeTimestamp ?? decoded.beforeTimestamp })
@@ -89,11 +115,12 @@ export async function readPiAgentRuntimeHistory(runtimeInstanceId, input) {
         inspection,
     };
 }
-export function piSessionEntriesToAgentRuntimeHistoryEntries(entries) {
+export function piSessionEntriesToAgentRuntimeHistoryEntries(entries, historyPositions = [], historyScopeId) {
     const normalized = [];
     let nativeTurnId;
     for (let sequence = 0; sequence < entries.length; sequence += 1) {
         const entry = entries[sequence];
+        const historyPosition = historyPositions[sequence];
         if (entry.type === "session_info" && entry.name) {
             normalized.push({
                 id: `pi:${entry.id}`,
@@ -101,6 +128,8 @@ export function piSessionEntriesToAgentRuntimeHistoryEntries(entries) {
                 source: "native",
                 createdAt: entry.timestamp,
                 sequence,
+                ...(historyPosition ? { historyPosition } : {}),
+                ...(historyScopeId ? { historyScopeId } : {}),
                 nativeEntryId: entry.id,
                 name: entry.name,
             });
@@ -117,6 +146,8 @@ export function piSessionEntriesToAgentRuntimeHistoryEntries(entries) {
                 source: "native",
                 createdAt: entry.timestamp,
                 sequence,
+                ...(historyPosition ? { historyPosition } : {}),
+                ...(historyScopeId ? { historyScopeId } : {}),
                 nativeTurnId,
                 nativeEntryId: entry.id,
                 role: "user",
@@ -132,6 +163,8 @@ export function piSessionEntriesToAgentRuntimeHistoryEntries(entries) {
                 source: "native",
                 createdAt: entry.timestamp,
                 sequence,
+                ...(historyPosition ? { historyPosition } : {}),
+                ...(historyScopeId ? { historyScopeId } : {}),
                 nativeTurnId,
                 nativeEntryId: entry.id,
                 role: "assistant",
@@ -153,6 +186,8 @@ export function piSessionEntriesToAgentRuntimeHistoryEntries(entries) {
                 source: "native",
                 createdAt: entry.timestamp,
                 sequence,
+                ...(historyPosition ? { historyPosition } : {}),
+                ...(historyScopeId ? { historyScopeId } : {}),
                 nativeTurnId,
                 nativeEntryId: entry.id,
                 role: "tool",
@@ -228,7 +263,7 @@ export function readPiTranscriptTailEntries(path, maxBytes = PI_HISTORY_TAIL_MAX
 }
 export function readPiTranscriptHistoryPage(path, input = {}) {
     if (!existsSync(path))
-        return { entries: [], hasOlder: false, scannedBytes: 0, startByte: 0, endByte: 0 };
+        return { entries: [], entryPositions: [], hasOlder: false, scannedBytes: 0, startByte: 0, endByte: 0 };
     const stats = statSync(path);
     const fileSize = Math.max(0, stats.size);
     const initialEnd = input.beforeByte === undefined
@@ -261,7 +296,7 @@ export function readPiTranscriptHistoryPage(path, input = {}) {
                 const entry = parsed[entryIndex];
                 if (beforeTime !== undefined && entryTimestampMs(entry) >= beforeTime)
                     continue;
-                entries.push({ entry, startByte: record.startByte });
+                entries.push({ entry, startByte: record.startByte, parsedIndex: entryIndex });
                 if (entries.length >= limit)
                     break;
             }
@@ -271,8 +306,10 @@ export function readPiTranscriptHistoryPage(path, input = {}) {
         closeSync(fd);
     }
     const nextBeforeByte = cursorEnd > 0 ? cursorEnd : undefined;
+    const orderedEntries = entries.reverse();
     return {
-        entries: entries.reverse().map((item) => item.entry),
+        entries: orderedEntries.map((item) => item.entry),
+        entryPositions: orderedEntries.map((item) => `pi-byte:${item.startByte}:${item.parsedIndex}`),
         nextBeforeByte,
         hasOlder: nextBeforeByte !== undefined,
         scannedBytes,
@@ -280,6 +317,30 @@ export function readPiTranscriptHistoryPage(path, input = {}) {
         endByte: initialEnd,
     };
 }
+function readPiTranscriptEntriesWithPositions(path, maxBytes, maxEntries) {
+    if (statSync(path).size > maxBytes)
+        return undefined;
+    const content = readFileSync(path);
+    if (content.length > maxBytes)
+        return undefined;
+    const entries = [];
+    const entryPositions = [];
+    let lineStart = 0;
+    for (let cursor = 0; cursor <= content.length; cursor += 1) {
+        if (cursor < content.length && content[cursor] !== 0x0a)
+            continue;
+        const line = content.subarray(lineStart, cursor).toString("utf8");
+        const parsed = parseTranscriptLine(line);
+        for (let parsedIndex = 0; parsedIndex < parsed.length; parsedIndex += 1) {
+            if (entries.length >= maxEntries)
+                return undefined;
+            entries.push(parsed[parsedIndex]);
+            entryPositions.push(`pi-byte:${lineStart}:${parsedIndex}`);
+        }
+        lineStart = cursor + 1;
+    }
+    return { entries, entryPositions };
+}
 function normalizePiAssistantContent(content) {
     if (typeof content === "string")
         return [{ type: "text", text: content }];

package/dist/agent-runtimes/pi/openai-response-observer.js

@@ -0,0 +1,102 @@
+export function withOpenAiResponseEventObserver(options, observer) {
+    const fetchImpl = options?.fetch ?? globalThis.fetch;
+    return {
+        ...(options ?? {}),
+        // Pi does not expose raw events from its shared Codex WebSocket transport.
+        // SSE keeps observation request-scoped instead of replacing global constructors.
+        transport: "sse",
+        fetch: async (input, init) => observeOpenAiSseResponse(await fetchImpl(input, init), observer),
+    };
+}
+export function observeOpenAiSseResponse(response, observer) {
+    if (!response.body || !response.headers.get("content-type")?.toLowerCase().includes("text/event-stream")) {
+        return response;
+    }
+    const reader = response.body.getReader();
+    const parser = new OpenAiSseParser(observer);
+    let cancelled = false;
+    const body = new ReadableStream({
+        async pull(controller) {
+            try {
+                const chunk = await reader.read();
+                if (cancelled)
+                    return;
+                if (chunk.done) {
+                    parser.finish();
+                    reader.releaseLock();
+                    controller.close();
+                    return;
+                }
+                parser.push(chunk.value);
+                controller.enqueue(chunk.value);
+            }
+            catch (error) {
+                if (cancelled)
+                    return;
+                reader.releaseLock();
+                controller.error(error);
+            }
+        },
+        async cancel(reason) {
+            cancelled = true;
+            try {
+                await reader.cancel(reason);
+            }
+            finally {
+                reader.releaseLock();
+            }
+        },
+    }, { highWaterMark: 0 });
+    return new Response(body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+    });
+}
+class OpenAiSseParser {
+    observer;
+    decoder = new TextDecoder();
+    buffer = "";
+    constructor(observer) {
+        this.observer = observer;
+    }
+    push(chunk) {
+        this.buffer += this.decoder.decode(chunk, { stream: true });
+        this.drain();
+    }
+    finish() {
+        this.buffer += this.decoder.decode();
+        this.drain(true);
+    }
+    drain(final = false) {
+        this.buffer = this.buffer.replaceAll("\r\n", "\n");
+        let separator = this.buffer.indexOf("\n\n");
+        while (separator >= 0) {
+            this.observeBlock(this.buffer.slice(0, separator));
+            this.buffer = this.buffer.slice(separator + 2);
+            separator = this.buffer.indexOf("\n\n");
+        }
+        if (final && this.buffer.trim()) {
+            this.observeBlock(this.buffer);
+            this.buffer = "";
+        }
+    }
+    observeBlock(block) {
+        const data = block
+            .split("\n")
+            .filter((line) => line.startsWith("data:"))
+            .map((line) => line.slice(5).trim())
+            .join("\n")
+            .trim();
+        if (data && data !== "[DONE]")
+            observeJson(data, this.observer);
+    }
+}
+function observeJson(value, observer) {
+    try {
+        observer(JSON.parse(value));
+    }
+    catch {
+        // Provider observation must never interfere with the provider stream.
+    }
+}