@averyyy/pi-server 0.84.2-piclient.1 → 0.84.2-piclient.3

package/dist/server.js

@@ -4,11 +4,12 @@ import { compactLegacy, DEFAULT_COMPACTION_SETTINGS, prepareLegacyCompaction, }
 import { createModels, createProvider, } from "@earendil-works/pi-ai";
 import { streamSimple } from "@earendil-works/pi-ai/compat";
 import { loadConfig } from "./config.js";
+import { PiServerError, PiServerErrorCode } from "./error-codes.js";
 import { encodeErrorEvent, encodeProxyEvent } from "./event-encoding.js";
 import { ReceiveUploadError, receiveUpload } from "./receive-upload.js";
 import { CHUNK_ENDPOINT, receiveRequestChunk } from "./request-chunks.js";
 import { deletePersistedSession, loadPersistedSessions, savePersistedSession } from "./session-persistence.js";
-import { appendCompactionEntry, appendMessages, appendSessionEntries, deleteSession as deleteSessionFromStore, dropLastAssistantError, getOrCreateSession, getSession, getSessionBranch, listSessions, replaceMessages, replaceSessionTree, setStaticContext, switchSessionLeaf, } from "./session-store.js";
+import { appendCompactionEntry, appendMessages, appendSessionEntries, deleteSession as deleteSessionFromStore, getOrCreateSession, getSession, getSessionBranch, listSessions, replaceMessages, replaceSessionTree, setStaticContext, switchSessionLeaf, } from "./session-store.js";
 export { loadConfig } from "./config.js";
 const packageMetadata = createRequire(import.meta.url)("../package.json");
 const PI_SERVER_VERSION = packageMetadata.version;
@@ -34,6 +35,7 @@ function createRequestModels(model, options) {
 const STREAM_HEARTBEAT = ": keep-alive\n\n";
 const JSON_HEARTBEAT = " \n";
 const STREAM_HEARTBEAT_INTERVAL_MS = 25_000;
+const STREAM_RUN_TTL_MS = 60 * 60 * 1000; // 1 hour
 const streamRuns = new Map();
 function readBody(req) {
     return new Promise((resolve, reject) => {
@@ -48,6 +50,14 @@ function sendJson(res, status, body) {
     res.writeHead(status, { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(data) });
     res.end(data);
 }
+function sendError(res, status, message, code, details) {
+    const body = { error: message };
+    if (code)
+        body.code = code;
+    if (details)
+        body.details = details;
+    sendJson(res, status, body);
+}
 function logRequestError(req, error) {
     const message = error instanceof Error ? error.stack || error.message : String(error);
     console.error(`${req.method ?? "UNKNOWN"} ${req.url ?? "/"} failed: ${message}`);
@@ -83,27 +93,58 @@ function getStreamRun(sessionId, runId) {
 }
 function startStreamRun(sessionId, runId) {
     const existing = getStreamRun(sessionId, runId);
-    if (existing?.status === "completed" || existing?.status === "failed")
+    if (existing?.status === "completed")
         return existing;
     const now = Date.now();
     const run = existing ?? {
         sessionId,
         runId,
         status: "running",
-        events: [],
         createdAt: now,
         updatedAt: now,
     };
+    if (existing) {
+        run.message = undefined;
+        run.errorMessage = undefined;
+    }
     run.status = "running";
     run.updatedAt = now;
     streamRuns.set(runKey(sessionId, runId), run);
     return run;
 }
-function recordStreamRunEvent(run, event) {
-    if (!run)
-        return;
-    run.events.push(event);
-    run.updatedAt = Date.now();
+function replayStreamRun(run) {
+    if (!run.message)
+        return [];
+    if (run.message.stopReason !== "stop" &&
+        run.message.stopReason !== "length" &&
+        run.message.stopReason !== "toolUse" &&
+        run.message.stopReason !== "deferred") {
+        return [];
+    }
+    const events = [{ type: "start" }];
+    for (const [contentIndex, content] of run.message.content.entries()) {
+        switch (content.type) {
+            case "text":
+                events.push({ type: "text_start", contentIndex }, { type: "text_delta", contentIndex, delta: content.text }, { type: "text_end", contentIndex, contentSignature: content.textSignature });
+                break;
+            case "thinking":
+                events.push({ type: "thinking_start", contentIndex }, { type: "thinking_delta", contentIndex, delta: content.thinking }, { type: "thinking_end", contentIndex, contentSignature: content.thinkingSignature });
+                break;
+            case "toolCall":
+                events.push({ type: "toolcall_start", contentIndex, id: content.id, toolName: content.name }, { type: "toolcall_delta", contentIndex, delta: JSON.stringify(content.arguments) }, { type: "toolcall_end", contentIndex, toolCall: content });
+                break;
+            default:
+                break;
+        }
+    }
+    events.push({
+        type: "done",
+        reason: run.message.stopReason,
+        usage: run.message.usage,
+        deferred: run.message.deferred,
+        message: run.message,
+    });
+    return events;
 }
 function completeStreamRun(run, message) {
     if (!run)
@@ -120,6 +161,40 @@ function failStreamRun(run, errorMessage) {
     run.errorMessage = errorMessage;
     run.updatedAt = Date.now();
 }
+function touchStreamRun(run) {
+    if (run)
+        run.updatedAt = Date.now();
+}
+function writeStreamEvent(res, event) {
+    if (!res.writableEnded && !res.destroyed) {
+        res.write(encodeProxyEvent(event));
+    }
+}
+function writeStreamError(res, message) {
+    if (!res.writableEnded && !res.destroyed) {
+        res.write(encodeErrorEvent(message));
+    }
+}
+function endStreamResponse(res) {
+    if (!res.writableEnded && !res.destroyed) {
+        res.end();
+    }
+}
+function cleanupExpiredStreamRuns(nowMs) {
+    for (const [key, run] of streamRuns) {
+        if (nowMs - run.updatedAt > STREAM_RUN_TTL_MS) {
+            streamRuns.delete(key);
+        }
+    }
+}
+function deleteStreamRunsForSession(sessionId) {
+    for (const [key, run] of streamRuns) {
+        if (run.sessionId === sessionId)
+            streamRuns.delete(key);
+    }
+}
+const streamRunCleanupTimer = setInterval(() => cleanupExpiredStreamRuns(Date.now()), STREAM_RUN_TTL_MS / 4);
+streamRunCleanupTimer.unref();
 function sessionHistoryFullResponseBody(session, baseMessageCount) {
     return {
         sessionId: session.sessionId,
@@ -156,12 +231,9 @@ function sessionTreePatchResponseBody(session, baseMessageCount, entriesFrom, ba
         },
     };
 }
-export function resolveStreamOptions(_config, model, body) {
-    return { model, options: { ...(body.options ?? {}) } };
-}
 function handleSessionInit(config, body, res) {
     if (!body.sessionId) {
-        sendJson(res, 400, { error: "sessionId is required" });
+        sendError(res, 400, "sessionId is required", PiServerErrorCode.REQUIRED_FIELD_MISSING);
         return;
     }
     if (body.staticContext) {
@@ -176,11 +248,11 @@ function handleSessionInit(config, body, res) {
 }
 function handleSessionUpdate(config, body, res) {
     if (!body.sessionId) {
-        sendJson(res, 400, { error: "sessionId is required" });
+        sendError(res, 400, "sessionId is required", PiServerErrorCode.REQUIRED_FIELD_MISSING);
         return;
     }
     if (!body.staticContext) {
-        sendJson(res, 400, { error: "staticContext is required for update" });
+        sendError(res, 400, "staticContext is required for update", PiServerErrorCode.REQUIRED_FIELD_MISSING);
         return;
     }
     setStaticContext(body.sessionId, body.staticContext);
@@ -190,11 +262,11 @@ function handleSessionUpdate(config, body, res) {
 }
 function handleSessionSync(config, body, res) {
     if (!body.sessionId) {
-        sendJson(res, 400, { error: "sessionId is required" });
+        sendError(res, 400, "sessionId is required", PiServerErrorCode.REQUIRED_FIELD_MISSING);
         return;
     }
     if (!Array.isArray(body.messages)) {
-        sendJson(res, 400, { error: "messages is required" });
+        sendError(res, 400, "messages is required", PiServerErrorCode.REQUIRED_FIELD_MISSING);
         return;
     }
     if (body.staticContext) {
@@ -206,11 +278,11 @@ function handleSessionSync(config, body, res) {
 }
 function handleSessionAppend(config, body, res) {
     if (!body.sessionId) {
-        sendJson(res, 400, { error: "sessionId is required" });
+        sendError(res, 400, "sessionId is required", PiServerErrorCode.REQUIRED_FIELD_MISSING);
         return;
     }
     if (!Array.isArray(body.messages)) {
-        sendJson(res, 400, { error: "messages is required" });
+        sendError(res, 400, "messages is required", PiServerErrorCode.REQUIRED_FIELD_MISSING);
         return;
     }
     if (body.staticContext) {
@@ -222,11 +294,11 @@ function handleSessionAppend(config, body, res) {
 }
 function handleSessionTreeSync(config, body, res) {
     if (!body.sessionId) {
-        sendJson(res, 400, { error: "sessionId is required" });
+        sendError(res, 400, "sessionId is required", PiServerErrorCode.REQUIRED_FIELD_MISSING);
         return;
     }
     if (!Array.isArray(body.entries)) {
-        sendJson(res, 400, { error: "entries is required" });
+        sendError(res, 400, "entries is required", PiServerErrorCode.REQUIRED_FIELD_MISSING);
         return;
     }
     if (body.staticContext) {
@@ -238,28 +310,50 @@ function handleSessionTreeSync(config, body, res) {
 }
 function handleSessionTreeAppend(config, body, res) {
     if (!body.sessionId) {
-        sendJson(res, 400, { error: "sessionId is required" });
+        sendError(res, 400, "sessionId is required", PiServerErrorCode.REQUIRED_FIELD_MISSING);
         return;
     }
     if (!Array.isArray(body.entries)) {
-        sendJson(res, 400, { error: "entries is required" });
+        sendError(res, 400, "entries is required", PiServerErrorCode.REQUIRED_FIELD_MISSING);
         return;
     }
-    if (body.staticContext) {
-        setStaticContext(body.sessionId, body.staticContext);
+    try {
+        if (body.staticContext) {
+            setStaticContext(body.sessionId, body.staticContext);
+        }
+        const session = appendSessionEntries(body.sessionId, body.entries, body.leafId ?? null);
+        persistSession(config, session);
+        sendJson(res, 200, sessionResponseBody(session));
+    }
+    catch (error) {
+        if (error instanceof PiServerError) {
+            sendError(res, 400, error.message, error.code, error.details);
+        }
+        else {
+            const message = error instanceof Error ? error.message : String(error);
+            sendError(res, 500, message, PiServerErrorCode.INTERNAL_ERROR);
+        }
     }
-    const session = appendSessionEntries(body.sessionId, body.entries, body.leafId ?? null);
-    persistSession(config, session);
-    sendJson(res, 200, sessionResponseBody(session));
 }
 function handleSessionTreeSwitch(config, body, res) {
     if (!body.sessionId) {
-        sendJson(res, 400, { error: "sessionId is required" });
+        sendError(res, 400, "sessionId is required", PiServerErrorCode.REQUIRED_FIELD_MISSING);
         return;
     }
-    const session = switchSessionLeaf(body.sessionId, body.leafId ?? null);
-    persistSession(config, session);
-    sendJson(res, 200, sessionResponseBody(session));
+    try {
+        const session = switchSessionLeaf(body.sessionId, body.leafId ?? null);
+        persistSession(config, session);
+        sendJson(res, 200, sessionResponseBody(session));
+    }
+    catch (error) {
+        if (error instanceof PiServerError) {
+            sendError(res, 400, error.message, error.code, error.details);
+        }
+        else {
+            const message = error instanceof Error ? error.message : String(error);
+            sendError(res, 500, message, PiServerErrorCode.INTERNAL_ERROR);
+        }
+    }
 }
 function prepareSessionCompact(body) {
     if (!body.sessionId) {
@@ -270,7 +364,7 @@ function prepareSessionCompact(body) {
     }
     const session = getSession(body.sessionId);
     if (!session) {
-        return { status: 404, body: { error: "session not found" } };
+        return { status: 404, body: { error: "session not found", code: PiServerErrorCode.SESSION_NOT_FOUND } };
     }
     const entries = getSessionBranch(session);
     const preparationResult = prepareLegacyCompaction(entries, body.settings ?? DEFAULT_COMPACTION_SETTINGS, body.preparation);
@@ -290,7 +384,7 @@ function prepareSessionCompact(body) {
 async function completeSessionCompact(config, body, prepared) {
     const result = await compactLegacy(prepared.preparation, createRequestModels(body.model, prepared.options), body.model, body.customInstructions, undefined, prepared.options.reasoning);
     if (!result.ok) {
-        return { status: 500, body: { error: result.error.message } };
+        return { status: 500, body: { error: result.error.message, code: PiServerErrorCode.INTERNAL_ERROR } };
     }
     const baseTreeHash = prepared.session.treeHash;
     const baseEntryCount = prepared.session.entries.length;
@@ -399,23 +493,10 @@ async function handleSessionCompact(config, body, res) {
     }
     await handleSessionCompactJsonStream(config, body, prepared, res);
 }
-function handleDropLastAssistantError(config, body, res) {
-    if (!body.sessionId) {
-        sendJson(res, 400, { error: "sessionId is required" });
-        return;
-    }
-    const dropped = dropLastAssistantError(body.sessionId);
-    const session = getSession(body.sessionId);
-    if (session) {
-        persistSession(config, session);
-    }
-    const messageCount = session?.messages.length ?? 0;
-    sendJson(res, 200, { success: true, dropped, messageCount });
-}
 function handleSessionHistory(sessionId, from, entriesFrom, revision, baseTreeHash, res) {
     const session = getSession(sessionId);
     if (!session) {
-        sendJson(res, 404, { error: "session not found" });
+        sendError(res, 404, "session not found", PiServerErrorCode.SESSION_NOT_FOUND);
         return;
     }
     const baseMessageCount = from ?? 0;
@@ -431,7 +512,7 @@ function handleSessionHistory(sessionId, from, entriesFrom, revision, baseTreeHa
 function handleSessionRun(sessionId, runId, res) {
     const run = getStreamRun(sessionId, runId);
     if (!run) {
-        sendJson(res, 404, { error: "run not found" });
+        sendError(res, 404, "run not found", PiServerErrorCode.RUN_NOT_FOUND);
         return;
     }
     sendJson(res, 200, run);
@@ -446,33 +527,53 @@ export function buildStreamContext(session, body) {
 }
 function handleStream(config, body, res) {
     if (!body.sessionId) {
-        sendJson(res, 400, { error: "sessionId is required" });
+        sendError(res, 400, "sessionId is required", PiServerErrorCode.REQUIRED_FIELD_MISSING);
         return;
     }
     if (!body.model) {
-        sendJson(res, 400, { error: "model is required" });
+        sendError(res, 400, "model is required", PiServerErrorCode.REQUIRED_FIELD_MISSING);
         return;
     }
+    cleanupExpiredStreamRuns(Date.now());
     const session = getOrCreateSession(body.sessionId);
     if (body.staticContext) {
         setStaticContext(body.sessionId, body.staticContext);
         persistSession(config, session);
     }
     if (!session.staticContext && !body.staticContext) {
-        sendJson(res, 400, { error: "Session has no static context. Initialize with /api/session/init first." });
+        sendError(res, 400, "Session has no static context. Initialize with /api/session/init first.", PiServerErrorCode.SESSION_NO_STATIC_CONTEXT);
         return;
     }
     if (body.ephemeralMessages !== undefined && !Array.isArray(body.ephemeralMessages)) {
-        sendJson(res, 400, { error: "ephemeralMessages must be an array" });
+        sendError(res, 400, "ephemeralMessages must be an array", PiServerErrorCode.INVALID_REQUEST);
         return;
     }
     if (body.contextOverlay !== undefined && !Array.isArray(body.contextOverlay)) {
-        sendJson(res, 400, { error: "contextOverlay must be an array" });
+        sendError(res, 400, "contextOverlay must be an array", PiServerErrorCode.INVALID_REQUEST);
         return;
     }
     const context = buildStreamContext(session, body);
     const existingRun = body.runId ? getStreamRun(body.sessionId, body.runId) : undefined;
-    const { model: resolvedModel, options: streamOptions } = resolveStreamOptions(config, body.model, body);
+    const resolvedModel = body.model;
+    const streamOptions = { ...(body.options ?? {}) };
+    if (existingRun?.status === "completed") {
+        res.writeHead(200, {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+        });
+        res.flushHeaders();
+        res.write(STREAM_HEARTBEAT);
+        for (const event of replayStreamRun(existingRun)) {
+            writeStreamEvent(res, event);
+        }
+        endStreamResponse(res);
+        return;
+    }
+    if (existingRun?.status === "running") {
+        sendError(res, 409, "A stream with this runId is already in progress", PiServerErrorCode.RUN_IN_PROGRESS);
+        return;
+    }
     res.writeHead(200, {
         "Content-Type": "text/event-stream",
         "Cache-Control": "no-cache",
@@ -480,16 +581,10 @@ function handleStream(config, body, res) {
     });
     res.flushHeaders();
     res.write(STREAM_HEARTBEAT);
-    if (existingRun?.status === "completed") {
-        for (const event of existingRun.events) {
-            res.write(encodeProxyEvent(event));
-        }
-        res.end();
-        return;
-    }
     const run = body.runId ? startStreamRun(body.sessionId, body.runId) : undefined;
     const heartbeat = setInterval(() => {
-        if (!res.writableEnded) {
+        touchStreamRun(run);
+        if (!res.writableEnded && !res.destroyed) {
             res.write(STREAM_HEARTBEAT);
         }
     }, STREAM_HEARTBEAT_INTERVAL_MS);
@@ -502,8 +597,8 @@ function handleStream(config, body, res) {
         clearInterval(heartbeat);
         const message = err instanceof Error ? err.message : String(err);
         failStreamRun(run, message);
-        res.write(encodeErrorEvent(message));
-        res.end();
+        writeStreamError(res, message);
+        endStreamResponse(res);
         return;
     }
     (async () => {
@@ -511,8 +606,8 @@ function handleStream(config, body, res) {
             for await (const event of stream) {
                 const proxyEvent = toProxyEvent(event);
                 if (proxyEvent) {
-                    recordStreamRunEvent(run, proxyEvent);
-                    res.write(encodeProxyEvent(proxyEvent));
+                    touchStreamRun(run);
+                    writeStreamEvent(res, proxyEvent);
                 }
                 if (event.type === "done") {
                     completeStreamRun(run, event.message);
@@ -525,13 +620,13 @@ function handleStream(config, body, res) {
         finally {
             clearInterval(heartbeat);
         }
-        res.end();
+        endStreamResponse(res);
     })().catch((err) => {
         clearInterval(heartbeat);
         const message = err instanceof Error ? err.message : String(err);
         failStreamRun(run, message);
-        res.write(encodeErrorEvent(message));
-        res.end();
+        writeStreamError(res, message);
+        endStreamResponse(res);
     });
 }
 async function handlePostRequest(config, pathname, body, res) {
@@ -574,10 +669,6 @@ async function handlePostRequest(config, pathname, body, res) {
         handleSessionTreeSwitch(config, body, res);
         return true;
     }
-    if (pathname === "/api/session/drop-last-assistant-error") {
-        handleDropLastAssistantError(config, body, res);
-        return true;
-    }
     if (pathname === "/api/session/compact") {
         await handleSessionCompact(config, body, res);
         return true;
@@ -618,19 +709,19 @@ export function createPiServer(configOverride) {
             const fromParam = url.searchParams.get("from");
             const from = fromParam === null ? undefined : Number(fromParam);
             if (from !== undefined && (!Number.isInteger(from) || from < 0)) {
-                sendJson(res, 400, { error: "from must be a non-negative integer" });
+                sendError(res, 400, "from must be a non-negative integer", PiServerErrorCode.INVALID_REQUEST);
                 return;
             }
             const entriesFromParam = url.searchParams.get("entriesFrom");
             const entriesFrom = entriesFromParam === null ? undefined : Number(entriesFromParam);
             if (entriesFrom !== undefined && (!Number.isInteger(entriesFrom) || entriesFrom < 0)) {
-                sendJson(res, 400, { error: "entriesFrom must be a non-negative integer" });
+                sendError(res, 400, "entriesFrom must be a non-negative integer", PiServerErrorCode.INVALID_REQUEST);
                 return;
             }
             const revisionParam = url.searchParams.get("revision");
             const revision = revisionParam === null ? undefined : Number(revisionParam);
             if (revision !== undefined && (!Number.isInteger(revision) || revision < 0)) {
-                sendJson(res, 400, { error: "revision must be a non-negative integer" });
+                sendError(res, 400, "revision must be a non-negative integer", PiServerErrorCode.INVALID_REQUEST);
                 return;
             }
             handleSessionHistory(decodeURIComponent(encodedSessionId), from, entriesFrom, revision, url.searchParams.get("baseTreeHash") ?? undefined, res);
@@ -644,12 +735,15 @@ export function createPiServer(configOverride) {
                     sendJson(res, 200, chunkResult.ack);
                     return;
                 }
-                await handlePostRequest(config, chunkResult.target, JSON.parse(chunkResult.bodyJson), res);
+                const handled = await handlePostRequest(config, chunkResult.target, JSON.parse(chunkResult.bodyJson), res);
+                if (!handled && !res.headersSent) {
+                    sendError(res, 404, "Not found", PiServerErrorCode.INVALID_REQUEST);
+                }
             }
             catch (err) {
                 logRequestError(req, err);
                 if (!res.headersSent) {
-                    sendJson(res, 400, { error: err instanceof Error ? err.message : String(err) });
+                    sendError(res, 400, err instanceof Error ? err.message : String(err), PiServerErrorCode.INVALID_REQUEST);
                 }
                 else {
                     res.write(encodeErrorEvent(err instanceof Error ? err.message : String(err)));
@@ -663,11 +757,15 @@ export function createPiServer(configOverride) {
                 const body = JSON.parse(await readBody(req));
                 if (await handlePostRequest(config, url.pathname, body, res))
                     return;
+                if (!res.headersSent) {
+                    sendError(res, 404, "Not found", PiServerErrorCode.INVALID_REQUEST);
+                    return;
+                }
             }
             catch (err) {
                 logRequestError(req, err);
                 if (!res.headersSent) {
-                    sendJson(res, 500, { error: err instanceof Error ? err.message : String(err) });
+                    sendError(res, 500, err instanceof Error ? err.message : String(err), PiServerErrorCode.INTERNAL_ERROR);
                 }
                 else {
                     res.write(encodeErrorEvent(err instanceof Error ? err.message : String(err)));
@@ -679,11 +777,12 @@ export function createPiServer(configOverride) {
         if (req.method === "DELETE" && url.pathname.startsWith("/api/session/")) {
             const sessionId = decodeURIComponent(url.pathname.slice("/api/session/".length));
             deleteSessionFromStore(sessionId);
+            deleteStreamRunsForSession(sessionId);
             deletePersistedSession(config.sessionStoreDir, sessionId);
             sendJson(res, 200, { deleted: sessionId });
             return;
         }
-        sendJson(res, 404, { error: "Not found" });
+        sendError(res, 404, "Not found", PiServerErrorCode.INVALID_REQUEST);
     });
     return server;
 }