@qvac/sdk 0.14.1 → 0.16.0

package/dist/server/worker-core.js

@@ -1,16 +1,16 @@
-import os from "bare-os";
-import Signal from "bare-signals";
-import { createBareKitRPCServer, createIPCClient, } from "./rpc/create-server.js";
-import { destroySwarm } from "./bare/hyperswarm.js";
-import { initEnv, getValidatedEnv } from "./env.js";
-import { closeAllRagInstances } from "./bare/rag-hyperdb/index.js";
-import { cleanupDownloads } from "./rpc/handlers/load-model/download-manager.js";
-import { unloadAllModels } from "./bare/registry/model-registry.js";
-import { closeRegistryClient } from "./bare/registry/registry-client.js";
-import { clearAllLoggingStreams, startLogBuffering, stopLogBufferingWithTimeout, } from "./bare/registry/logging-stream-registry.js";
-import { clearAllAddonLoggers, getServerLogger, SDK_LOG_ID, SDK_ALL_LOG_ID, } from "../logging/index.js";
-import { clearPlugins } from "./plugins/index.js";
-import { acquireWorkerLock, releaseWorkerLock, } from "./utils/worker-lock.js";
+import os from 'bare-os';
+import Signal from 'bare-signals';
+import { createBareKitRPCServer, createIPCClient } from './rpc/create-server.js';
+import { destroySwarm } from './bare/hyperswarm.js';
+import { initEnv, getValidatedEnv } from './env.js';
+import { closeAllRagInstances } from './bare/rag-hyperdb/index.js';
+import { cleanupDownloads } from './rpc/handlers/load-model/download-manager.js';
+import { unloadAllModels } from './bare/registry/model-registry.js';
+import { closeRegistryClient } from './bare/registry/registry-client.js';
+import { clearAllLoggingStreams, startLogBuffering, stopLogBufferingWithTimeout } from './bare/registry/logging-stream-registry.js';
+import { clearAllAddonLoggers, getServerLogger, SDK_LOG_ID, SDK_ALL_LOG_ID } from '../logging/index.js';
+import { clearPlugins } from './plugins/index.js';
+import { acquireWorkerLock, releaseWorkerLock } from './utils/worker-lock.js';
 let coreInitialized = false;
 let rpcInitialized = false;
 // Set true when the cleanup body has run at least once. Lets both
@@ -35,7 +35,7 @@ function scheduleForceExit() {
         logger.error(`Bare.exit did not terminate the worker within ${FORCE_EXIT_GRACE_MS}ms — ` +
             `force-killing self (likely blocked native handle)`);
         try {
-            os.kill(os.pid(), "SIGKILL");
+            os.kill(os.pid(), 'SIGKILL');
         }
         catch {
             // best-effort — if SIGKILL itself fails, there's nothing more to do
@@ -43,7 +43,8 @@ function scheduleForceExit() {
     }, FORCE_EXIT_GRACE_MS);
     // Don't let the safety-net timer keep the process alive on the happy
     // path. Bare returns an object (not a number) from setTimeout.
-    if (timer && typeof timer === "object" && "unref" in timer) {
+    if (timer && typeof timer === 'object' && 'unref' in timer) {
+        ;
         timer.unref();
     }
 }
@@ -58,8 +59,8 @@ export function initializeWorkerCore() {
     acquireWorkerLock();
     setupShutdownHandlers();
     coreInitialized = true;
-    logger.debug("Worker core initialized");
-    logger.debug("Arguments to worker:", Bare.argv);
+    logger.debug('Worker core initialized');
+    logger.debug('Arguments to worker:', Bare.argv);
     return { hasRPCConfig };
 }
 export function ensureRPCSetup() {
@@ -74,16 +75,16 @@ export function ensureRPCSetup() {
         if (ipcSocketPath) {
             logger.info(`Running in desktop mode, connecting to IPC socket: ${ipcSocketPath}`);
             const rpc = createIPCClient(ipcSocketPath, {
-                onDisconnect: () => void shutdownBareDirectWorker("ipc-disconnect"),
+                onDisconnect: () => void shutdownBareDirectWorker('ipc-disconnect')
             });
-            logger.debug("Desktop IPC client created?", !!rpc);
+            logger.debug('Desktop IPC client created?', !!rpc);
         }
         else {
-            logger.info("Running in BareKit IPC mode");
+            logger.info('Running in BareKit IPC mode');
             createBareKitRPCServer();
         }
-        logger.info("Bare worker started and listening for RPC requests");
-        logger.debug("Working directory:", os.cwd());
+        logger.info('Bare worker started and listening for RPC requests');
+        logger.debug('Working directory:', os.cwd());
         rpcInitialized = true;
         // The worker is now reachable, so a `subscribeServerLogs` client can connect.
         // Bound the global startup buffer the same way model-load buffering is bounded:
@@ -93,7 +94,7 @@ export function ensureRPCSetup() {
         stopLogBufferingWithTimeout(SDK_ALL_LOG_ID);
     }
     catch (error) {
-        logger.error("Worker error:", error);
+        logger.error('Worker error:', error);
         Bare.exit(1);
     }
 }
@@ -127,7 +128,7 @@ async function runCleanup() {
         closeAllRagInstances(),
         cleanupDownloads(),
         unloadAllModels(),
-        closeRegistryClient(),
+        closeRegistryClient()
     ]);
 }
 /**
@@ -151,13 +152,13 @@ export async function cleanupForTerminate() {
     // own, so a follow-up shutdownBareDirectWorker call won't redo the body.
     if (cleanupRan)
         return;
-    logger.info("🧹 Pre-terminate cleanup starting...");
+    logger.info('🧹 Pre-terminate cleanup starting...');
     try {
         await runCleanup();
-        logger.info("✅ Pre-terminate cleanup completed");
+        logger.info('✅ Pre-terminate cleanup completed');
     }
     catch (error) {
-        logger.error("❌ Error during pre-terminate cleanup:", error);
+        logger.error('❌ Error during pre-terminate cleanup:', error);
     }
 }
 export async function shutdownBareDirectWorker(reason) {
@@ -165,37 +166,37 @@ export async function shutdownBareDirectWorker(reason) {
         return;
     isShuttingDown = true;
     const messages = {
-        signal: "🐻 Bare worker shutdown signal received, cleaning up...",
-        "rpc-close": "🧹 Bare direct mode RPC closed, cleaning up...",
-        "uncaught-exception": "💥 Uncaught exception, cleaning up...",
-        "unhandled-rejection": "💥 Unhandled rejection, cleaning up...",
-        "ipc-disconnect": "🔌 Parent IPC disconnected, cleaning up...",
+        signal: '🐻 Bare worker shutdown signal received, cleaning up...',
+        'rpc-close': '🧹 Bare direct mode RPC closed, cleaning up...',
+        'uncaught-exception': '💥 Uncaught exception, cleaning up...',
+        'unhandled-rejection': '💥 Unhandled rejection, cleaning up...',
+        'ipc-disconnect': '🔌 Parent IPC disconnected, cleaning up...'
     };
     logger.info(messages[reason]);
     try {
         // Idempotent: if cleanupForTerminate already ran, this is a no-op.
         await runCleanup();
-        logger.info("✅ Cleanup completed successfully");
+        logger.info('✅ Cleanup completed successfully');
     }
     catch (error) {
-        logger.error("❌ Error during shutdown cleanup:", error);
+        logger.error('❌ Error during shutdown cleanup:', error);
     }
     releaseWorkerLock();
     scheduleForceExit();
-    const isGraceful = reason === "signal" || reason === "rpc-close";
+    const isGraceful = reason === 'signal' || reason === 'rpc-close';
     Bare.exit(isGraceful ? 0 : 1);
 }
 function setupShutdownHandlers() {
     const signals = new Signal.Emitter();
     signals.unref();
-    signals.once("SIGTERM", () => void shutdownBareDirectWorker("signal"));
-    signals.once("SIGINT", () => void shutdownBareDirectWorker("signal"));
-    Bare.on("uncaughtException", (err) => {
-        logger.error("Uncaught exception in worker:", err);
-        void shutdownBareDirectWorker("uncaught-exception");
+    signals.once('SIGTERM', () => void shutdownBareDirectWorker('signal'));
+    signals.once('SIGINT', () => void shutdownBareDirectWorker('signal'));
+    Bare.on('uncaughtException', (err) => {
+        logger.error('Uncaught exception in worker:', err);
+        void shutdownBareDirectWorker('uncaught-exception');
     });
-    Bare.on("unhandledRejection", (reason) => {
-        logger.error("Unhandled rejection in worker:", reason);
-        void shutdownBareDirectWorker("unhandled-rejection");
+    Bare.on('unhandledRejection', (reason) => {
+        logger.error('Unhandled rejection in worker:', reason);
+        void shutdownBareDirectWorker('unhandled-rejection');
     });
 }

package/dist/server/worker.js

@@ -1,13 +1,13 @@
 /**
  * Default worker entry point that registers ALL built-in plugins.
  */
-import { initializeWorkerCore, ensureRPCSetup } from "./worker-core.js";
-import { registerPlugins } from "./plugins/index.js";
-import { getServerLogger } from "../logging/index.js";
-import { llmPlugin, embeddingsPlugin, whisperPlugin, bciPlugin, parakeetPlugin, nmtPlugin, ttsPlugin, ocrPlugin, diffusionPlugin, vlaPlugin, classificationPlugin, } from "./bare/plugins/index.js";
+import { initializeWorkerCore, ensureRPCSetup } from './worker-core.js';
+import { registerPlugins } from './plugins/index.js';
+import { getServerLogger } from '../logging/index.js';
+import { llmPlugin, embeddingsPlugin, whisperPlugin, bciPlugin, parakeetPlugin, nmtPlugin, ttsPlugin, ocrPlugin, diffusionPlugin, vlaPlugin, classificationPlugin } from './bare/plugins/index.js';
 const { hasRPCConfig } = initializeWorkerCore();
 const logger = getServerLogger();
-logger.info("🐻 Hello from Bare");
+logger.info('🐻 Hello from Bare');
 registerPlugins([
     llmPlugin,
     embeddingsPlugin,
@@ -19,15 +19,15 @@ registerPlugins([
     ocrPlugin,
     diffusionPlugin,
     vlaPlugin,
-    classificationPlugin,
+    classificationPlugin
 ]);
 logger.info(hasRPCConfig
-    ? "Parsed RPC configuration from arguments"
-    : "Using default configuration (direct mode)");
+    ? 'Parsed RPC configuration from arguments'
+    : 'Using default configuration (direct mode)');
 // Auto-setup RPC only if we successfully parsed RPC configuration
 if (hasRPCConfig) {
     ensureRPCSetup();
 }
 else {
-    logger.info("Running in direct mode - RPC setup will be lazy");
+    logger.info('Running in direct mode - RPC setup will be lazy');
 }

package/dist/utils/aggregate-events.d.ts

@@ -1,5 +1,5 @@
-import type { CompletionError, CompletionEvent, CompletionFinal, CompletionStats, StopReason, ToolCall } from "../schemas/index";
-import { type ToolHandlerMap } from "./tool-helpers";
+import type { CompletionError, CompletionEvent, CompletionFinal, CompletionStats, StopReason, ToolCall } from '../schemas/index';
+import { type ToolHandlerMap } from './tool-helpers';
 export type AggregatedEvents = {
     contentText: string;
     thinkingText: string;

package/dist/utils/aggregate-events.js

@@ -1,8 +1,8 @@
-import { normalizeAssistantCacheContent } from "./cache-normalize.js";
-import { attachHandlersToToolCalls, } from "./tool-helpers.js";
+import { normalizeAssistantCacheContent } from './cache-normalize.js';
+import { attachHandlersToToolCalls } from './tool-helpers.js';
 export function aggregateEvents(events) {
-    let contentText = "";
-    let thinkingText = "";
+    let contentText = '';
+    let thinkingText = '';
     let stats;
     let rawFullText;
     let error;
@@ -10,33 +10,33 @@ export function aggregateEvents(events) {
     let cancelled = false;
     const toolCalls = [];
     for (const event of events) {
-        if (event.type === "contentDelta") {
+        if (event.type === 'contentDelta') {
             contentText += event.text;
         }
-        else if (event.type === "thinkingDelta") {
+        else if (event.type === 'thinkingDelta') {
             thinkingText += event.text;
         }
-        else if (event.type === "completionStats") {
+        else if (event.type === 'completionStats') {
             stats = event.stats;
         }
-        else if (event.type === "toolCall") {
+        else if (event.type === 'toolCall') {
             toolCalls.push(event.call);
         }
-        else if (event.type === "completionDone") {
-            if ("raw" in event && event.raw) {
+        else if (event.type === 'completionDone') {
+            if ('raw' in event && event.raw) {
                 rawFullText = event.raw.fullText;
             }
             // Error wins over cancelled if a wire event ever carries both
             // signals: a mid-stream addon failure makes the partial state
             // unsafe to expose, regardless of why the loop exited.
-            if (event.stopReason === "error" && "error" in event) {
+            if (event.stopReason === 'error' && 'error' in event) {
                 error = event.error;
             }
             else {
                 if (event.stopReason !== undefined) {
                     stopReason = event.stopReason;
                 }
-                if (event.stopReason === "cancelled") {
+                if (event.stopReason === 'cancelled') {
                     cancelled = true;
                 }
             }
@@ -50,16 +50,14 @@ export function aggregateEvents(events) {
         rawFullText,
         error,
         stopReason,
-        cancelled,
+        cancelled
     };
 }
 export function buildFinalFromEvents(events, handlers) {
-    const { contentText, thinkingText, stats, toolCalls, rawFullText, error, stopReason, cancelled, } = aggregateEvents(events);
+    const { contentText, thinkingText, stats, toolCalls, rawFullText, error, stopReason, cancelled } = aggregateEvents(events);
     const attachedToolCalls = attachHandlersToToolCalls(toolCalls, handlers);
     const fullText = rawFullText ?? contentText;
-    const cacheableAssistantContent = attachedToolCalls.length === 0
-        ? normalizeAssistantCacheContent(fullText)
-        : undefined;
+    const cacheableAssistantContent = attachedToolCalls.length === 0 ? normalizeAssistantCacheContent(fullText) : undefined;
     const final = {
         contentText,
         ...(thinkingText && { thinkingText }),
@@ -67,9 +65,9 @@ export function buildFinalFromEvents(events, handlers) {
         ...(stats && { stats }),
         raw: { fullText },
         ...(cacheableAssistantContent !== undefined && {
-            cacheableAssistantContent,
+            cacheableAssistantContent
         }),
-        ...(stopReason !== undefined && { stopReason }),
+        ...(stopReason !== undefined && { stopReason })
     };
     return { final, error, cancelled };
 }

package/dist/utils/cache-normalize.js

@@ -16,8 +16,5 @@ const UNCLOSED_TRAILING_THINK_RE = /<think>[\s\S]*$/i;
  * callers push back either shape and still hit the cache.
  */
 export function normalizeAssistantCacheContent(content) {
-    return content
-        .replace(THINK_BLOCK_RE, "")
-        .replace(UNCLOSED_TRAILING_THINK_RE, "")
-        .trim();
+    return content.replace(THINK_BLOCK_RE, '').replace(UNCLOSED_TRAILING_THINK_RE, '').trim();
 }

package/dist/utils/encoding.js

@@ -20,7 +20,7 @@ export function decodeBase64(base64) {
  * provides a cross-platform alternative to Buffer.from(bytes).toString("base64").
  */
 export function encodeBase64(bytes) {
-    let binary = "";
+    let binary = '';
     for (let i = 0; i < bytes.length; i++)
         binary += String.fromCharCode(bytes[i]);
     return btoa(binary);

package/dist/utils/errors-base.d.ts

@@ -1,3 +1,3 @@
-import type { QvacErrorOptions } from "@qvac/error";
+import type { QvacErrorOptions } from '@qvac/error';
 export declare function createErrorOptions(code: number, adds?: string | (string | number)[], cause?: unknown): QvacErrorOptions;
 //# sourceMappingURL=errors-base.d.ts.map

package/dist/utils/errors-base.js

@@ -7,7 +7,7 @@ export function createErrorOptions(code, adds, cause) {
         options.cause =
             cause instanceof Error
                 ? cause
-                : new Error(typeof cause === "string" ? cause : JSON.stringify(cause));
+                : new Error(typeof cause === 'string' ? cause : JSON.stringify(cause));
     }
     return options;
 }

package/dist/utils/errors-client.d.ts

@@ -1,4 +1,4 @@
-import { QvacErrorBase } from "@qvac/error";
+import { QvacErrorBase } from '@qvac/error';
 export declare class InvalidResponseError extends QvacErrorBase {
     constructor(expected: string, cause?: unknown);
 }

package/dist/utils/errors-client.js

@@ -1,7 +1,7 @@
-import { QvacErrorBase } from "@qvac/error";
-import { SDK_CLIENT_ERROR_CODES } from "../schemas/sdk-errors-client.js";
-import { SDK_SERVER_ERROR_CODES } from "../schemas/sdk-errors-server.js";
-import { createErrorOptions } from "./errors-base.js";
+import { QvacErrorBase } from '@qvac/error';
+import { SDK_CLIENT_ERROR_CODES } from '../schemas/sdk-errors-client.js';
+import { SDK_SERVER_ERROR_CODES } from '../schemas/sdk-errors-server.js';
+import { createErrorOptions } from './errors-base.js';
 // ============== Response Validation Errors ==============
 export class InvalidResponseError extends QvacErrorBase {
     constructor(expected, cause) {
@@ -157,7 +157,7 @@ export class BarePackError extends QvacErrorBase {
 }
 export class InvalidPluginSpecifierError extends QvacErrorBase {
     constructor(specifiers, cause) {
-        const list = specifiers.map((s) => `  - ${s}`).join("\n");
+        const list = specifiers.map((s) => `  - ${s}`).join('\n');
         super(createErrorOptions(SDK_CLIENT_ERROR_CODES.INVALID_PLUGIN_SPECIFIER, [list], cause));
     }
 }

package/dist/utils/errors-server.d.ts

@@ -1,5 +1,5 @@
-import { QvacErrorBase } from "@qvac/error";
-import type { CompletionStats, ToolCallWithCall } from "../schemas/index";
+import { QvacErrorBase } from '@qvac/error';
+import type { CompletionStats, ToolCallWithCall } from '../schemas/index';
 /**
  * Partial completion payload attached to `InferenceCancelledError` when a
  * cancel hits mid-stream. Mirrors the named fields on `CompletionFinal`
@@ -132,7 +132,7 @@ export declare class RequestNotFoundError extends QvacErrorBase {
  * policy refuses the request. Under the default queue policy a same-model
  * request waits FIFO rather than rejecting, so this fires on the bounded-queue
  * cases: an explicit `onOverflow: "reject"`, the per-model queue-depth cap, or
- * a `queueTimeoutMs` elapsing while waiting for a slot. Distinct from
+ * a `queueTimeoutMs` elapsing while waiting. Distinct from
  * `RequestIdConflictError`, which only fires on UUID collisions.
  */
 export declare class RequestRejectedByPolicyError extends QvacErrorBase {

package/dist/utils/errors-server.js

@@ -1,6 +1,6 @@
-import { QvacErrorBase } from "@qvac/error";
-import { SDK_SERVER_ERROR_CODES } from "../schemas/sdk-errors-server.js";
-import { createErrorOptions } from "./errors-base.js";
+import { QvacErrorBase } from '@qvac/error';
+import { SDK_SERVER_ERROR_CODES } from '../schemas/sdk-errors-server.js';
+import { createErrorOptions } from './errors-base.js';
 // ============== Model Registry Errors ==============
 export class ModelAlreadyRegisteredError extends QvacErrorBase {
     constructor(modelId, cause) {
@@ -65,12 +65,12 @@ export class TtsReferenceAudioRequiredError extends QvacErrorBase {
 }
 export class LegacyParakeetModelDeprecatedError extends QvacErrorBase {
     constructor(legacyFields, cause) {
-        super(createErrorOptions(SDK_SERVER_ERROR_CODES.LEGACY_PARAKEET_MODEL_DEPRECATED, [legacyFields.join(", ")], cause));
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.LEGACY_PARAKEET_MODEL_DEPRECATED, [legacyFields.join(', ')], cause));
     }
 }
 export class LegacyTtsModelDeprecatedError extends QvacErrorBase {
     constructor(legacyFields, cause) {
-        super(createErrorOptions(SDK_SERVER_ERROR_CODES.LEGACY_TTS_MODEL_DEPRECATED, [legacyFields.join(", ")], cause));
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.LEGACY_TTS_MODEL_DEPRECATED, [legacyFields.join(', ')], cause));
     }
 }
 // ============== Model Unloading Errors ==============
@@ -134,9 +134,9 @@ export class ContextOverflowError extends QvacErrorBase {
     modelId;
     constructor(promptTokens, ctxSize, modelId, cause) {
         super(createErrorOptions(SDK_SERVER_ERROR_CODES.CONTEXT_OVERFLOW, [
-            promptTokens !== undefined ? String(promptTokens) : "",
-            ctxSize !== undefined ? String(ctxSize) : "",
-            modelId ?? "",
+            promptTokens !== undefined ? String(promptTokens) : '',
+            ctxSize !== undefined ? String(ctxSize) : '',
+            modelId ?? ''
         ], cause));
         if (promptTokens !== undefined)
             this.promptTokens = promptTokens;
@@ -149,7 +149,7 @@ export class ContextOverflowError extends QvacErrorBase {
         return {
             ...(this.promptTokens !== undefined && { promptTokens: this.promptTokens }),
             ...(this.ctxSize !== undefined && { ctxSize: this.ctxSize }),
-            ...(this.modelId !== undefined && { modelId: this.modelId }),
+            ...(this.modelId !== undefined && { modelId: this.modelId })
         };
     }
 }
@@ -195,7 +195,7 @@ export class RequestNotFoundError extends QvacErrorBase {
  * policy refuses the request. Under the default queue policy a same-model
  * request waits FIFO rather than rejecting, so this fires on the bounded-queue
  * cases: an explicit `onOverflow: "reject"`, the per-model queue-depth cap, or
- * a `queueTimeoutMs` elapsing while waiting for a slot. Distinct from
+ * a `queueTimeoutMs` elapsing while waiting. Distinct from
  * `RequestIdConflictError`, which only fires on UUID collisions.
  */
 export class RequestRejectedByPolicyError extends QvacErrorBase {
@@ -215,7 +215,7 @@ export class RequestRejectedByPolicyError extends QvacErrorBase {
             requestId: this.requestId,
             kind: this.kind,
             modelId: this.modelId,
-            reason: this.reason,
+            reason: this.reason
         };
     }
 }
@@ -293,8 +293,8 @@ export class ModelOperationNotSupportedError extends QvacErrorBase {
             modelId,
             modelType,
             operation,
-            supportedOperations.join(", "),
-            suggestedModelTypes.join(", "),
+            supportedOperations.join(', '),
+            suggestedModelTypes.join(', ')
         ], cause));
         this.modelId = modelId;
         this.modelType = modelType;
@@ -505,9 +505,7 @@ export class DelegateConnectionFailedError extends QvacErrorBase {
 }
 export class DelegateProviderError extends QvacErrorBase {
     constructor(details, providerCode, cause) {
-        super(createErrorOptions(SDK_SERVER_ERROR_CODES.DELEGATE_PROVIDER_ERROR, providerCode !== undefined
-            ? [details, String(providerCode)]
-            : [details], cause));
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.DELEGATE_PROVIDER_ERROR, providerCode !== undefined ? [details, String(providerCode)] : [details], cause));
     }
 }
 export class RPCNoDataReceivedError extends QvacErrorBase {
@@ -528,7 +526,7 @@ export class PluginNotFoundError extends QvacErrorBase {
 }
 export class PluginHandlerNotFoundError extends QvacErrorBase {
     constructor(modelType, handler, availableHandlers, cause) {
-        const serializedHandlers = availableHandlers?.join(", ") ?? "";
+        const serializedHandlers = availableHandlers?.join(', ') ?? '';
         super(createErrorOptions(SDK_SERVER_ERROR_CODES.PLUGIN_HANDLER_NOT_FOUND, [modelType, handler, serializedHandlers], cause));
     }
 }
@@ -585,7 +583,10 @@ export class LifecycleResumeFailedError extends QvacErrorBase {
 }
 export class LifecycleOperationBlockedError extends QvacErrorBase {
     constructor(requestType, lifecycleState) {
-        super(createErrorOptions(SDK_SERVER_ERROR_CODES.LIFECYCLE_OPERATION_BLOCKED, [requestType, lifecycleState]));
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.LIFECYCLE_OPERATION_BLOCKED, [
+            requestType,
+            lifecycleState
+        ]));
     }
 }
 // ============== Security Errors ==============

package/dist/utils/load-model-validation.js

@@ -1,6 +1,6 @@
-import { inferModelTypeFromModelSrc } from "../schemas/model-src-utils.js";
-import { normalizeModelType } from "../schemas/model-types.js";
-import { ModelSrcTypeMismatchError } from "./errors-client.js";
+import { inferModelTypeFromModelSrc } from '../schemas/model-src-utils.js';
+import { normalizeModelType } from '../schemas/model-types.js';
+import { ModelSrcTypeMismatchError } from './errors-client.js';
 /**
  * Throws {@link ModelSrcTypeMismatchError} when explicit
  * `modelType` disagrees with the type inferred from `modelSrc`.

package/dist/utils/mcp-adapter.d.ts

@@ -1,7 +1,7 @@
-import type { Tool } from "../schemas/tools";
-import type { McpClientInput } from "../schemas/mcp-adapter";
-import type { ToolHandler } from "./tool-helpers";
-export type { McpClient, McpClientInput } from "../schemas/mcp-adapter";
+import type { Tool } from '../schemas/tools';
+import type { McpClientInput } from '../schemas/mcp-adapter';
+import type { ToolHandler } from './tool-helpers';
+export type { McpClient, McpClientInput } from '../schemas/mcp-adapter';
 export type ToolHandlerMap = Map<string, ToolHandler>;
 export type McpToolsResult = {
     tools: Tool[];

package/dist/utils/mcp-adapter.js

@@ -1,14 +1,7 @@
-import { mapValues } from "./object.js";
-const VALID_TYPES = [
-    "string",
-    "number",
-    "integer",
-    "boolean",
-    "object",
-    "array",
-];
+import { mapValues } from './object.js';
+const VALID_TYPES = ['string', 'number', 'integer', 'boolean', 'object', 'array'];
 function isValidType(value) {
-    return typeof value === "string" && VALID_TYPES.includes(value);
+    return typeof value === 'string' && VALID_TYPES.includes(value);
 }
 function convertMcpToolToTool(mcpTool) {
     const inputSchema = mcpTool.inputSchema;
@@ -17,20 +10,20 @@ function convertMcpToolToTool(mcpTool) {
     const convertedProperties = mapValues(properties, (prop) => {
         const { type, description, enum: enumVal } = prop;
         return {
-            type: isValidType(type) ? type : "string",
+            type: isValidType(type) ? type : 'string',
             ...(description && { description }),
-            ...(enumVal && { enum: enumVal }),
+            ...(enumVal && { enum: enumVal })
         };
     });
     return {
-        type: "function",
+        type: 'function',
         name: mcpTool.name,
-        description: mcpTool.description ?? "",
+        description: mcpTool.description ?? '',
         parameters: {
-            type: "object",
+            type: 'object',
             properties: convertedProperties,
-            required: required.length > 0 ? required : undefined,
-        },
+            required: required.length > 0 ? required : undefined
+        }
     };
 }
 function createMcpToolHandler(client, toolName) {
@@ -49,46 +42,46 @@ export async function getMcpToolsWithHandlers(clients) {
         }
         if (includeResources !== false && client.listResources) {
             allTools.push({
-                type: "function",
-                name: "list_resources",
-                description: "List available resources from MCP server",
+                type: 'function',
+                name: 'list_resources',
+                description: 'List available resources from MCP server',
                 parameters: {
-                    type: "object",
-                    properties: {},
-                },
+                    type: 'object',
+                    properties: {}
+                }
             });
-            handlers.set("list_resources", async () => {
+            handlers.set('list_resources', async () => {
                 if (!client.listResources) {
                     return { resources: [] };
                 }
                 const result = await client.listResources();
                 return {
-                    type: "text",
-                    text: JSON.stringify(result.resources, null, 2),
+                    type: 'text',
+                    text: JSON.stringify(result.resources, null, 2)
                 };
             });
             if (client.readResource) {
                 allTools.push({
-                    type: "function",
-                    name: "read_resource",
-                    description: "Read content of a specific resource by URI",
+                    type: 'function',
+                    name: 'read_resource',
+                    description: 'Read content of a specific resource by URI',
                     parameters: {
-                        type: "object",
+                        type: 'object',
                         properties: {
                             uri: {
-                                type: "string",
-                                description: "The URI of the resource to read",
-                            },
+                                type: 'string',
+                                description: 'The URI of the resource to read'
+                            }
                         },
-                        required: ["uri"],
-                    },
+                        required: ['uri']
+                    }
                 });
-                handlers.set("read_resource", async (args) => {
+                handlers.set('read_resource', async (args) => {
                     if (!client.readResource) {
-                        return { error: "readResource not available" };
+                        return { error: 'readResource not available' };
                     }
                     const result = await client.readResource({
-                        uri: args["uri"],
+                        uri: args['uri']
                     });
                     return result.contents[0];
                 });