@qvac/sdk 0.13.5 → 0.14.1

package/dist/server/bare/registry/registry-client.js

@@ -11,7 +11,7 @@ const logger = getServerLogger();
 // fd-lock issue a blocking flock(LOCK_EX) on a libuv worker thread. The
 // blocking variant cannot be cancelled from JS, so if another SDK process
 // holds the lock indefinitely it leaves a pending native handle that
-// prevents process.exit() from terminating the worker — see QVAC-18197.
+// prevents Bare.exit() from terminating the worker — see QVAC-18197.
 //
 // With tryLock + bounded retries we get the same "tolerate transient locks
 // during another SDK's startup/shutdown" property #1480 wanted, but every

package/dist/server/bare/runtime-lifecycle.d.ts

@@ -12,6 +12,15 @@ interface ResourceMeta {
     label: string;
     createdAt: number;
 }
+type ResumeListener = () => void;
+/**
+ * Register a callback fired after the runtime returns to "active". Lets in-flight
+ * work (e.g. an HTTP download whose socket died while backgrounded) recover the
+ * instant `resume()` runs instead of waiting for a timeout. Returns an
+ * unregister function — callers MUST call it when their work finishes so the
+ * listener doesn't leak into the next operation.
+ */
+export declare function onResume(listener: ResumeListener): () => void;
 export declare function registerSwarm(swarm: SuspendableSwarm, meta: ResourceMeta): void;
 export declare function unregisterSwarm(swarm: SuspendableSwarm): void;
 export declare function registerCorestore(store: SuspendableStore, meta: ResourceMeta): void;

package/dist/server/bare/runtime-lifecycle.js

@@ -8,8 +8,30 @@ const LIFECYCLE_ALLOWED_TYPES = new Set([
 ]);
 const swarms = new Map();
 const stores = new Map();
+const resumeListeners = new Set();
 let state = "active";
 let transitionPromise = null;
+/**
+ * Register a callback fired after the runtime returns to "active". Lets in-flight
+ * work (e.g. an HTTP download whose socket died while backgrounded) recover the
+ * instant `resume()` runs instead of waiting for a timeout. Returns an
+ * unregister function — callers MUST call it when their work finishes so the
+ * listener doesn't leak into the next operation.
+ */
+export function onResume(listener) {
+    resumeListeners.add(listener);
+    return () => resumeListeners.delete(listener);
+}
+function notifyResume() {
+    for (const listener of Array.from(resumeListeners)) {
+        try {
+            listener();
+        }
+        catch (error) {
+            logger.error("Lifecycle: onResume listener threw:", error);
+        }
+    }
+}
 export function registerSwarm(swarm, meta) {
     swarms.set(swarm, meta);
     logger.debug(`Lifecycle: registered swarm [${meta.label}]`);
@@ -46,6 +68,7 @@ export function getRegisteredResourceCounts() {
 export function resetLifecycleState() {
     swarms.clear();
     stores.clear();
+    resumeListeners.clear();
     state = "active";
     transitionPromise = null;
 }
@@ -130,6 +153,7 @@ export async function resumeRuntime() {
         .then(() => {
         state = "active";
         logger.info("▶️ Runtime resumed");
+        notifyResume();
     })
         .catch((error) => {
         state = "suspended";

package/dist/server/bare/types/addon-responses.d.ts

@@ -56,6 +56,7 @@ export interface TranscribeStats {
     melSpecMs?: number;
     backendDevice?: number;
     backendId?: number;
+    gpuUnsupported?: number;
     gpuMemTotalMb?: number;
     gpuMemFreeMb?: number;
 }

package/dist/server/env.js

@@ -1,4 +1,4 @@
-import process from "bare-process";
+import env from "bare-env";
 import { isBareKit } from "which-runtime";
 import { z } from "zod";
 const envSchema = z.object({
@@ -13,21 +13,18 @@ let validatedEnv = null;
 export function initEnv() {
     const defaultHomeDir = 
     // Snap's HOME can be revision-scoped; SNAP_USER_COMMON is stable.
-    process.env["SNAP_USER_COMMON"] ??
-        process.env["HOME"] ??
-        process.env["USERPROFILE"] ??
-        "/tmp";
+    env["SNAP_USER_COMMON"] ?? env["HOME"] ?? env["USERPROFILE"] ?? "/tmp";
     let envConfig = {
         HOME_DIR: defaultHomeDir,
     };
     let hasRPCConfig = false;
-    if (isBareKit && process.argv[0]) {
-        envConfig["HOME_DIR"] = process.argv[0];
+    if (isBareKit && Bare.argv[0]) {
+        envConfig["HOME_DIR"] = Bare.argv[0];
     }
     // Try to parse any argument as JSON config (fail gracefully)
-    if (process.argv[2]) {
+    if (Bare.argv[2]) {
         try {
-            const rpcArgs = JSON.parse(process.argv[2]);
+            const rpcArgs = JSON.parse(Bare.argv[2]);
             envConfig = { ...envConfig, ...rpcArgs };
             hasRPCConfig = true;
         }
@@ -47,7 +44,7 @@ export function getEnv() {
         initEnv();
     }
     return {
-        ...process.env,
+        ...env,
         ...validatedEnv,
     };
 }

package/dist/server/plugins/registry.js

@@ -2,6 +2,7 @@ import { pluginDefinitionRuntimeSchema, } from "../../schemas/plugin.js";
 import { isModelTypeAlias } from "../../schemas/index.js";
 import { PluginAlreadyRegisteredError, PluginDefinitionInvalidError, PluginLoggingInvalidError, PluginModelTypeReservedError, } from "../../utils/errors-server.js";
 import { createAddonLoggerCallback } from "../../logging/addon.js";
+import { formatZodError } from "../../utils/zod-error.js";
 const plugins = new Map();
 function getModelTypeForError(plugin) {
     if (!plugin || typeof plugin !== "object")
@@ -17,10 +18,7 @@ function validatePluginDefinition(plugin) {
     const result = pluginDefinitionRuntimeSchema.safeParse(plugin);
     if (result.success)
         return;
-    const details = result.error.issues
-        .map((i) => `${String(i.path.join("."))}: ${i.message}`)
-        .join(", ");
-    throw new PluginDefinitionInvalidError(getModelTypeForError(plugin), details);
+    throw new PluginDefinitionInvalidError(getModelTypeForError(plugin), formatZodError(result.error));
 }
 export function registerPlugin(plugin) {
     validatePluginDefinition(plugin);

package/dist/server/rpc/handlers/load-model/handler.js

@@ -59,6 +59,7 @@ import { generateShortHash, canonicalConfigString, transformConfigForReload, } f
 import { buildDownloadProfilingFields } from "./types.js";
 import { ConfigReloadNotSupportedError, InferenceCancelledError, ModelTypeMismatchError, ModelIsDelegatedError, ModelNotFoundError, ModelLoadFailedError, PluginLoadConfigValidationFailedError, PluginNotFoundError, } from "../../../../utils/errors-server.js";
 import { getServerLogger } from "../../../../logging/index.js";
+import { formatZodError } from "../../../../utils/zod-error.js";
 import { getPlugin } from "../../../plugins/index.js";
 import { getRequestRegistry, withRequestContext, } from "../../../bare/runtime/index.js";
 import { generateServerRequestId } from "../../../bare/runtime/request-id.js";
@@ -96,10 +97,7 @@ export async function handleLoadModel(request, progressCallback) {
             let resolvedModelConfig = (request.modelConfig ?? {});
             const parseResult = plugin.loadConfigSchema.safeParse(resolvedModelConfig);
             if (!parseResult.success) {
-                const details = parseResult.error.issues
-                    .map((i) => `${String(i.path.join("."))}: ${i.message}`)
-                    .join(", ");
-                throw new PluginLoadConfigValidationFailedError(canonicalModelType, details);
+                throw new PluginLoadConfigValidationFailedError(canonicalModelType, formatZodError(parseResult.error));
             }
             resolvedModelConfig = parseResult.data;
             const totalLoadStart = profilingEnabled ? nowMs() : 0;

package/dist/server/rpc/handlers/load-model/http.js

@@ -2,15 +2,21 @@ import fs, { promises as fsPromises } from "bare-fs";
 import path from "bare-path";
 import { Readable } from "bare-stream";
 import fetch, { Headers } from "bare-fetch";
+import { AbortController } from "bare-abort-controller";
 import { withTimeout } from "../../../../utils/withTimeout.js";
 import { getModelsCacheDir, getShardedModelCacheDir, generateShortHash, detectShardedModel, parsePatternBasedShardUrl, extractTensorsFromShards, calculatePercentage, isArchiveUrl, sanitizePathComponent, extractAndValidateShardedArchive, validateShardedModelCache, checkAllShardsExist, generateShardFilenames, hasValidGGUFHeader, } from "../../../utils/index.js";
 import { getSDKConfig } from "../../../bare/registry/config-registry.js";
+import { getLifecycleState, onResume } from "../../../bare/runtime-lifecycle.js";
 import { createHttpDownloadKey, startOrJoinDownload, applyJoinedDownloadStats, } from "./download-manager.js";
 import { DownloadCancelledError, HTTPError, NoResponseBodyError, PartialDownloadOfflineError, ResponseBodyNotReadableError, } from "../../../../utils/errors-server.js";
 import { getServerLogger } from "../../../../logging/index.js";
 const logger = getServerLogger();
 const DEFAULT_CONCURRENCY = 3;
 const DEFAULT_HTTP_CONNECTION_TIMEOUT_MS = 10_000;
+// If no bytes arrive for this long mid-stream, treat the transfer as stalled
+// (dead socket after a suspend or network drop that didn't surface an error)
+// and abort so the caller can resume from the partial via a Range request.
+const HTTP_STREAM_STALL_TIMEOUT_MS = 10_000;
 function extractFilenameFromUrl(url) {
     // Parse URL to get the filename from the path
     const urlParts = url.split("/");
@@ -180,72 +186,140 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
             (typeof body.pipe === "function" &&
                 typeof body.on === "function");
         if (isReadable) {
-            // Track progress by intercepting data events if possible
-            body.on("data", (chunk) => {
-                downloadedBytes += chunk.length;
-                if (progressCallback) {
-                    progressCallback({
-                        type: "modelProgress",
-                        downloaded: downloadedBytes,
-                        total: totalBytes,
-                        percentage: calculatePercentage(downloadedBytes, totalBytes),
-                        downloadKey,
-                    });
-                }
-            });
-            // Pipe directly to file
-            body.pipe(writeStream);
             // Wait for download to complete
             await new Promise((resolve, reject) => {
-                // Handle abort signal
+                let stallTimer;
+                const clearStall = () => {
+                    if (stallTimer) {
+                        clearTimeout(stallTimer);
+                        stallTimer = undefined;
+                    }
+                };
+                // Reset on every chunk; if it ever fires, the socket went quiet
+                // mid-stream (suspend/drop) — abort so the caller resumes via Range.
+                const armStall = () => {
+                    clearStall();
+                    stallTimer = setTimeout(() => {
+                        body.destroy();
+                        writeStream.destroy();
+                        reject(new Error(`HTTP stream stalled: no data for ${HTTP_STREAM_STALL_TIMEOUT_MS}ms`));
+                    }, HTTP_STREAM_STALL_TIMEOUT_MS);
+                };
                 const abortHandler = () => {
-                    const error = new DownloadCancelledError();
+                    clearStall();
                     body.destroy();
                     writeStream.destroy();
-                    reject(error);
+                    reject(new DownloadCancelledError());
                 };
                 if (signal) {
+                    if (signal.aborted) {
+                        abortHandler();
+                        return;
+                    }
                     signal.addEventListener("abort", abortHandler);
                 }
+                // Track progress + keep the stall watchdog fed
+                body.on("data", (chunk) => {
+                    armStall();
+                    downloadedBytes += chunk.length;
+                    if (progressCallback) {
+                        progressCallback({
+                            type: "modelProgress",
+                            downloaded: downloadedBytes,
+                            total: totalBytes,
+                            percentage: calculatePercentage(downloadedBytes, totalBytes),
+                            downloadKey,
+                        });
+                    }
+                });
+                // Pipe directly to file
+                body.pipe(writeStream);
+                armStall();
                 writeStream.on("finish", () => {
+                    clearStall();
                     logger.info(`✅ Model downloaded successfully to ${modelPath}`);
                     if (signal) {
                         signal.removeEventListener("abort", abortHandler);
                     }
                     resolve(undefined);
                 });
-                writeStream.on("error", reject);
-                body.on("error", reject);
+                writeStream.on("error", (error) => {
+                    clearStall();
+                    reject(error);
+                });
+                body.on("error", (error) => {
+                    clearStall();
+                    reject(error);
+                });
             });
         }
         else if (body[Symbol.asyncIterator]) {
-            // Body is an async iterable (for await...of)
-            for await (const chunk of body) {
-                // Check if abort signal is triggered
-                if (signal && signal.aborted) {
-                    writeStream.destroy();
-                    throw new DownloadCancelledError();
-                }
-                const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-                downloadedBytes += buffer.length;
-                if (progressCallback) {
-                    progressCallback({
-                        type: "modelProgress",
-                        downloaded: downloadedBytes,
-                        total: totalBytes,
-                        percentage: calculatePercentage(downloadedBytes, totalBytes),
-                        downloadKey,
+            // Body is an async iterable. Drive the iterator manually so each pull can
+            // race a stall timeout: a dead socket after suspend/drop produces neither
+            // a chunk nor an error, so the timeout converts it into a retriable
+            // failure and we abandon the iterator (which cancels the stream).
+            const iterator = body[Symbol.asyncIterator]();
+            let stalled = false;
+            try {
+                for (;;) {
+                    let stallTimer;
+                    const nextPromise = iterator.next();
+                    nextPromise.catch(() => { });
+                    let step;
+                    try {
+                        step = await Promise.race([
+                            nextPromise,
+                            new Promise((_, reject) => {
+                                stallTimer = setTimeout(() => {
+                                    stalled = true;
+                                    reject(new Error(`HTTP stream stalled: no data for ${HTTP_STREAM_STALL_TIMEOUT_MS}ms`));
+                                }, HTTP_STREAM_STALL_TIMEOUT_MS);
+                            }),
+                        ]);
+                    }
+                    finally {
+                        if (stallTimer)
+                            clearTimeout(stallTimer);
+                    }
+                    if (step.done)
+                        break;
+                    if (signal?.aborted) {
+                        writeStream.destroy();
+                        throw new DownloadCancelledError();
+                    }
+                    const buffer = Buffer.isBuffer(step.value)
+                        ? step.value
+                        : Buffer.from(step.value);
+                    downloadedBytes += buffer.length;
+                    if (progressCallback) {
+                        progressCallback({
+                            type: "modelProgress",
+                            downloaded: downloadedBytes,
+                            total: totalBytes,
+                            percentage: calculatePercentage(downloadedBytes, totalBytes),
+                            downloadKey,
+                        });
+                    }
+                    // Write chunk to file
+                    await new Promise((resolve, reject) => {
+                        writeStream.write(buffer, (err) => {
+                            if (err)
+                                reject(new Error(err instanceof Error ? err.message : String(err)));
+                            else
+                                resolve();
+                        });
                     });
                 }
-                // Write chunk to file
-                await new Promise((resolve, reject) => {
-                    writeStream.write(buffer, (err) => {
-                        if (err)
-                            reject(new Error(err instanceof Error ? err.message : String(err)));
-                        else
-                            resolve();
-                    });
-                });
+            }
+            finally {
+                if (stalled) {
+                    try {
+                        await iterator.return?.();
+                    }
+                    catch {
+                        /* best effort: free the dead socket */
+                    }
+                }
             }
             // Close the write stream
             await new Promise((resolve, reject) => {
@@ -257,17 +331,45 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
             });
         }
         else {
-            // Fallback: try to use getReader() if it's a ReadableStream
+            // Fallback: getReader() for a WHATWG ReadableStream (bare-fetch body).
             const readableStreamBody = body;
             const reader = readableStreamBody.getReader
                 ? readableStreamBody.getReader()
                 : null;
             if (reader) {
+                let cancelled = false;
                 try {
-                    while (true) {
-                        const { done, value } = await reader.read();
+                    for (;;) {
+                        // Race each read against a stall timeout. A dead socket after a
+                        // suspend/drop yields no data and no error; the timeout converts
+                        // that into a retriable failure so the caller resumes via Range.
+                        let stallTimer;
+                        const readPromise = reader.read();
+                        // Avoid an unhandled rejection if the read loses the race.
+                        readPromise.catch(() => { });
+                        let result;
+                        try {
+                            result = await Promise.race([
+                                readPromise,
+                                new Promise((_, reject) => {
+                                    stallTimer = setTimeout(() => {
+                                        cancelled = true;
+                                        reject(new Error(`HTTP stream stalled: no data for ${HTTP_STREAM_STALL_TIMEOUT_MS}ms`));
+                                    }, HTTP_STREAM_STALL_TIMEOUT_MS);
+                                }),
+                            ]);
+                        }
+                        finally {
+                            if (stallTimer)
+                                clearTimeout(stallTimer);
+                        }
+                        const { done, value } = result;
                         if (done)
                             break;
+                        if (signal?.aborted) {
+                            cancelled = true;
+                            throw new DownloadCancelledError();
+                        }
                         const buffer = Buffer.from(value);
                         downloadedBytes += buffer.length;
                         if (progressCallback) {
@@ -291,6 +393,14 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
                     }
                 }
                 finally {
+                    if (cancelled) {
+                        try {
+                            await reader.cancel();
+                        }
+                        catch {
+                            /* best effort: free the dead socket */
+                        }
+                    }
                     reader.releaseLock();
                 }
                 // Close the write stream
@@ -313,6 +423,98 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
         throw error instanceof Error ? error : new Error(String(error));
     }
 }
+const DEFAULT_HTTP_DOWNLOAD_MAX_RETRIES = 5;
+const HTTP_RETRY_BASE_DELAY_MS = 500;
+const LIFECYCLE_WAIT_POLL_MS = 200;
+const LIFECYCLE_WAIT_MAX_MS = 5 * 60_000;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+ * A mid-stream socket/body error, a connection failure (HTTP status 0, no
+ * response), or our own resume-triggered abort is recoverable by resuming from
+ * the partial. A real HTTP status (4xx/5xx) or a missing/unreadable body is not.
+ *
+ * `DownloadCancelledError` is intentionally NOT excluded here: this is only
+ * reached after the caller's consumer-cancel gate, so a cancellation at this
+ * point is our per-attempt abort (resume interrupt), which must be retried.
+ */
+function isResumableTransferError(error) {
+    if (error instanceof NoResponseBodyError ||
+        error instanceof ResponseBodyNotReadableError ||
+        error instanceof PartialDownloadOfflineError) {
+        return false;
+    }
+    if (error instanceof HTTPError)
+        return error.httpStatus === 0;
+    return error instanceof Error;
+}
+/**
+ * Block until the runtime is active again before retrying. After a suspend the
+ * socket is dead and the process can't service the transfer; resuming the fetch
+ * only makes sense once `resume()` has run. Bounded and abort-aware.
+ */
+async function waitForLifecycleActive(signal) {
+    if (getLifecycleState() === "active")
+        return;
+    const start = Date.now();
+    while (getLifecycleState() !== "active") {
+        if (signal?.aborted)
+            throw new DownloadCancelledError();
+        if (Date.now() - start > LIFECYCLE_WAIT_MAX_MS)
+            return;
+        await sleep(LIFECYCLE_WAIT_POLL_MS);
+    }
+}
+/**
+ * Run `performHttpDownload` with bounded retry. On a recoverable interruption
+ * (mid-stream socket drop, or a dead socket after suspend/network loss) it
+ * waits for the runtime to be active and re-issues the request, which resumes
+ * from the on-disk partial via a Range header. No consumer-side babysitting.
+ *
+ * Each attempt runs on its own AbortController that is aborted either by the
+ * consumer `signal` (a real cancel — terminal) or by `resume()` (a proactive
+ * recovery — the in-flight socket is dead after a background, so abort and
+ * range-resume immediately instead of waiting for the stall watchdog).
+ */
+async function performHttpDownloadWithResume(url, modelPath, downloadKey, progressCallback, signal) {
+    const maxRetries = DEFAULT_HTTP_DOWNLOAD_MAX_RETRIES;
+    let attempt = 0;
+    for (;;) {
+        const attemptController = new AbortController();
+        const forwardCancel = () => attemptController.abort();
+        if (signal) {
+            if (signal.aborted)
+                attemptController.abort();
+            else
+                signal.addEventListener("abort", forwardCancel, { once: true });
+        }
+        // resume() → abort this attempt so it range-resumes now, not after the stall.
+        const offResume = onResume(() => attemptController.abort());
+        try {
+            await performHttpDownload(url, modelPath, downloadKey, progressCallback, attemptController.signal);
+            return;
+        }
+        catch (error) {
+            // A real consumer cancel is terminal; anything else (resume abort, stall,
+            // network error) is recoverable from the partial.
+            if (signal?.aborted) {
+                throw error instanceof DownloadCancelledError
+                    ? error
+                    : new DownloadCancelledError();
+            }
+            attempt++;
+            if (attempt > maxRetries || !isResumableTransferError(error))
+                throw error;
+            logger.warn(`⚠️ HTTP download interrupted (attempt ${attempt}/${maxRetries}), resuming from partial: ${error instanceof Error ? error.message : String(error)}`);
+            await waitForLifecycleActive(signal);
+            await sleep(HTTP_RETRY_BASE_DELAY_MS * attempt);
+        }
+        finally {
+            if (signal)
+                signal.removeEventListener("abort", forwardCancel);
+            offResume();
+        }
+    }
+}
 export async function downloadModelFromHttp(url, progressCallback, hooks) {
     const filename = extractFilenameFromUrl(url);
     if (isArchiveUrl(url)) {
@@ -355,7 +557,7 @@ export async function downloadModelFromHttp(url, progressCallback, hooks) {
             // Download the file
             hooks?.markCacheMiss?.();
             ctx.setCacheHit(false);
-            await performHttpDownload(url, modelPath, downloadKey, ctx.broadcastProgress, ctx.signal);
+            await performHttpDownloadWithResume(url, modelPath, downloadKey, ctx.broadcastProgress, ctx.signal);
             try {
                 const stats = await fsPromises.stat(modelPath);
                 ctx.broadcastProgress({
@@ -576,7 +778,7 @@ async function downloadShardedModelFromArchive(archiveUrl, progressCallback, hoo
             throw error;
         }
         async function downloadAndExtractArchive() {
-            await performHttpDownload(archiveUrl, archivePath, downloadKey, ctx.broadcastProgress, ctx.signal);
+            await performHttpDownloadWithResume(archiveUrl, archivePath, downloadKey, ctx.broadcastProgress, ctx.signal);
             logger.info(`✅ Archive downloaded, extracting to: ${extractDir}`);
             const firstShardPath = await extractAndValidateShardedArchive(archivePath, extractDir, ctx.signal);
             try {
@@ -605,7 +807,7 @@ async function downloadShardsWithConcurrency(shardsToDownload, allShards, concur
             const state = queue.shift();
             const downloadPromise = (async () => {
                 logger.info(`📥 Downloading shard ${state.index + 1}: ${state.shard.filename}`);
-                await performHttpDownload(state.shard.url, state.shardPath, downloadKey, (progress) => {
+                await performHttpDownloadWithResume(state.shard.url, state.shardPath, downloadKey, (progress) => {
                     state.downloadedBytes = progress.downloaded;
                     if (progressCallback) {
                         const overallDownloaded = allShards.reduce((sum, s) => sum + s.downloadedBytes, 0);

package/dist/server/rpc/handlers/logging-stream.js

@@ -3,10 +3,12 @@ export async function* handleLoggingStream(request) {
     const { id } = request;
     const logQueue = [];
     let pendingResolve = null;
-    const streamHandler = (level, namespace, message) => {
+    const streamHandler = (level, namespace, message, sourceId) => {
         const logResponse = {
             type: "loggingStream",
-            id,
+            // For the global SDK_ALL_LOG_ID stream `sourceId` is the real origin of the
+            // log; for a per-id stream it equals the subscription `id`.
+            id: sourceId,
             level: level,
             namespace,
             message,

package/dist/server/rpc/handlers/plugin-invoke.js

@@ -3,6 +3,7 @@ import { getPlugin, getPluginHandler } from "../../plugins/index.js";
 import { profileReplyHandler, profileStreamHandler, } from "../profiling/index.js";
 import { PluginNotFoundError, PluginHandlerNotFoundError, PluginHandlerTypeMismatchError, PluginRequestValidationFailedError, PluginResponseValidationFailedError, ModelIsDelegatedError, ModelNotFoundError, } from "../../../utils/errors-server.js";
 import { getServerLogger } from "../../../logging/index.js";
+import { formatZodError } from "../../../utils/zod-error.js";
 const logger = getServerLogger();
 function resolvePluginHandler(modelId, handlerName) {
     const modelEntry = getModelEntry(modelId);
@@ -34,18 +35,12 @@ export async function handlePluginInvoke(request) {
         }
         const parseResult = handlerDef.requestSchema.safeParse(params);
         if (!parseResult.success) {
-            const details = parseResult.error.issues
-                .map((i) => `${String(i.path.join("."))}: ${i.message}`)
-                .join(", ");
-            throw new PluginRequestValidationFailedError(handlerName, details);
+            throw new PluginRequestValidationFailedError(handlerName, formatZodError(parseResult.error));
         }
         const result = await handlerDef.handler(parseResult.data);
         const responseParseResult = handlerDef.responseSchema.safeParse(result);
         if (!responseParseResult.success) {
-            const details = responseParseResult.error.issues
-                .map((i) => `${String(i.path.join("."))}: ${i.message}`)
-                .join(", ");
-            throw new PluginResponseValidationFailedError(handlerName, details);
+            throw new PluginResponseValidationFailedError(handlerName, formatZodError(responseParseResult.error));
         }
         return {
             type: "pluginInvoke",
@@ -63,19 +58,13 @@ export async function* handlePluginInvokeStream(request) {
         }
         const parseResult = handlerDef.requestSchema.safeParse(params);
         if (!parseResult.success) {
-            const details = parseResult.error.issues
-                .map((i) => `${String(i.path.join("."))}: ${i.message}`)
-                .join(", ");
-            throw new PluginRequestValidationFailedError(handlerName, details);
+            throw new PluginRequestValidationFailedError(handlerName, formatZodError(parseResult.error));
         }
         const generator = handlerDef.handler(parseResult.data);
         for await (const chunk of generator) {
             const responseParseResult = handlerDef.responseSchema.safeParse(chunk);
             if (!responseParseResult.success) {
-                const details = responseParseResult.error.issues
-                    .map((i) => `${String(i.path.join("."))}: ${i.message}`)
-                    .join(", ");
-                throw new PluginResponseValidationFailedError(handlerName, details);
+                throw new PluginResponseValidationFailedError(handlerName, formatZodError(responseParseResult.error));
             }
             yield {
                 type: "pluginInvokeStream",