@averyyy/pi-server 0.99.1-piclient.1 → 1.0.0-piclient.2

package/dist/server.js

@@ -1,8 +1,14 @@
+import { randomUUID } from "node:crypto";
 import { createServer } from "node:http";
 import { createRequire } from "node:module";
 import { compactLegacy, convertToLlm, DEFAULT_COMPACTION_SETTINGS, prepareLegacyCompaction, } from "@earendil-works/pi-agent-core";
 import { createModels, createProvider, } from "@earendil-works/pi-ai";
-import { streamSimple } from "@earendil-works/pi-ai/compat";
+import { cloudflareWorkersAISystemOneApi } from "@earendil-works/pi-ai/api/cloudflare-workers-ai-system-one.lazy";
+import { llamaCppClassifyApi } from "@earendil-works/pi-ai/api/llama-cpp-classify.lazy";
+import { typesafeSystemOneApi } from "@earendil-works/pi-ai/api/typesafe-system-one.lazy";
+import { getBuiltinProviderForModel, getEnvApiKey, getImagesApiProvider, stream as streamApi, streamSimple, } from "@earendil-works/pi-ai/compat";
+import { builtinModels } from "@earendil-works/pi-ai/providers/all";
+import { getProviderEnvValue } from "@earendil-works/pi-ai/utils/provider-env";
 import { loadConfig } from "./config.js";
 import { PiServerError, PiServerErrorCode } from "./error-codes.js";
 import { encodeErrorEvent, encodeProxyEvent } from "./event-encoding.js";
@@ -16,22 +22,50 @@ const packageMetadata = createRequire(import.meta.url)("../package.json");
 const PI_SERVER_VERSION = packageMetadata.version;
 function createRequestModels(model, options) {
     const models = createModels();
-    const requestStream = (requestModel, context, streamOptions) => streamSimple(requestModel, context, {
-        ...streamOptions,
-        ...(options.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {}),
-    });
+    const builtin = getBuiltinProviderForModel(model);
+    const requestApiStream = (requestModel, context, streamOptions) => builtin
+        ? builtin.stream(requestModel, context, streamOptions)
+        : streamApi(requestModel, context, streamOptions);
+    const requestStream = (requestModel, context, streamOptions) => {
+        const requestOptions = {
+            ...streamOptions,
+            ...(options.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {}),
+        };
+        return builtin
+            ? builtin.streamSimple(requestModel, context, requestOptions)
+            : streamSimple(requestModel, context, requestOptions);
+    };
     models.setProvider(createProvider({
         id: model.provider,
         name: model.provider,
         models: [model],
-        auth: {
-            apiKey: {
-                name: "pi-server request auth",
-                resolve: async () => ({ auth: { apiKey: options.apiKey, headers: options.headers } }),
+        auth: builtin
+            ? {
+                ...builtin.auth,
+                apiKey: {
+                    name: builtin.auth.apiKey?.name ?? "pi-server request auth",
+                    resolve: async (request) => {
+                        const resolved = await builtin.auth.apiKey?.resolve(request);
+                        if (resolved)
+                            return resolved;
+                        // Declared request credentials are validated by the native provider.
+                        if (options.apiKey !== undefined ||
+                            options.headers !== undefined ||
+                            model.headers !== undefined) {
+                            return { auth: { apiKey: options.apiKey, headers: options.headers }, env: options.env };
+                        }
+                        return undefined;
+                    },
+                },
+            }
+            : {
+                apiKey: {
+                    name: "pi-server request auth",
+                    resolve: async () => ({ auth: { apiKey: options.apiKey, headers: options.headers } }),
+                },
             },
-        },
         api: {
-            stream: requestStream,
+            stream: requestApiStream,
             streamSimple: requestStream,
         },
     }));
@@ -102,6 +136,8 @@ function createRunRecord(sessionId, runId, kind) {
         resolveSettled = resolve;
     });
     return {
+        callbacks: new Map(),
+        callbackConnectionClosed: false,
         sessionId,
         runId,
         kind,
@@ -117,6 +153,7 @@ function createRunRecord(sessionId, runId, kind) {
 function settleRun(run) {
     if (!run)
         return;
+    rejectProviderCallbacks(run, new Error("Provider run settled before callback reply"));
     const resolve = run.resolveSettled;
     run.resolveSettled = undefined;
     resolve?.();
@@ -127,7 +164,9 @@ function startStreamRun(sessionId, runId, kind = "stream") {
         return existing;
     const run = existing ?? createRunRecord(sessionId, runId, kind);
     if (existing) {
+        run.callbackConnectionClosed = false;
         run.message = undefined;
+        run.cacheRetention = undefined;
         run.errorMessage = undefined;
         run.cancelRequested = false;
         run.controller = new AbortController();
@@ -151,7 +190,9 @@ function streamRunResponseBody(run) {
         createdAt: run.createdAt,
         updatedAt: run.updatedAt,
         ...(run.message ? { message: run.message } : {}),
+        ...(run.cacheRetention !== undefined ? { cacheRetention: run.cacheRetention } : {}),
         ...(run.compactResult ? { compactResult: run.compactResult } : {}),
+        ...(run.operationResult ? { operationResult: run.operationResult } : {}),
         ...(run.errorMessage ? { errorMessage: run.errorMessage } : {}),
     };
 }
@@ -204,7 +245,7 @@ function completeStreamRun(run, message) {
     run.errorMessage = undefined;
     run.updatedAt = Date.now();
 }
-function failStreamRun(run, errorMessage) {
+function failStreamRun(run, errorMessage, message) {
     if (!run)
         return;
     if (run.cancelRequested) {
@@ -214,6 +255,7 @@ function failStreamRun(run, errorMessage) {
         return;
     }
     run.status = "failed";
+    run.message = message;
     run.errorMessage = errorMessage;
     run.updatedAt = Date.now();
 }
@@ -221,6 +263,94 @@ function touchStreamRun(run) {
     if (run)
         run.updatedAt = Date.now();
 }
+function rejectProviderCallbacks(run, error) {
+    const pending = [...run.callbacks.values()];
+    run.callbacks.clear();
+    for (const callback of pending)
+        callback.reject(error);
+}
+function createProviderCallbacks(run, res, callbacks) {
+    if (!callbacks?.onPayload && !callbacks?.onResponse)
+        return {};
+    res.once("close", () => {
+        run.callbackConnectionClosed = true;
+        rejectProviderCallbacks(run, new Error("Provider callback connection closed"));
+    });
+    run.controller.signal.addEventListener("abort", () => rejectProviderCallbacks(run, new DOMException("Provider run aborted", "AbortError")), { once: true });
+    const requestCallback = (request) => {
+        if (run.controller.signal.aborted)
+            return Promise.reject(new DOMException("Provider run aborted", "AbortError"));
+        if (run.callbackConnectionClosed || res.destroyed || res.writableEnded)
+            return Promise.reject(new Error("Provider callback connection closed"));
+        return new Promise((resolve, reject) => {
+            run.callbacks.set(request.callbackId, { resolve, reject });
+            try {
+                writeServerSentEvent(res, "provider_callback", request);
+            }
+            catch (error) {
+                run.callbacks.delete(request.callbackId);
+                reject(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+    };
+    return {
+        ...(callbacks.onPayload
+            ? {
+                onPayload: (payload, model) => requestCallback({
+                    callbackId: randomUUID(),
+                    kind: "payload",
+                    model: { ...model, headers: undefined },
+                    payload,
+                }),
+            }
+            : {}),
+        ...(callbacks.onResponse
+            ? {
+                onResponse: async (response, model) => {
+                    await requestCallback({
+                        callbackId: randomUUID(),
+                        kind: "response",
+                        model: { ...model, headers: undefined },
+                        response,
+                    });
+                },
+            }
+            : {}),
+    };
+}
+function handleProviderCallbackReply(body, res) {
+    if (!body || typeof body !== "object") {
+        sendError(res, 400, "Provider callback reply must be an object", PiServerErrorCode.INVALID_REQUEST);
+        return;
+    }
+    const reply = body;
+    if (typeof reply.sessionId !== "string" || typeof reply.runId !== "string" || typeof reply.callbackId !== "string") {
+        sendError(res, 400, "sessionId, runId and callbackId are required", PiServerErrorCode.REQUIRED_FIELD_MISSING);
+        return;
+    }
+    const run = getStreamRun(reply.sessionId, reply.runId);
+    const pending = run?.callbacks.get(reply.callbackId);
+    if (!run || run.status !== "running" || !pending) {
+        sendError(res, 409, "Provider callback is no longer pending", PiServerErrorCode.INVALID_REQUEST);
+        return;
+    }
+    let error;
+    if (reply.error !== undefined) {
+        const remoteError = reply.error;
+        if (!remoteError || typeof remoteError.name !== "string" || typeof remoteError.message !== "string") {
+            sendError(res, 400, "Provider callback error requires string name and message", PiServerErrorCode.INVALID_REQUEST);
+            return;
+        }
+        error = new Error(remoteError.message);
+        error.name = remoteError.name;
+    }
+    run.callbacks.delete(reply.callbackId);
+    sendJson(res, 200, { accepted: true, callbackId: reply.callbackId, runId: reply.runId });
+    if (error)
+        pending.reject(error);
+    else
+        pending.resolve(reply.result);
+}
 function writeStreamEvent(res, event) {
     if (!res.writableEnded && !res.destroyed) {
         res.write(encodeProxyEvent(event));
@@ -243,9 +373,19 @@ function cleanupExpiredStreamRuns(nowMs) {
         }
     }
 }
-function deleteStreamRunsForSession(sessionId) {
-    for (const [key, run] of streamRuns) {
-        if (run.sessionId === sessionId)
+async function deleteStreamRunsForSession(sessionId) {
+    const runs = [...streamRuns.entries()].filter(([, run]) => run.sessionId === sessionId);
+    for (const [, run] of runs) {
+        if (run.status !== "running")
+            continue;
+        run.cancelRequested = true;
+        run.updatedAt = Date.now();
+        run.controller.abort();
+        rejectProviderCallbacks(run, new DOMException("Provider session deleted", "AbortError"));
+    }
+    await Promise.all(runs.map(([, run]) => run.settled));
+    for (const [key, run] of runs) {
+        if (streamRuns.get(key) === run)
             streamRuns.delete(key);
     }
 }
@@ -411,7 +551,7 @@ function handleSessionTreeSwitch(config, body, res) {
         }
     }
 }
-function prepareSessionCompact(body) {
+function prepareSessionCompact(body, models) {
     if (!body.sessionId) {
         return { status: 400, body: { error: "sessionId is required" } };
     }
@@ -491,6 +631,7 @@ function prepareSessionCompact(body) {
         }
     }
     return {
+        models: models ?? createRequestModels(body.model, options),
         session,
         sessionId: session.sessionId,
         revision: session.revision,
@@ -522,7 +663,7 @@ function sessionCompactConflict(body, prepared, currentSession) {
     };
 }
 async function completeSessionCompact(config, body, prepared, run) {
-    const result = await compactLegacy(prepared.preparation, createRequestModels(body.model, prepared.options), body.model, body.customInstructions, run?.controller.signal, prepared.options.reasoning, undefined, undefined, prepared.cacheContext, prepared.options, prepared.cacheFallbackReason);
+    const result = await compactLegacy(prepared.preparation, prepared.models, body.model, body.customInstructions, run?.controller.signal, prepared.options.reasoning, undefined, undefined, prepared.cacheContext, prepared.options, prepared.cacheFallbackReason);
     if (!result.ok) {
         return { status: 500, body: { error: result.error.message, code: PiServerErrorCode.INTERNAL_ERROR } };
     }
@@ -666,7 +807,7 @@ function finishCompactRun(run, result) {
     }
     run.updatedAt = Date.now();
 }
-async function handleSessionCompact(config, body, res) {
+async function handleSessionCompact(config, body, res, models) {
     const existingRun = body.runId ? getStreamRun(body.sessionId, body.runId) : undefined;
     if (existingRun?.status === "aborted") {
         sendJson(res, 409, { error: "Compaction run was aborted", code: PiServerErrorCode.INVALID_REQUEST });
@@ -676,7 +817,7 @@ async function handleSessionCompact(config, body, res) {
         sendJson(res, 200, existingRun.compactResult);
         return;
     }
-    const prepared = prepareSessionCompact(body);
+    const prepared = prepareSessionCompact(body, models);
     if ("status" in prepared) {
         sendJson(res, prepared.status, prepared.body);
         return;
@@ -749,6 +890,7 @@ async function handleSessionRunAbort(sessionId, runId, res) {
     run.cancelRequested = true;
     run.updatedAt = Date.now();
     run.controller.abort();
+    rejectProviderCallbacks(run, new DOMException("Provider run aborted", "AbortError"));
     await run.settled;
     sendJson(res, 200, streamRunResponseBody(run));
 }
@@ -760,7 +902,7 @@ export function buildStreamContext(session, body) {
         tools: session.staticContext?.tools,
     };
 }
-function handleStream(config, body, res) {
+function handleStream(config, body, res, models) {
     if (!body.sessionId) {
         sendError(res, 400, "sessionId is required", PiServerErrorCode.REQUIRED_FIELD_MISSING);
         return;
@@ -769,6 +911,10 @@ function handleStream(config, body, res) {
         sendError(res, 400, "model is required", PiServerErrorCode.REQUIRED_FIELD_MISSING);
         return;
     }
+    if ((body.callbacks?.onPayload || body.callbacks?.onResponse) && !body.runId) {
+        sendError(res, 400, "runId is required for provider callbacks", PiServerErrorCode.REQUIRED_FIELD_MISSING);
+        return;
+    }
     cleanupExpiredStreamRuns(Date.now());
     const session = getOrCreateSession(body.sessionId);
     if (body.staticContext) {
@@ -798,6 +944,9 @@ function handleStream(config, body, res) {
         });
         res.flushHeaders();
         res.write(STREAM_HEARTBEAT);
+        if (existingRun.cacheRetention !== undefined) {
+            writeServerSentEvent(res, "cache_policy", { cacheRetention: existingRun.cacheRetention });
+        }
         for (const event of replayStreamRun(existingRun)) {
             writeStreamEvent(res, event);
         }
@@ -815,7 +964,31 @@ function handleStream(config, body, res) {
     const run = body.runId ? startStreamRun(body.sessionId, body.runId) : undefined;
     const streamOptions = {
         ...(body.options ?? {}),
+        transformPreparedStreamOptions: (prepared) => {
+            // Resolve after auth env merging, then pin the same policy for native dispatch.
+            const cacheRetention = prepared.cacheRetention ??
+                (getProviderEnvValue("PI_CACHE_RETENTION", prepared.env) === "long" ? "long" : "short");
+            if (cacheRetention !== "none" && cacheRetention !== "short" && cacheRetention !== "long") {
+                throw new Error("Invalid cache retention policy");
+            }
+            if (run)
+                run.cacheRetention = cacheRetention;
+            writeServerSentEvent(res, "cache_policy", { cacheRetention });
+            return { ...prepared, cacheRetention };
+        },
         ...(run ? { signal: run.controller.signal } : {}),
+        ...(run ? createProviderCallbacks(run, res, body.callbacks) : {}),
+        ...(body.observeProviderStreamEvents
+            ? {
+                onProviderStreamEvent: (data, model) => {
+                    writeStreamEvent(res, {
+                        type: "provider_stream_event",
+                        data,
+                        model: { ...model, headers: undefined },
+                    });
+                },
+            }
+            : {}),
     };
     res.writeHead(200, {
         "Content-Type": "text/event-stream",
@@ -833,7 +1006,18 @@ function handleStream(config, body, res) {
     heartbeat.unref();
     let stream;
     try {
-        stream = streamSimple(resolvedModel, context, streamOptions);
+        if (body.requestKind === "deferred") {
+            if (!body.deferredHandle)
+                throw new Error("deferredHandle is required for deferred fetch");
+            stream = (models ?? builtinModels()).streamDeferred(resolvedModel, body.deferredHandle, streamOptions);
+        }
+        else {
+            const requestModels = models ?? createRequestModels(resolvedModel, streamOptions);
+            stream =
+                body.requestKind === "api"
+                    ? requestModels.stream(resolvedModel, context, streamOptions)
+                    : requestModels.streamSimple(resolvedModel, context, streamOptions);
+        }
     }
     catch (err) {
         clearInterval(heartbeat);
@@ -856,7 +1040,7 @@ function handleStream(config, body, res) {
                     completeStreamRun(run, event.message);
                 }
                 else if (event.type === "error") {
-                    failStreamRun(run, event.error.errorMessage ?? event.reason);
+                    failStreamRun(run, event.error.errorMessage ?? event.reason, event.error);
                 }
             }
         }
@@ -875,7 +1059,23 @@ function handleStream(config, body, res) {
         }
     })();
 }
-async function handlePostRequest(config, pathname, body, res) {
+async function handlePostRequest(config, pathname, body, res, models, streamModels) {
+    if (pathname === "/api/provider-callback") {
+        handleProviderCallbackReply(body, res);
+        return true;
+    }
+    if (pathname === "/api/generate-images") {
+        await handleModelOperation(models, { ...body, kind: "image" }, res);
+        return true;
+    }
+    if (pathname === "/api/classify") {
+        await handleModelOperation(models, { ...body, kind: "classifier" }, res);
+        return true;
+    }
+    if (pathname === "/api/cancel-deferred") {
+        await handleModelOperation(models, { ...body, kind: "deferred-cancel" }, res);
+        return true;
+    }
     if (pathname === "/api/receive") {
         try {
             sendJson(res, 200, receiveUpload(config.uploadDir, body));
@@ -916,17 +1116,136 @@ async function handlePostRequest(config, pathname, body, res) {
         return true;
     }
     if (pathname === "/api/session/compact") {
-        await handleSessionCompact(config, body, res);
+        await handleSessionCompact(config, body, res, streamModels);
         return true;
     }
     if (pathname === "/api/stream") {
-        handleStream(config, body, res);
+        handleStream(config, body, res, streamModels);
         return true;
     }
     return false;
 }
-export function createPiServer(configOverride) {
+const CLASSIFIER_APIS = {
+    "typesafe-system-one": typesafeSystemOneApi(),
+    "cloudflare-workers-ai-system-one": cloudflareWorkersAISystemOneApi(),
+    "llama-cpp-classify": llamaCppClassifyApi(),
+};
+async function handleModelOperation(models, body, res) {
+    if (!body.sessionId ||
+        !body.runId ||
+        !body.model ||
+        (body.kind === "deferred-cancel" ? !body.handle : !body.context)) {
+        sendError(res, 400, "sessionId, runId, model and operation input are required", PiServerErrorCode.REQUIRED_FIELD_MISSING);
+        return;
+    }
+    const existing = getStreamRun(body.sessionId, body.runId);
+    if (existing && existing.kind !== body.kind) {
+        sendError(res, 409, "runId belongs to a different operation", PiServerErrorCode.INVALID_REQUEST);
+        return;
+    }
+    if (existing?.status === "running") {
+        sendError(res, 409, "A run with this runId is already in progress", PiServerErrorCode.RUN_IN_PROGRESS);
+        return;
+    }
+    if (existing?.status === "aborted") {
+        sendError(res, 409, "Model operation was aborted", PiServerErrorCode.INVALID_REQUEST);
+        return;
+    }
+    const run = existing?.operationResult ? existing : startStreamRun(body.sessionId, body.runId, body.kind);
+    res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive" });
+    res.flushHeaders();
+    res.write(STREAM_HEARTBEAT);
+    const heartbeat = setInterval(() => {
+        touchStreamRun(run);
+        if (!res.destroyed && !res.writableEnded)
+            res.write(STREAM_HEARTBEAT);
+    }, STREAM_HEARTBEAT_INTERVAL_MS);
+    heartbeat.unref();
+    try {
+        if (!run.operationResult) {
+            const requestModels = body.kind === "deferred-cancel" ? models : resolveOperationModels(models, body.model, body.options);
+            const result = body.kind === "deferred-cancel"
+                ? await requestModels
+                    .cancelDeferred(body.model, body.handle, {
+                    ...body.options,
+                    ...createProviderCallbacks(run, res, body.callbacks),
+                    signal: run.controller.signal,
+                })
+                    .then(() => ({ cancelled: true, stopReason: "stop" }))
+                : body.kind === "image"
+                    ? await requestModels.generateImages(body.model, body.context, {
+                        ...body.options,
+                        ...createProviderCallbacks(run, res, body.callbacks),
+                        signal: run.controller.signal,
+                    })
+                    : await requestModels.classify(body.model, body.context, {
+                        ...body.options,
+                        ...createProviderCallbacks(run, res, body.callbacks),
+                        signal: run.controller.signal,
+                    });
+            run.operationResult = run.cancelRequested
+                ? { ...result, stopReason: "aborted", errorMessage: "Model operation aborted" }
+                : result;
+            run.status =
+                run.cancelRequested || result.stopReason === "aborted"
+                    ? "aborted"
+                    : result.stopReason === "error"
+                        ? "failed"
+                        : "completed";
+            run.errorMessage = "errorMessage" in result ? result.errorMessage : undefined;
+            run.updatedAt = Date.now();
+        }
+        if (!res.destroyed && !res.writableEnded)
+            writeServerSentEvent(res, "result", run.operationResult);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        failStreamRun(run, message);
+        if (!res.destroyed && !res.writableEnded)
+            writeServerSentEvent(res, "error", { error: message });
+    }
+    finally {
+        clearInterval(heartbeat);
+        settleRun(run);
+        endStreamResponse(res);
+    }
+}
+function resolveOperationModels(models, model, options) {
+    const provider = models.getProvider(model.provider);
+    const hasDeclaredApi = provider
+        ?.getAllModels?.()
+        .some((candidate) => candidate.type === model.type && candidate.api === model.api);
+    if (hasDeclaredApi &&
+        ((model.type === "image" && provider?.generateImages) || (model.type === "classifier" && provider?.classify)))
+        return models;
+    const requestModels = createModels();
+    const apiKey = options?.apiKey ?? getEnvApiKey(model.provider, options?.env);
+    const auth = provider?.auth ?? {
+        apiKey: {
+            name: "pi-server request auth",
+            resolve: async () => ({ auth: { apiKey, headers: options?.headers } }),
+        },
+    };
+    if (model.type === "image") {
+        const api = getImagesApiProvider(model.api);
+        if (!api)
+            throw new Error(`No image API registered on pi-server: ${model.api}`);
+        requestModels.setProvider(createProvider({ id: model.provider, models: [model], auth, images: { [model.api]: api } }));
+    }
+    else if (model.type === "classifier") {
+        const api = CLASSIFIER_APIS[model.api];
+        if (!api)
+            throw new Error(`No classifier API registered on pi-server: ${model.api}`);
+        requestModels.setProvider(createProvider({ id: model.provider, models: [model], auth, classifiers: { [model.api]: api } }));
+    }
+    else {
+        throw new Error("Image generation and classification require an operation-specific model type");
+    }
+    return requestModels;
+}
+export function createPiServer(configOverride, streamModels) {
     const config = loadConfig(configOverride);
+    const models = streamModels ?? builtinModels();
     loadPersistedSessions(config.sessionStoreDir);
     const server = createServer(async (req, res) => {
         const url = new URL(req.url ?? "/", "http://localhost");
@@ -945,6 +1264,24 @@ export function createPiServer(configOverride) {
             sendJson(res, 200, { sessions: listSessions() });
             return;
         }
+        if (req.method === "GET" && url.pathname === "/api/models") {
+            try {
+                const stripHeaders = (model) => ({ ...model, headers: undefined });
+                sendJson(res, 200, {
+                    models: models.getAllModels().map(stripHeaders),
+                    available: (await models.getAllAvailable()).map(stripHeaders),
+                    providers: models.getProviders().map((provider) => ({
+                        id: provider.id,
+                        fetchDeferred: provider.fetchDeferred !== undefined,
+                        cancelDeferred: provider.cancelDeferred !== undefined,
+                    })),
+                });
+            }
+            catch (error) {
+                sendError(res, 500, error instanceof Error ? error.message : String(error), PiServerErrorCode.INTERNAL_ERROR);
+            }
+            return;
+        }
         const runMatch = /^\/api\/session\/([^/]+)\/runs\/([^/]+)$/.exec(url.pathname);
         if (req.method === "GET" && runMatch) {
             handleSessionRun(decodeURIComponent(runMatch[1]), decodeURIComponent(runMatch[2]), res);
@@ -987,7 +1324,7 @@ export function createPiServer(configOverride) {
                     sendJson(res, 200, chunkResult.ack);
                     return;
                 }
-                const handled = await handlePostRequest(config, chunkResult.target, JSON.parse(chunkResult.bodyJson), res);
+                const handled = await handlePostRequest(config, chunkResult.target, JSON.parse(chunkResult.bodyJson), res, models, streamModels);
                 if (!handled && !res.headersSent) {
                     sendError(res, 404, "Not found", PiServerErrorCode.INVALID_REQUEST);
                 }
@@ -1007,7 +1344,7 @@ export function createPiServer(configOverride) {
         if (req.method === "POST") {
             try {
                 const body = JSON.parse(await readBody(req));
-                if (await handlePostRequest(config, url.pathname, body, res))
+                if (await handlePostRequest(config, url.pathname, body, res, models, streamModels))
                     return;
                 if (!res.headersSent) {
                     sendError(res, 404, "Not found", PiServerErrorCode.INVALID_REQUEST);
@@ -1029,8 +1366,8 @@ 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);
+            await deleteStreamRunsForSession(sessionId);
             sendJson(res, 200, { deleted: sessionId });
             return;
         }
@@ -1094,6 +1431,7 @@ function toProxyEvent(event) {
                 type: "error",
                 reason: event.reason,
                 errorMessage: event.error.errorMessage,
+                message: event.error,
                 usage: event.error.usage,
             };
         default: