@averyyy/pi-coding-agent 0.80.3-piclient.10

package/dist/core/pi-server-client.js

@@ -0,0 +1,754 @@
+import { randomUUID } from "node:crypto";
+import { setTimeout as sleep } from "node:timers/promises";
+import { EventStream, parseStreamingJson, } from "@earendil-works/pi-ai";
+import { buildPiServerTreePrefixHashes, hashPiServerSessionEntries, hashPiServerStaticContext, } from "./pi-server-protocol.js";
+import { ChunkRequest } from "./pi-server-request.js";
+class PiServerEventStream extends EventStream {
+    constructor() {
+        super((event) => event.type === "done" || event.type === "error", (event) => {
+            if (event.type === "done")
+                return event.message;
+            if (event.type === "error")
+                return event.error;
+            throw new Error("Unexpected event type");
+        });
+    }
+}
+function getServerUrl() {
+    return process.env.PI_SERVER_URL ?? "http://127.0.0.1:4217";
+}
+function getAuthToken() {
+    return process.env.PI_SERVER_AUTH_TOKEN ?? "";
+}
+function createPiServerRequest(signal) {
+    return new ChunkRequest({
+        serverUrl: getServerUrl(),
+        authToken: getAuthToken(),
+        signal,
+    });
+}
+const sessionStaticContextHashes = new Map();
+const sessionSyncedEntryIds = new Map();
+const sessionTreeHashes = new Map();
+const sessionTreeEntryCounts = new Map();
+const sessionTreeLeafIds = new Map();
+const sessionHasTemporaryTree = new Set();
+const RESPONSE_BODY_EXCERPT_CHARS = 500;
+const TRANSIENT_PI_SERVER_RETRY_DELAYS_MS = [250, 750, 1500];
+const TRANSIENT_PI_SERVER_STATUS_CODES = new Set([502, 503, 504, 530]);
+export function hashStaticContext(ctx) {
+    return hashPiServerStaticContext(ctx);
+}
+function hashEntries(entries) {
+    return hashPiServerSessionEntries(entries);
+}
+function getLinearTreeFromMessages(messages) {
+    let parentId = null;
+    const entries = messages.map((message, index) => {
+        const id = `message-${index}`;
+        const entry = {
+            type: "message",
+            id,
+            parentId,
+            timestamp: new Date(message.timestamp).toISOString(),
+            message,
+        };
+        parentId = id;
+        return entry;
+    });
+    return { entries, leafId: parentId };
+}
+export function resetSessionTracking(sessionId) {
+    sessionStaticContextHashes.delete(sessionId);
+    sessionSyncedEntryIds.delete(sessionId);
+    sessionTreeHashes.delete(sessionId);
+    sessionTreeEntryCounts.delete(sessionId);
+    sessionTreeLeafIds.delete(sessionId);
+    sessionHasTemporaryTree.delete(sessionId);
+}
+export function resetAllSessionTracking() {
+    sessionStaticContextHashes.clear();
+    sessionSyncedEntryIds.clear();
+    sessionTreeHashes.clear();
+    sessionTreeEntryCounts.clear();
+    sessionTreeLeafIds.clear();
+    sessionHasTemporaryTree.clear();
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getResponseStatus(response) {
+    const status = response.statusText ? `${response.status} ${response.statusText}` : String(response.status);
+    return response.status >= 500 ? `${status} (server error)` : status;
+}
+function getResponseContentType(response) {
+    return response.headers.get("content-type") ?? "unknown";
+}
+function getBodyExcerpt(text) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return "<empty>";
+    const excerpt = trimmed.slice(0, RESPONSE_BODY_EXCERPT_CHARS);
+    return excerpt.length < trimmed.length ? `${excerpt}...` : excerpt;
+}
+function getJsonErrorText(text) {
+    if (!text)
+        return undefined;
+    try {
+        const parsed = JSON.parse(text);
+        if (!isObject(parsed))
+            return undefined;
+        const error = parsed.error;
+        return typeof error === "string" && error.length > 0 ? error : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function formatResponseDetails(response, bodyText) {
+    const body = getJsonErrorText(bodyText) ?? getBodyExcerpt(bodyText);
+    return `${getResponseStatus(response)}; content-type: ${getResponseContentType(response)}; body excerpt: ${body}`;
+}
+async function readPiServerFailure(response) {
+    const bodyText = await response.text();
+    return {
+        details: formatResponseDetails(response, bodyText),
+        matchText: getJsonErrorText(bodyText) ?? bodyText,
+    };
+}
+async function readPiServerJson(response, errorPrefix) {
+    const bodyText = await response.text();
+    if (!response.ok) {
+        throw new Error(`${errorPrefix} (${formatResponseDetails(response, bodyText)})`);
+    }
+    try {
+        return JSON.parse(bodyText);
+    }
+    catch {
+        throw new Error(`${errorPrefix} (${formatResponseDetails(response, bodyText)}; expected JSON)`);
+    }
+}
+function getServerSentEventFieldValue(line, field) {
+    const prefix = `${field}:`;
+    const value = line.slice(prefix.length);
+    return value.startsWith(" ") ? value.slice(1) : value;
+}
+function parseServerSentEvents(bodyText) {
+    const events = [];
+    let event = "message";
+    let dataLines = [];
+    const flush = () => {
+        if (dataLines.length === 0)
+            return;
+        events.push({ event, data: dataLines.join("\n") });
+        event = "message";
+        dataLines = [];
+    };
+    for (const line of bodyText.split(/\r?\n/)) {
+        if (line === "") {
+            flush();
+            continue;
+        }
+        if (line.startsWith(":"))
+            continue;
+        if (line.startsWith("event:")) {
+            event = getServerSentEventFieldValue(line, "event");
+            continue;
+        }
+        if (line.startsWith("data:")) {
+            dataLines.push(getServerSentEventFieldValue(line, "data"));
+        }
+    }
+    flush();
+    return events;
+}
+function parseServerSentEventData(event, errorPrefix) {
+    try {
+        return JSON.parse(event.data);
+    }
+    catch {
+        throw new Error(`${errorPrefix} (invalid event-stream JSON data: ${getBodyExcerpt(event.data)})`);
+    }
+}
+function formatServerSentEventError(response, payload) {
+    const message = isObject(payload) && typeof payload.error === "string" ? payload.error : JSON.stringify(payload);
+    return `${getResponseStatus(response)}; content-type: ${getResponseContentType(response)}; body excerpt: ${getBodyExcerpt(message)}`;
+}
+async function readPiServerEventStreamJson(response, errorPrefix) {
+    const bodyText = await response.text();
+    for (const event of parseServerSentEvents(bodyText)) {
+        if (event.event === "error") {
+            throw new Error(`${errorPrefix} (${formatServerSentEventError(response, parseServerSentEventData(event, errorPrefix))})`);
+        }
+        if (event.event === "result") {
+            return parseServerSentEventData(event, errorPrefix);
+        }
+    }
+    throw new Error(`${errorPrefix} (${formatResponseDetails(response, bodyText)}; expected result event)`);
+}
+async function readPiServerCompactResponse(response, errorPrefix) {
+    const contentType = getResponseContentType(response).toLowerCase().split(";")[0]?.trim();
+    if (contentType === "text/event-stream") {
+        return readPiServerEventStreamJson(response, errorPrefix);
+    }
+    return readPiServerJson(response, errorPrefix);
+}
+function isAbortError(error, signal) {
+    return signal?.aborted === true || (error instanceof Error && error.name === "AbortError");
+}
+function isTransientPiServerFetchError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /fetch failed|network|socket hang up|terminated|ECONNRESET|ECONNREFUSED|ETIMEDOUT|EAI_AGAIN|CONNECT timeout/i.test(message);
+}
+function isTransientPiServerResponse(response, bodyText) {
+    if (!TRANSIENT_PI_SERVER_STATUS_CODES.has(response.status))
+        return false;
+    if (response.status === 530)
+        return true;
+    return /CONNECT timeout|Bad Gateway|upstream|timeout/i.test(`${response.statusText}\n${bodyText}`);
+}
+async function waitForPiServerRetry(attempt, signal) {
+    await sleep(TRANSIENT_PI_SERVER_RETRY_DELAYS_MS[attempt], undefined, { signal });
+}
+async function postPiServerJsonWithTransientRetry(request, endpoint, body, errorPrefix) {
+    for (let attempt = 0;; attempt++) {
+        let response;
+        try {
+            response = await request.postJson(endpoint, body);
+        }
+        catch (error) {
+            if (attempt < TRANSIENT_PI_SERVER_RETRY_DELAYS_MS.length &&
+                !isAbortError(error, request.options.signal) &&
+                isTransientPiServerFetchError(error)) {
+                await waitForPiServerRetry(attempt, request.options.signal);
+                continue;
+            }
+            throw error;
+        }
+        const bodyText = await response.text();
+        if (!response.ok) {
+            if (attempt < TRANSIENT_PI_SERVER_RETRY_DELAYS_MS.length &&
+                !request.options.signal?.aborted &&
+                isTransientPiServerResponse(response, bodyText)) {
+                await waitForPiServerRetry(attempt, request.options.signal);
+                continue;
+            }
+            throw new Error(`${errorPrefix} (${formatResponseDetails(response, bodyText)})`);
+        }
+        try {
+            return JSON.parse(bodyText);
+        }
+        catch {
+            throw new Error(`${errorPrefix} (${formatResponseDetails(response, bodyText)}; expected JSON)`);
+        }
+    }
+}
+async function ensurePiServerEventStream(response) {
+    const contentType = getResponseContentType(response);
+    if (contentType.toLowerCase().split(";")[0]?.trim() === "text/event-stream") {
+        return;
+    }
+    const bodyText = await response.text();
+    throw new Error(`pi-server error: ${formatResponseDetails(response, bodyText)}; expected text/event-stream`);
+}
+async function ensureSessionInit(sessionId, context, request) {
+    const currentHash = hashStaticContext(context);
+    const previousHash = sessionStaticContextHashes.get(sessionId);
+    if (previousHash === currentHash) {
+        return {
+            sessionId,
+            staticContextHash: previousHash,
+            messageCount: 0,
+            fromCache: true,
+        };
+    }
+    const staticContext = {
+        systemPrompt: context.systemPrompt,
+        tools: context.tools,
+    };
+    const endpoint = previousHash === undefined ? "/api/session/init" : "/api/session/update";
+    const result = await postPiServerJsonWithTransientRetry(request, endpoint, { sessionId, staticContext }, "Session init failed");
+    sessionStaticContextHashes.set(sessionId, currentHash);
+    if (result.treeHash !== undefined) {
+        sessionTreeHashes.set(sessionId, result.treeHash);
+        sessionTreeLeafIds.set(sessionId, result.leafId ?? null);
+        if (result.entryCount !== undefined) {
+            sessionTreeEntryCounts.set(sessionId, result.entryCount);
+        }
+    }
+    return result;
+}
+function getStaticContext(context) {
+    return {
+        systemPrompt: context.systemPrompt,
+        tools: context.tools,
+    };
+}
+function markTreeSynced(sessionId, tree) {
+    sessionSyncedEntryIds.set(sessionId, new Set(tree.entries.map((entry) => entry.id)));
+    const prefixHashes = buildPiServerTreePrefixHashes(tree.entries);
+    sessionTreeHashes.set(sessionId, prefixHashes[prefixHashes.length - 1]);
+    sessionTreeEntryCounts.set(sessionId, tree.entries.length);
+    sessionTreeLeafIds.set(sessionId, tree.leafId);
+    if (tree.replace) {
+        sessionHasTemporaryTree.add(sessionId);
+    }
+    else {
+        sessionHasTemporaryTree.delete(sessionId);
+    }
+}
+async function postTreeJson(request, endpoint, body, errorPrefix) {
+    await postPiServerJsonWithTransientRetry(request, endpoint, body, errorPrefix);
+}
+async function fetchPiServerHistory(sessionId, request, localTree) {
+    const prefixHashes = localTree ? buildPiServerTreePrefixHashes(localTree.entries) : undefined;
+    const historyUrl = localTree && prefixHashes
+        ? `/api/session/${encodeURIComponent(sessionId)}/history?entriesFrom=${localTree.entries.length}&baseTreeHash=${encodeURIComponent(prefixHashes[prefixHashes.length - 1])}`
+        : `/api/session/${encodeURIComponent(sessionId)}/history`;
+    const response = await request.getJson(historyUrl);
+    if (response.status === 404) {
+        return undefined;
+    }
+    const history = await readPiServerJson(response, "Session history reconciliation failed");
+    if (history.treePatch && localTree) {
+        return {
+            entries: [...localTree.entries.slice(0, history.treePatch.entriesFrom), ...history.treePatch.entries],
+            leafId: history.treePatch.leafId,
+            messages: history.messages ?? [],
+        };
+    }
+    if (!history.entries || history.leafId === undefined || !history.messages) {
+        throw new Error("Session history reconciliation failed (response did not include the session tree)");
+    }
+    return {
+        entries: history.entries,
+        leafId: history.leafId,
+        messages: history.messages,
+    };
+}
+async function applyPiServerHistory(sessionId, snapshot, onHistoryReconciled) {
+    markTreeSynced(sessionId, snapshot);
+    await onHistoryReconciled?.(snapshot);
+}
+async function fetchPiServerRun(sessionId, runId, request) {
+    const response = await request.getJson(`/api/session/${encodeURIComponent(sessionId)}/runs/${encodeURIComponent(runId)}`);
+    if (response.status === 404) {
+        return undefined;
+    }
+    return readPiServerJson(response, "Session run recovery failed");
+}
+function getKnownServerPrefixIds(sessionId, entries) {
+    const entryCount = sessionTreeEntryCounts.get(sessionId);
+    const treeHash = sessionTreeHashes.get(sessionId);
+    if (entryCount === undefined || treeHash === undefined || entryCount > entries.length) {
+        return undefined;
+    }
+    const prefixHashes = buildPiServerTreePrefixHashes(entries);
+    if (prefixHashes[entryCount] !== treeHash) {
+        return undefined;
+    }
+    const ids = new Set(entries.slice(0, entryCount).map((entry) => entry.id));
+    sessionSyncedEntryIds.set(sessionId, ids);
+    return ids;
+}
+function isRecoverableTreeDivergenceError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /parent entry .* does not exist|leafId .* does not exist|entry .* already exists/i.test(message);
+}
+function isRecoverableMissingServerState(response, errorBody) {
+    if (response.status !== 400 && response.status !== 404)
+        return false;
+    return /Session has no static context|session not found|parent entry .* does not exist|leafId .* does not exist|entry .* already exists/i.test(errorBody);
+}
+async function syncFullPiServerTree(sessionId, context, tree, request) {
+    await postTreeJson(request, "/api/session/tree/sync", {
+        sessionId,
+        entries: tree.entries,
+        leafId: tree.leafId,
+        staticContext: getStaticContext(context),
+    }, "Session tree sync failed");
+    markTreeSynced(sessionId, tree);
+}
+function shouldUseServerHistory(sessionId, tree) {
+    return !tree.replace && !sessionHasTemporaryTree.has(sessionId) && (sessionTreeEntryCounts.get(sessionId) ?? 0) > 0;
+}
+async function recoverPiServerTreeDivergence(sessionId, context, tree, request, onHistoryReconciled) {
+    if (shouldUseServerHistory(sessionId, tree)) {
+        const snapshot = await fetchPiServerHistory(sessionId, request, tree);
+        if (snapshot && snapshot.entries.length > 0) {
+            await applyPiServerHistory(sessionId, snapshot, onHistoryReconciled);
+            throw new Error("pi-server history differed from local history; local session was reconciled to server history");
+        }
+    }
+    await syncFullPiServerTree(sessionId, context, tree, request);
+}
+export async function syncPiServerTree(sessionId, context, tree, options) {
+    const request = createPiServerRequest(options?.signal);
+    await ensureSessionInit(sessionId, context, request);
+    await syncPiServerTreeWithRequest(sessionId, context, tree, request, options?.onHistoryReconciled);
+}
+async function syncPiServerTreeWithRequest(sessionId, context, tree, request, onHistoryReconciled) {
+    const syncTree = tree;
+    const currentHash = hashEntries(syncTree.entries);
+    const previousHash = sessionTreeHashes.get(sessionId);
+    const previousLeafId = sessionTreeLeafIds.get(sessionId);
+    if (!tree.replace && previousHash === currentHash) {
+        if (previousLeafId !== syncTree.leafId) {
+            try {
+                await postTreeJson(request, "/api/session/tree/switch", { sessionId, leafId: syncTree.leafId }, "Session tree switch failed");
+            }
+            catch (error) {
+                if (!isRecoverableTreeDivergenceError(error)) {
+                    throw error;
+                }
+                await recoverPiServerTreeDivergence(sessionId, context, syncTree, request, onHistoryReconciled);
+                return;
+            }
+            sessionTreeLeafIds.set(sessionId, syncTree.leafId);
+        }
+        markTreeSynced(sessionId, syncTree);
+        return;
+    }
+    const syncedIds = !tree.replace && !sessionHasTemporaryTree.has(sessionId)
+        ? (sessionSyncedEntryIds.get(sessionId) ?? getKnownServerPrefixIds(sessionId, syncTree.entries))
+        : undefined;
+    if (syncedIds) {
+        const deltaEntries = syncTree.entries.filter((entry) => !syncedIds.has(entry.id));
+        if (deltaEntries.length > 0) {
+            try {
+                await postTreeJson(request, "/api/session/tree/append", {
+                    sessionId,
+                    entries: deltaEntries,
+                    leafId: syncTree.leafId,
+                    staticContext: getStaticContext(context),
+                }, "Session tree append failed");
+            }
+            catch (error) {
+                if (!isRecoverableTreeDivergenceError(error)) {
+                    throw error;
+                }
+                await recoverPiServerTreeDivergence(sessionId, context, syncTree, request, onHistoryReconciled);
+                return;
+            }
+            markTreeSynced(sessionId, syncTree);
+            return;
+        }
+    }
+    await recoverPiServerTreeDivergence(sessionId, context, syncTree, request, onHistoryReconciled);
+}
+function serializeOptions(options) {
+    return {
+        temperature: options?.temperature,
+        maxTokens: options?.maxTokens,
+        reasoning: options?.reasoning,
+        cacheRetention: options?.cacheRetention,
+        sessionId: options?.sessionId,
+        apiKey: options?.apiKey,
+        headers: options?.headers,
+        metadata: options?.metadata,
+        transport: options?.transport,
+        thinkingBudgets: options?.thinkingBudgets,
+        timeoutMs: options?.timeoutMs,
+        websocketConnectTimeoutMs: options?.websocketConnectTimeoutMs,
+        maxRetries: options?.maxRetries,
+        maxRetryDelayMs: options?.maxRetryDelayMs,
+    };
+}
+export async function compactPiServer(model, context, options) {
+    const sessionId = options?.sessionId ?? "default";
+    const request = createPiServerRequest(options?.signal);
+    await ensureSessionInit(sessionId, context, request);
+    const tree = options?.sessionTree ?? getLinearTreeFromMessages(context.messages);
+    await syncPiServerTreeWithRequest(sessionId, context, tree, request, options?.onHistoryReconciled);
+    const makeBody = () => ({
+        sessionId,
+        model,
+        options: serializeOptions(options),
+        settings: options?.settings,
+        preparation: options?.preparation,
+        customInstructions: options?.customInstructions,
+        baseTreeHash: sessionTreeHashes.get(sessionId) ?? hashEntries(tree.entries),
+        streamResponse: true,
+    });
+    let response = await request.postJson("/api/session/compact", makeBody());
+    if (!response.ok) {
+        let failure = await readPiServerFailure(response);
+        if (!options?.signal?.aborted && isRecoverableMissingServerState(response, failure.matchText)) {
+            resetSessionTracking(sessionId);
+            await ensureSessionInit(sessionId, context, request);
+            await syncPiServerTreeWithRequest(sessionId, context, tree, request, options?.onHistoryReconciled);
+            response = await request.postJson("/api/session/compact", makeBody());
+            if (response.ok) {
+                failure = { details: "", matchText: "" };
+            }
+            else {
+                failure = await readPiServerFailure(response);
+            }
+        }
+        if (!response.ok) {
+            throw new Error(`Server compaction failed (${failure.details})`);
+        }
+    }
+    const result = await readPiServerCompactResponse(response, "Server compaction failed");
+    if (!result.compaction) {
+        throw new Error("Server compaction response did not include a compaction result");
+    }
+    const resultEntries = result.entries ??
+        (result.treePatch
+            ? [...tree.entries.slice(0, result.treePatch.entriesFrom), ...result.treePatch.entries]
+            : undefined);
+    const resultLeafId = result.leafId ?? result.treePatch?.leafId;
+    if (!result.compactionEntry || !resultEntries || resultLeafId === undefined) {
+        throw new Error("Server compaction response did not include the updated session tree");
+    }
+    markTreeSynced(sessionId, { entries: resultEntries, leafId: resultLeafId });
+    return {
+        compaction: result.compaction,
+        compactionEntry: result.compactionEntry,
+        entries: resultEntries,
+        leafId: resultLeafId,
+        messages: result.messages ?? [],
+    };
+}
+export async function dropLastPiServerAssistantError(sessionId) {
+    const request = createPiServerRequest();
+    const response = await request.postJson("/api/session/drop-last-assistant-error", { sessionId });
+    await readPiServerJson(response, "Dropping server assistant error failed");
+}
+export async function streamPiServer(model, context, options) {
+    const sessionId = options?.sessionId ?? randomUUID();
+    const runId = randomUUID();
+    const isEphemeralSession = options?.sessionId === undefined;
+    const stream = new PiServerEventStream();
+    const partial = {
+        role: "assistant",
+        stopReason: "stop",
+        content: [],
+        api: model.api,
+        provider: model.provider,
+        model: model.id,
+        usage: {
+            input: 0,
+            output: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            totalTokens: 0,
+            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+        },
+        timestamp: Date.now(),
+    };
+    (async () => {
+        let phase = "session_init";
+        try {
+            const request = createPiServerRequest(options?.signal);
+            await ensureSessionInit(sessionId, context, request);
+            const tree = options?.sessionTree ?? {
+                ...getLinearTreeFromMessages(context.messages),
+                replace: true,
+            };
+            const syncTree = tree;
+            phase = "tree_sync";
+            await syncPiServerTreeWithRequest(sessionId, context, syncTree, request, options?.onHistoryReconciled);
+            const makeBody = () => ({
+                sessionId,
+                runId,
+                model,
+                options: serializeOptions(options),
+                ephemeralMessages: options?.ephemeralMessages,
+                contextOverlay: options?.contextOverlay,
+            });
+            phase = "provider_stream";
+            let response = await request.postJson("/api/stream", makeBody());
+            if (!response.ok) {
+                let failure = await readPiServerFailure(response);
+                if (!options?.signal?.aborted && isRecoverableMissingServerState(response, failure.matchText)) {
+                    resetSessionTracking(sessionId);
+                    await ensureSessionInit(sessionId, context, request);
+                    await syncPiServerTreeWithRequest(sessionId, context, syncTree, request, options?.onHistoryReconciled);
+                    response = await request.postJson("/api/stream", makeBody());
+                    if (response.ok) {
+                        failure = { details: "", matchText: "" };
+                    }
+                    else {
+                        failure = await readPiServerFailure(response);
+                    }
+                }
+                if (!response.ok) {
+                    throw new Error(`pi-server error: ${failure.details}`);
+                }
+            }
+            await ensurePiServerEventStream(response);
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = "";
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                if (options?.signal?.aborted) {
+                    throw new Error("Request aborted by user");
+                }
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop() || "";
+                for (const line of lines) {
+                    if (line.startsWith("data: ")) {
+                        const data = line.slice(6).trim();
+                        if (!data)
+                            continue;
+                        const proxyEvent = JSON.parse(data);
+                        const event = processProxyEvent(proxyEvent, partial);
+                        if (event) {
+                            stream.push(event);
+                        }
+                    }
+                }
+            }
+            if (options?.signal?.aborted) {
+                throw new Error("Request aborted by user");
+            }
+            if (isEphemeralSession) {
+                resetSessionTracking(sessionId);
+            }
+            stream.end();
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (!options?.signal?.aborted && phase === "provider_stream") {
+                try {
+                    const recoveredRun = await fetchPiServerRun(sessionId, runId, createPiServerRequest());
+                    if (recoveredRun?.status === "completed" && recoveredRun.message) {
+                        switch (recoveredRun.message.stopReason) {
+                            case "stop":
+                            case "length":
+                            case "toolUse":
+                                stream.push({
+                                    type: "done",
+                                    reason: recoveredRun.message.stopReason,
+                                    message: recoveredRun.message,
+                                });
+                                break;
+                            case "aborted":
+                                stream.push({ type: "error", reason: "aborted", error: recoveredRun.message });
+                                break;
+                            case "error":
+                                stream.push({ type: "error", reason: "error", error: recoveredRun.message });
+                                break;
+                        }
+                        stream.end();
+                        return;
+                    }
+                }
+                catch {
+                    // Keep the original stream error authoritative.
+                }
+            }
+            const reason = options?.signal?.aborted ? "aborted" : "error";
+            partial.stopReason = reason;
+            partial.errorMessage = errorMessage;
+            partial.diagnostics = [
+                ...(partial.diagnostics ?? []),
+                {
+                    type: "pi_server_failure",
+                    timestamp: Date.now(),
+                    error: { name: error instanceof Error ? error.name : "Error", message: errorMessage },
+                    details: { phase, source: "pi-server", retryable: phase === "provider_stream" },
+                },
+            ];
+            stream.push({
+                type: "error",
+                reason,
+                error: partial,
+            });
+            stream.end();
+        }
+    })();
+    return stream;
+}
+function processProxyEvent(proxyEvent, partial) {
+    switch (proxyEvent.type) {
+        case "start":
+            return { type: "start", partial };
+        case "text_start":
+            partial.content[proxyEvent.contentIndex] = { type: "text", text: "" };
+            return { type: "text_start", contentIndex: proxyEvent.contentIndex, partial };
+        case "text_delta": {
+            const content = partial.content[proxyEvent.contentIndex];
+            if (content?.type === "text") {
+                content.text += proxyEvent.delta;
+                return { type: "text_delta", contentIndex: proxyEvent.contentIndex, delta: proxyEvent.delta, partial };
+            }
+            throw new Error("Received text_delta for non-text content");
+        }
+        case "text_end": {
+            const content = partial.content[proxyEvent.contentIndex];
+            if (content?.type === "text") {
+                content.textSignature = proxyEvent.contentSignature;
+                return { type: "text_end", contentIndex: proxyEvent.contentIndex, content: content.text, partial };
+            }
+            throw new Error("Received text_end for non-text content");
+        }
+        case "thinking_start":
+            partial.content[proxyEvent.contentIndex] = { type: "thinking", thinking: "" };
+            return { type: "thinking_start", contentIndex: proxyEvent.contentIndex, partial };
+        case "thinking_delta": {
+            const content = partial.content[proxyEvent.contentIndex];
+            if (content?.type === "thinking") {
+                content.thinking += proxyEvent.delta;
+                return { type: "thinking_delta", contentIndex: proxyEvent.contentIndex, delta: proxyEvent.delta, partial };
+            }
+            throw new Error("Received thinking_delta for non-thinking content");
+        }
+        case "thinking_end": {
+            const content = partial.content[proxyEvent.contentIndex];
+            if (content?.type === "thinking") {
+                content.thinkingSignature = proxyEvent.contentSignature;
+                return { type: "thinking_end", contentIndex: proxyEvent.contentIndex, content: content.thinking, partial };
+            }
+            throw new Error("Received thinking_end for non-thinking content");
+        }
+        case "toolcall_start":
+            partial.content[proxyEvent.contentIndex] = {
+                type: "toolCall",
+                id: proxyEvent.id,
+                name: proxyEvent.toolName,
+                arguments: {},
+                partialJson: "",
+            };
+            return { type: "toolcall_start", contentIndex: proxyEvent.contentIndex, partial };
+        case "toolcall_delta": {
+            const content = partial.content[proxyEvent.contentIndex];
+            if (content?.type === "toolCall") {
+                content.partialJson += proxyEvent.delta;
+                content.arguments = parseStreamingJson(content.partialJson) || {};
+                partial.content[proxyEvent.contentIndex] = { ...content };
+                return { type: "toolcall_delta", contentIndex: proxyEvent.contentIndex, delta: proxyEvent.delta, partial };
+            }
+            throw new Error("Received toolcall_delta for non-toolCall content");
+        }
+        case "toolcall_end": {
+            const content = partial.content[proxyEvent.contentIndex];
+            if (content?.type === "toolCall") {
+                delete content.partialJson;
+                return { type: "toolcall_end", contentIndex: proxyEvent.contentIndex, toolCall: content, partial };
+            }
+            return undefined;
+        }
+        case "done":
+            partial.stopReason = proxyEvent.reason;
+            partial.usage = proxyEvent.usage;
+            return { type: "done", reason: proxyEvent.reason, message: partial };
+        case "error":
+            partial.stopReason = proxyEvent.reason;
+            partial.errorMessage = proxyEvent.errorMessage;
+            partial.usage = proxyEvent.usage;
+            return { type: "error", reason: proxyEvent.reason, error: partial };
+        default: {
+            const _exhaustiveCheck = proxyEvent;
+            console.warn(`Unhandled proxy event type: ${proxyEvent.type}`);
+            return undefined;
+        }
+    }
+}
+export { getServerUrl, getAuthToken };
+//# sourceMappingURL=pi-server-client.js.map