@averyyy/pi-coding-agent 0.84.2-piclient.1 → 0.84.3-piclient.1

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

@@ -36,6 +36,14 @@ 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]);
+const PI_SERVER_RUN_RECOVERY_POLL_MS = 250;
+const DEFAULT_PI_SERVER_RUN_RECOVERY_TIMEOUT_MS = 10 * 60 * 1000;
+class PiServerRunRecoveryTimeoutError extends Error {
+    constructor() {
+        super("pi-server run recovery timed out; the server may still be processing the request");
+        this.name = "PiServerRunRecoveryTimeoutError";
+    }
+}
 export function hashStaticContext(ctx) {
     return hashPiServerStaticContext(ctx);
 }
@@ -74,6 +82,63 @@ export function resetAllSessionTracking() {
     sessionTreeLeafIds.clear();
     sessionHasTemporaryTree.clear();
 }
+class PiServerResponseError extends Error {
+    code;
+    details;
+    constructor(message, code, details) {
+        super(message);
+        this.name = "PiServerResponseError";
+        this.code = code;
+        this.details = details;
+    }
+}
+class ServerSentEventParser {
+    buffer = "";
+    event = "message";
+    dataLines = [];
+    feed(text) {
+        this.buffer += text;
+        const lines = this.buffer.split("\n");
+        this.buffer = lines.pop() ?? "";
+        return lines.flatMap((line) => this.consumeLine(line));
+    }
+    finish() {
+        const events = [];
+        if (this.buffer.length > 0) {
+            events.push(...this.consumeLine(this.buffer));
+            this.buffer = "";
+        }
+        const final = this.flush();
+        if (final)
+            events.push(final);
+        return events;
+    }
+    consumeLine(rawLine) {
+        const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+        if (line === "") {
+            const event = this.flush();
+            return event ? [event] : [];
+        }
+        if (line.startsWith(":"))
+            return [];
+        if (line.startsWith("event:")) {
+            this.event = getServerSentEventFieldValue(line, "event");
+            return [];
+        }
+        if (line.startsWith("data:")) {
+            this.dataLines.push(getServerSentEventFieldValue(line, "data"));
+        }
+        return [];
+    }
+    flush() {
+        if (this.dataLines.length === 0)
+            return undefined;
+        const event = { event: this.event, data: this.dataLines.join("\n") };
+        this.event = "message";
+        this.dataLines = [];
+        return event;
+    }
+}
 function isObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -91,34 +156,46 @@ function getBodyExcerpt(text) {
     const excerpt = trimmed.slice(0, RESPONSE_BODY_EXCERPT_CHARS);
     return excerpt.length < trimmed.length ? `${excerpt}...` : excerpt;
 }
-function getJsonErrorText(text) {
+function getJsonErrorResponse(text) {
     if (!text)
         return undefined;
     try {
         const parsed = JSON.parse(text);
-        if (!isObject(parsed))
+        if (!isObject(parsed) || typeof parsed.error !== "string" || parsed.error.length === 0)
             return undefined;
-        const error = parsed.error;
-        return typeof error === "string" && error.length > 0 ? error : undefined;
+        const code = parsed.code;
+        return {
+            error: parsed.error,
+            code: typeof code === "string" ? code : undefined,
+            details: isObject(parsed.details) ? parsed.details : undefined,
+        };
     }
     catch {
         return undefined;
     }
 }
+function getJsonErrorText(text) {
+    return getJsonErrorResponse(text)?.error;
+}
 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();
+    const errorResponse = getJsonErrorResponse(bodyText);
     return {
         details: formatResponseDetails(response, bodyText),
-        matchText: getJsonErrorText(bodyText) ?? bodyText,
+        code: errorResponse?.code,
     };
 }
 async function readPiServerJson(response, errorPrefix) {
     const bodyText = await response.text();
     if (!response.ok) {
+        const errorResponse = getJsonErrorResponse(bodyText);
+        if (errorResponse) {
+            throw new PiServerResponseError(`${errorPrefix} (${formatResponseDetails(response, bodyText)})`, errorResponse.code, errorResponse.details);
+        }
         throw new Error(`${errorPrefix} (${formatResponseDetails(response, bodyText)})`);
     }
     try {
@@ -134,33 +211,8 @@ function getServerSentEventFieldValue(line, field) {
     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;
+    const parser = new ServerSentEventParser();
+    return [...parser.feed(bodyText), ...parser.finish()];
 }
 function parseServerSentEventData(event, errorPrefix) {
     try {
@@ -233,6 +285,10 @@ async function postPiServerJsonWithTransientRetry(request, endpoint, body, error
                 await waitForPiServerRetry(attempt, request.options.signal);
                 continue;
             }
+            const errorResponse = getJsonErrorResponse(bodyText);
+            if (errorResponse) {
+                throw new PiServerResponseError(`${errorPrefix} (${formatResponseDetails(response, bodyText)})`, errorResponse.code, errorResponse.details);
+            }
             throw new Error(`${errorPrefix} (${formatResponseDetails(response, bodyText)})`);
         }
         try {
@@ -337,6 +393,17 @@ async function fetchPiServerRun(sessionId, runId, request) {
     }
     return readPiServerJson(response, "Session run recovery failed");
 }
+async function waitForPiServerRunCompletion(sessionId, runId, request, options) {
+    const deadline = Date.now() + DEFAULT_PI_SERVER_RUN_RECOVERY_TIMEOUT_MS;
+    for (;;) {
+        const run = await fetchPiServerRun(sessionId, runId, request);
+        if (!run || run.status !== "running")
+            return run;
+        if (Date.now() >= deadline)
+            throw new PiServerRunRecoveryTimeoutError();
+        await sleep(PI_SERVER_RUN_RECOVERY_POLL_MS, undefined, { signal: options?.signal });
+    }
+}
 function getKnownServerPrefixIds(sessionId, entries) {
     const entryCount = sessionTreeEntryCounts.get(sessionId);
     const treeHash = sessionTreeHashes.get(sessionId);
@@ -351,14 +418,25 @@ function getKnownServerPrefixIds(sessionId, entries) {
     sessionSyncedEntryIds.set(sessionId, ids);
     return ids;
 }
+function isRecoverableTreeDivergenceCode(code) {
+    return code === "PARENT_ENTRY_NOT_FOUND" || code === "LEAF_ID_NOT_FOUND" || code === "ENTRY_ALREADY_EXISTS";
+}
+function isRecoverableMissingServerStateCode(code) {
+    return code === "SESSION_NOT_FOUND" || code === "SESSION_NO_STATIC_CONTEXT" || isRecoverableTreeDivergenceCode(code);
+}
 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);
+    if (error instanceof PiServerResponseError) {
+        return isRecoverableTreeDivergenceCode(error.code);
+    }
+    if (error && typeof error === "object" && "code" in error) {
+        return isRecoverableTreeDivergenceCode(error.code);
+    }
+    return false;
 }
-function isRecoverableMissingServerState(response, errorBody) {
+function isRecoverableMissingServerState(response, errorCode) {
     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);
+    return isRecoverableMissingServerStateCode(errorCode);
 }
 async function syncFullPiServerTree(sessionId, context, tree, request) {
     await postTreeJson(request, "/api/session/tree/sync", {
@@ -473,13 +551,13 @@ export async function compactPiServer(model, context, options) {
     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)) {
+        if (!options?.signal?.aborted && isRecoverableMissingServerState(response, failure.code)) {
             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: "" };
+                failure = { details: "", code: undefined };
             }
             else {
                 failure = await readPiServerFailure(response);
@@ -510,11 +588,6 @@ export async function compactPiServer(model, context, options) {
         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();
@@ -556,12 +629,12 @@ export async function streamPiServer(model, context, options) {
             let response = await request.postJson("/api/stream", makeBody());
             if (!response.ok) {
                 let failure = await readPiServerFailure(response);
-                if (!options?.signal?.aborted && isRecoverableMissingServerState(response, failure.matchText)) {
+                if (!options?.signal?.aborted && isRecoverableMissingServerState(response, failure.code)) {
                     resetSessionTracking(sessionId);
                     await ensureSessionInit(sessionId, context, request);
                     response = await request.postJson("/api/stream", makeBody());
                     if (response.ok) {
-                        failure = { details: "", matchText: "" };
+                        failure = { details: "", code: undefined };
                     }
                     else {
                         failure = await readPiServerFailure(response);
@@ -574,7 +647,19 @@ export async function streamPiServer(model, context, options) {
             await ensurePiServerEventStream(response);
             const reader = response.body.getReader();
             const decoder = new TextDecoder();
-            let buffer = "";
+            const parser = new ServerSentEventParser();
+            let terminalReceived = false;
+            const consumeEvents = (events) => {
+                for (const serverEvent of events) {
+                    const proxyEvent = parseServerSentEventData(serverEvent, "pi-server stream");
+                    const event = processProxyEvent(proxyEvent, partial);
+                    if (!event)
+                        continue;
+                    if (event.type === "done" || event.type === "error")
+                        terminalReceived = true;
+                    stream.push(event);
+                }
+            };
             while (true) {
                 const { done, value } = await reader.read();
                 if (done)
@@ -582,35 +667,26 @@ export async function streamPiServer(model, context, options) {
                 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);
-                        }
-                    }
-                }
+                consumeEvents(parser.feed(decoder.decode(value, { stream: true })));
             }
+            consumeEvents(parser.feed(decoder.decode()));
+            consumeEvents(parser.finish());
             if (options?.signal?.aborted) {
                 throw new Error("Request aborted by user");
             }
+            if (!terminalReceived) {
+                throw new Error("pi-server stream ended before a terminal response event");
+            }
             if (isEphemeralSession) {
                 resetSessionTracking(sessionId);
             }
             stream.end();
         }
         catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
+            let errorMessage = error instanceof Error ? error.message : String(error);
             if (!options?.signal?.aborted && phase === "provider_stream") {
                 try {
-                    const recoveredRun = await fetchPiServerRun(sessionId, runId, createPiServerRequest());
+                    const recoveredRun = await waitForPiServerRunCompletion(sessionId, runId, createPiServerRequest(options?.signal), options);
                     if (recoveredRun?.status === "completed" && recoveredRun.message) {
                         switch (recoveredRun.message.stopReason) {
                             case "stop":
@@ -633,9 +709,13 @@ export async function streamPiServer(model, context, options) {
                         stream.end();
                         return;
                     }
+                    if (recoveredRun?.status === "failed" && recoveredRun.errorMessage) {
+                        errorMessage = recoveredRun.errorMessage;
+                    }
                 }
-                catch {
-                    // Keep the original stream error authoritative.
+                catch (recoveryError) {
+                    phase = "history_reconcile";
+                    errorMessage = recoveryError instanceof Error ? recoveryError.message : String(recoveryError);
                 }
             }
             const reason = options?.signal?.aborted ? "aborted" : "error";
@@ -724,12 +804,15 @@ function processProxyEvent(proxyEvent, partial) {
         case "toolcall_end": {
             const content = partial.content[proxyEvent.contentIndex];
             if (content?.type === "toolCall") {
+                Object.assign(content, proxyEvent.toolCall);
                 delete content.partialJson;
                 return { type: "toolcall_end", contentIndex: proxyEvent.contentIndex, toolCall: content, partial };
             }
             return undefined;
         }
         case "done":
+            if (proxyEvent.message)
+                return { type: "done", reason: proxyEvent.reason, message: proxyEvent.message };
             partial.stopReason = proxyEvent.reason;
             partial.usage = proxyEvent.usage;
             partial.deferred = proxyEvent.deferred;