@pasko70/pibo 2.5.2 → 3.0.0

package/dist/shared/trace-limits.js

@@ -0,0 +1,7 @@
+/**
+ * Reconciliation intentionally stays below the measured quadratic cost knee.
+ * Adapters may page more history, but product identity requires a complete
+ * proof and timing set within this shared bound.
+ */
+export const TRACE_RECONCILIATION_ENTRY_CAP = 500;
+export const TRACE_RECONCILIATION_TIMING_CAP = 500;

package/dist/shared/trace-live-patch.js

@@ -0,0 +1,61 @@
+import { reconcileAsyncAgentRunStatuses } from "./trace-async-agent-runs.js";
+import { applySingleEventToNodes, contentDeltaPatchNodeId, eventsCanAffectAsyncAgentRunStatus, isConfirmedUserMessageEcho, latestTraceStreamId, traceEventDedupeKey, } from "./trace-event-projection.js";
+import { flattenTraceNodes } from "./trace-nodes.js";
+import { nestMutableCopiedTraceNodes, shareUnchangedTraceNodes } from "./trace-patch-nodes.js";
+export function patchTraceViewWithEvent(view, event, sessionStatus) {
+    return patchTraceViewWithEvents(view, [event], sessionStatus);
+}
+export function patchTraceViewWithEvents(view, events, sessionStatus) {
+    if (!events.length)
+        return view;
+    const seenEventKeys = new Set(view.rawEvents.map((event) => traceEventDedupeKey(event)));
+    const candidateEvents = [];
+    for (const event of events) {
+        const eventKey = traceEventDedupeKey(event);
+        if (seenEventKeys.has(eventKey))
+            continue;
+        seenEventKeys.add(eventKey);
+        candidateEvents.push(event);
+    }
+    if (!candidateEvents.length)
+        return view;
+    const previousFlatNodes = flattenTraceNodes(view.nodes);
+    const allNodes = [];
+    const byId = new Map();
+    const previousById = new Map();
+    for (const previousNode of previousFlatNodes) {
+        previousById.set(previousNode.id, previousNode);
+        const nextNode = { ...previousNode, children: [] };
+        allNodes.push(nextNode);
+        byId.set(nextNode.id, nextNode);
+    }
+    const childByParent = new Map();
+    const linkedChildByToolCallId = new Map();
+    const openTranscriptEventIds = new Set();
+    const emptyHistoryCoverage = { mode: "none", eventIds: new Set(), toolCallIds: new Set() };
+    const appliedEvents = [];
+    let contentDeltaChangedNodeIds = new Set();
+    for (const event of candidateEvents) {
+        if (isConfirmedUserMessageEcho(allNodes, event))
+            continue;
+        appliedEvents.push(event);
+        const contentDeltaNodeId = contentDeltaPatchNodeId(event.payload);
+        if (contentDeltaChangedNodeIds && contentDeltaNodeId)
+            contentDeltaChangedNodeIds.add(contentDeltaNodeId);
+        else
+            contentDeltaChangedNodeIds = undefined;
+        applySingleEventToNodes(allNodes, byId, view.piboSessionId, event, childByParent, linkedChildByToolCallId, emptyHistoryCoverage, openTranscriptEventIds, sessionStatus);
+    }
+    if (!appliedEvents.length)
+        return view;
+    const nestedNodes = nestMutableCopiedTraceNodes(allNodes);
+    if (eventsCanAffectAsyncAgentRunStatus(appliedEvents))
+        reconcileAsyncAgentRunStatuses(nestedNodes);
+    const sharedNodes = shareUnchangedTraceNodes(previousById, nestedNodes, contentDeltaChangedNodeIds);
+    return {
+        ...view,
+        rawEvents: view.rawEvents.length ? [...view.rawEvents, ...appliedEvents] : appliedEvents,
+        nodes: sharedNodes,
+        latestStreamId: latestTraceStreamId(appliedEvents, view.latestStreamId),
+    };
+}

package/dist/shared/trace-tool-identity.js

@@ -0,0 +1,43 @@
+import { TRACE_RECONCILIATION_ENTRY_CAP } from "./trace-limits.js";
+const QUALIFIED_TOOL_PREFIX = "history-tool:";
+const TOOL_PREFIX = "tool:";
+const TOOL_INVOCATION_TAG = "event-tool";
+export function qualifiedHistoryToolNodeId(toolCallId, eventId, invocationOrdinal) {
+    const projectionIdentity = JSON.stringify([TOOL_INVOCATION_TAG, eventId, invocationOrdinal]);
+    return `${QUALIFIED_TOOL_PREFIX}${encodeURIComponent(JSON.stringify([toolCallId, projectionIdentity]))}`;
+}
+export function parseTraceToolNodeIdentity(nodeId) {
+    if (nodeId.startsWith(TOOL_PREFIX)) {
+        const toolCallId = nodeId.slice(TOOL_PREFIX.length);
+        return toolCallId ? { toolCallId } : undefined;
+    }
+    if (!nodeId.startsWith(QUALIFIED_TOOL_PREFIX))
+        return undefined;
+    try {
+        const decoded = JSON.parse(decodeURIComponent(nodeId.slice(QUALIFIED_TOOL_PREFIX.length)));
+        if (!Array.isArray(decoded)
+            || decoded.length !== 2
+            || typeof decoded[0] !== "string"
+            || decoded[0].length === 0
+            || typeof decoded[1] !== "string")
+            return undefined;
+        const qualifier = JSON.parse(decoded[1]);
+        if (!Array.isArray(qualifier)
+            || qualifier.length !== 3
+            || qualifier[0] !== TOOL_INVOCATION_TAG
+            || typeof qualifier[1] !== "string"
+            || qualifier[1].length === 0
+            || !Number.isSafeInteger(qualifier[2])
+            || Number(qualifier[2]) < 0
+            || Number(qualifier[2]) >= TRACE_RECONCILIATION_ENTRY_CAP)
+            return undefined;
+        const identity = {
+            toolCallId: decoded[0],
+            qualifier: { eventId: qualifier[1], invocationOrdinal: Number(qualifier[2]) },
+        };
+        return qualifiedHistoryToolNodeId(identity.toolCallId, identity.qualifier.eventId, identity.qualifier.invocationOrdinal) === nodeId ? identity : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/speech/openai-codex-realtime-call-proxy.js

@@ -0,0 +1,248 @@
+import { randomUUID } from "node:crypto";
+import { createServer } from "node:http";
+const CHATGPT_CODEX_BASE_URL = "https://chatgpt.com/backend-api/codex/";
+const CODEX_REALTIME_MODEL = "gpt-live-1-codex";
+const MAX_REQUEST_BYTES = 512 * 1024;
+const MAX_RESPONSE_BYTES = 512 * 1024;
+const REQUEST_BODY_TIMEOUT_MS = 10_000;
+const FORWARD_TIMEOUT_MS = 30_000;
+const OMITTED_RESPONSE_HEADERS = new Set([
+    "connection",
+    "content-encoding",
+    "content-length",
+    "keep-alive",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "te",
+    "trailer",
+    "transfer-encoding",
+    "upgrade",
+]);
+class ProxyRequestError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+async function readRequestBody(request, signal, timeoutMs) {
+    const chunks = [];
+    let bytes = 0;
+    const timeoutController = new AbortController();
+    const timer = setTimeout(() => {
+        timeoutController.abort(new ProxyRequestError(408, "Realtime call request timed out"));
+    }, timeoutMs);
+    timer.unref?.();
+    const combinedSignal = AbortSignal.any([signal, timeoutController.signal]);
+    const abortRead = () => request.destroy(combinedSignal.reason instanceof Error ? combinedSignal.reason : undefined);
+    if (combinedSignal.aborted)
+        abortRead();
+    else
+        combinedSignal.addEventListener("abort", abortRead, { once: true });
+    try {
+        for await (const chunk of request) {
+            const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            bytes += buffer.length;
+            if (bytes > MAX_REQUEST_BYTES)
+                throw new ProxyRequestError(413, "Realtime call request is too large");
+            chunks.push(buffer);
+        }
+        if (timeoutController.signal.aborted)
+            throw timeoutController.signal.reason;
+        if (signal.aborted)
+            throw signal.reason;
+        return Buffer.concat(chunks);
+    }
+    finally {
+        clearTimeout(timer);
+        combinedSignal.removeEventListener("abort", abortRead);
+    }
+}
+function requestHeaders(request) {
+    const authorization = request.headers.authorization;
+    if (typeof authorization !== "string" || !authorization) {
+        throw new ProxyRequestError(401, "Codex subscription authentication is required");
+    }
+    const headers = new Headers({
+        accept: "application/sdp",
+        "accept-encoding": "identity",
+        authorization,
+        "content-type": "application/json",
+        "openai-alpha": "quicksilver=v2",
+        originator: "codex_cli_rs",
+    });
+    for (const name of ["chatgpt-account-id", "session-id", "thread-id", "user-agent", "x-openai-fedramp"]) {
+        const value = request.headers[name];
+        if (typeof value === "string" && value)
+            headers.set(name, value);
+    }
+    return headers;
+}
+function realtimeCallBody(value) {
+    if (!isRecord(value) || typeof value.sdp !== "string" || !isRecord(value.session)) {
+        throw new ProxyRequestError(400, "Codex returned an invalid realtime call request");
+    }
+    const session = { ...value.session, model: CODEX_REALTIME_MODEL };
+    delete session.id;
+    return JSON.stringify({ ...value, session });
+}
+function writeResponseHeaders(response, outgoing) {
+    for (const [name, value] of response.headers) {
+        if (!OMITTED_RESPONSE_HEADERS.has(name))
+            outgoing.setHeader(name, value);
+    }
+}
+async function readResponseBody(response) {
+    const contentLength = response.headers.get("content-length");
+    if (contentLength && Number(contentLength) > MAX_RESPONSE_BYTES) {
+        await response.body?.cancel().catch(() => { });
+        throw new ProxyRequestError(502, "Realtime call response is too large");
+    }
+    if (!response.body)
+        return Buffer.alloc(0);
+    const reader = response.body.getReader();
+    const chunks = [];
+    let bytes = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            const chunk = Buffer.from(value);
+            bytes += chunk.length;
+            if (bytes > MAX_RESPONSE_BYTES) {
+                await reader.cancel().catch(() => { });
+                throw new ProxyRequestError(502, "Realtime call response is too large");
+            }
+            chunks.push(chunk);
+        }
+        return Buffer.concat(chunks);
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+async function forwardRealtimeCall(request, response, targetUrl, signal, requestBodyTimeoutMs) {
+    const body = await readRequestBody(request, signal, requestBodyTimeoutMs);
+    let payload;
+    try {
+        payload = JSON.parse(body.toString("utf8"));
+    }
+    catch {
+        throw new ProxyRequestError(400, "Codex returned malformed realtime call JSON");
+    }
+    const timeoutController = new AbortController();
+    const timer = setTimeout(() => timeoutController.abort(new Error("Realtime call forwarding timed out")), FORWARD_TIMEOUT_MS);
+    timer.unref?.();
+    try {
+        const upstream = await fetch(targetUrl, {
+            method: "POST",
+            headers: requestHeaders(request),
+            body: realtimeCallBody(payload),
+            redirect: "manual",
+            signal: AbortSignal.any([signal, timeoutController.signal]),
+        });
+        response.statusCode = upstream.status;
+        writeResponseHeaders(upstream, response);
+        response.end(await readResponseBody(upstream));
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function sendProxyError(response, error) {
+    if (response.headersSent) {
+        response.destroy();
+        return;
+    }
+    response.statusCode = error instanceof ProxyRequestError ? error.status : 502;
+    response.setHeader("content-type", "application/json");
+    response.end(JSON.stringify({ error: error instanceof ProxyRequestError ? error.message : "Realtime call forwarding failed" }));
+}
+export async function startOpenAiCodexRealtimeCallProxy(options = {}) {
+    if (options.signal?.aborted)
+        throw options.signal.reason;
+    const targetBaseUrl = new URL(options.targetBaseUrl ?? CHATGPT_CODEX_BASE_URL);
+    if (targetBaseUrl.protocol !== "https:" && targetBaseUrl.protocol !== "http:") {
+        throw new Error("Codex realtime call target must use HTTP or HTTPS");
+    }
+    if (!targetBaseUrl.pathname.endsWith("/"))
+        targetBaseUrl.pathname += "/";
+    const requestBodyTimeoutMs = options.requestBodyTimeoutMs ?? REQUEST_BODY_TIMEOUT_MS;
+    if (!Number.isFinite(requestBodyTimeoutMs) || requestBodyTimeoutMs <= 0) {
+        throw new Error("Codex realtime call request timeout must be a positive finite number");
+    }
+    const routePrefix = `/speech-${randomUUID()}/backend-api/codex`;
+    const sockets = new Set();
+    const activeRequests = new Set();
+    const server = createServer((request, response) => {
+        const requestController = new AbortController();
+        activeRequests.add(requestController);
+        void (async () => {
+            if (request.method !== "POST")
+                throw new ProxyRequestError(405, "Method not allowed");
+            const incomingUrl = new URL(request.url ?? "/", "http://127.0.0.1");
+            if (incomingUrl.pathname !== `${routePrefix}/realtime/calls`) {
+                throw new ProxyRequestError(404, "Not found");
+            }
+            const targetUrl = new URL("realtime/calls", targetBaseUrl);
+            targetUrl.search = incomingUrl.search;
+            await forwardRealtimeCall(request, response, targetUrl, requestController.signal, requestBodyTimeoutMs);
+        })()
+            .catch((error) => sendProxyError(response, error))
+            .finally(() => activeRequests.delete(requestController));
+    });
+    server.on("connection", (socket) => {
+        sockets.add(socket);
+        socket.once("close", () => sockets.delete(socket));
+    });
+    server.on("clientError", (_error, socket) => socket.destroy());
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", () => {
+            server.off("error", reject);
+            resolve();
+        });
+    });
+    if (options.signal?.aborted) {
+        await new Promise((resolve) => server.close(() => resolve()));
+        throw options.signal.reason;
+    }
+    const address = server.address();
+    if (!address || typeof address === "string") {
+        server.close();
+        throw new Error("Codex realtime call proxy did not bind to a TCP port");
+    }
+    let closePromise;
+    const close = () => {
+        if (!closePromise) {
+            options.signal?.removeEventListener("abort", closeOnAbort);
+            for (const controller of activeRequests)
+                controller.abort(new Error("Codex realtime call proxy closed"));
+            closePromise = new Promise((resolve) => {
+                if (!server.listening) {
+                    for (const socket of sockets)
+                        socket.destroy();
+                    resolve();
+                    return;
+                }
+                server.close(() => resolve());
+                for (const socket of sockets)
+                    socket.destroy();
+                server.closeAllConnections();
+            });
+        }
+        return closePromise;
+    };
+    const closeOnAbort = () => {
+        void close();
+    };
+    options.signal?.addEventListener("abort", closeOnAbort, { once: true });
+    return {
+        baseUrl: `http://127.0.0.1:${address.port}${routePrefix}`,
+        close,
+    };
+}