@qvac/sdk 0.4.1 → 0.6.0

package/dist/server/worker.js

@@ -1,27 +1,47 @@
 import process from "bare-process";
+import { isBareKit } from "which-runtime";
 import { createBareKitRPCServer, createIPCClient, } from "./rpc/create-server.js";
 import { z } from "zod";
 import { destroySwarm } from "./bare/hyperswarm.js";
-import { closeAllRagInstances } from "./bare/rag-hyperdb/rag-manager.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 { clearAllLoggingStreams } from "./bare/registry/logging-stream-registry.js";
-console.log("🐻 Hello from Bare");
-console.log("Arguments to worker:", process.argv);
+import { clearAllLoggingStreams, startLogBuffering, } from "./bare/registry/logging-stream-registry.js";
+import { ADDON_NAMESPACES, createAddonLoggerCallback, clearAllAddonLoggers, getServerLogger, SDK_LOG_ID, } from "../logging/index.js";
+import llmAddonLogging from "@qvac/llm-llamacpp/addonLogging.js";
+import embedAddonLogging from "@qvac/embed-llamacpp/addonLogging.js";
+import ttsAddonLogging from "@qvac/tts-onnx/addonLogging.js";
+import whisperAddonLogging from "@qvac/transcription-whispercpp/addonLogging.js";
+import nmtAddonLogging from "@qvac/translation-nmtcpp/addonLogging.js";
+// Buffer SDK logs from startup so clients can receive them when they subscribe
+startLogBuffering(SDK_LOG_ID);
+const logger = getServerLogger();
+logger.info("🐻 Hello from Bare");
+logger.debug("Arguments to worker:", process.argv);
+// Initialize addon logger callbacks
+llmAddonLogging.setLogger(createAddonLoggerCallback(ADDON_NAMESPACES.LLAMACPP_LLM));
+embedAddonLogging.setLogger(createAddonLoggerCallback(ADDON_NAMESPACES.LLAMACPP_EMBED));
+ttsAddonLogging.setLogger(createAddonLoggerCallback(ADDON_NAMESPACES.TTS));
+whisperAddonLogging.setLogger(createAddonLoggerCallback(ADDON_NAMESPACES.WHISPERCPP));
+nmtAddonLogging.setLogger(createAddonLoggerCallback(ADDON_NAMESPACES.NMTCPP));
 const defaultHomeDir = process.env["HOME"] || process.env["USERPROFILE"] || "/tmp";
 let envConfig = { HOME_DIR: defaultHomeDir };
 let hasRPCConfig = false;
+if (isBareKit && process.argv[0]) {
+    logger.info("Running in BareKit mode");
+    envConfig["HOME_DIR"] = process.argv[0];
+}
 // Try to parse any argument as JSON config (fail gracefully)
 if (process.argv[2]) {
     try {
         const rpcArgs = JSON.parse(process.argv[2]);
         envConfig = { ...envConfig, ...rpcArgs };
         hasRPCConfig = true;
-        console.log("Parsed RPC configuration from arguments");
+        logger.info("Parsed RPC configuration from arguments");
     }
     catch {
         // Not JSON or invalid - use defaults (direct mode)
-        console.log("Using default configuration (direct mode)");
+        logger.info("Using default configuration (direct mode)");
     }
 }
 const validatedEnv = z
@@ -43,22 +63,22 @@ export function ensureRPCSetup() {
     try {
         const ipcSocketPath = validatedEnv.QVAC_IPC_SOCKET_PATH;
         if (ipcSocketPath) {
-            console.log(`Running in desktop mode, connecting to IPC socket: ${ipcSocketPath}`);
+            logger.info(`Running in desktop mode, connecting to IPC socket: ${ipcSocketPath}`);
             // Connect to the IPC server (Named Pipe or Unix Socket)
             const rpc = createIPCClient(ipcSocketPath);
-            console.log("Desktop IPC client created?", !!rpc);
+            logger.debug("Desktop IPC client created?", !!rpc);
         }
         else {
-            console.log("Running in BareKit IPC mode");
+            logger.info("Running in BareKit IPC mode");
             // Start the standard RPC server with BareKit IPC for mobile
             createBareKitRPCServer();
         }
-        console.log("Bare worker started and listening for RPC requests");
-        console.log("Working directory:", process.cwd());
+        logger.info("Bare worker started and listening for RPC requests");
+        logger.debug("Working directory:", process.cwd());
         rpcInitialized = true;
     }
     catch (error) {
-        console.error("Worker error:", error);
+        logger.error("Worker error:", error);
         process.exit(1);
     }
 }
@@ -67,29 +87,39 @@ if (hasRPCConfig) {
     ensureRPCSetup();
 }
 else {
-    console.log("Running in direct mode - RPC setup will be lazy");
+    logger.info("Running in direct mode - RPC setup will be lazy");
+}
+// Centralized logger cleanup
+function clearLoggers() {
+    clearAllLoggingStreams();
+    clearAllAddonLoggers();
+    llmAddonLogging.releaseLogger();
+    embedAddonLogging.releaseLogger();
+    ttsAddonLogging.releaseLogger();
+    whisperAddonLogging.releaseLogger();
+    nmtAddonLogging.releaseLogger();
 }
 // Centralized cleanup for graceful shutdown
 let isShuttingDown = false;
-const shutdownHandler = async () => {
+async function shutdownHandler() {
     if (isShuttingDown)
         return;
     isShuttingDown = true;
-    console.log("🐻 Bare worker shutdown signal received, cleaning up...");
+    logger.info("🐻 Bare worker shutdown signal received, cleaning up...");
     try {
-        clearAllLoggingStreams();
+        clearLoggers();
         await Promise.allSettled([
             destroySwarm(),
             closeAllRagInstances(),
             cleanupDownloads(),
             unloadAllModels(),
         ]);
-        console.log("✅ Cleanup completed successfully");
+        logger.info("✅ Cleanup completed successfully");
     }
     catch (error) {
-        console.error("❌ Error during shutdown cleanup:", error);
+        logger.error("❌ Error during shutdown cleanup:", error);
     }
     process.exit(0);
-};
+}
 process.once("SIGTERM", () => void shutdownHandler());
 process.once("SIGINT", () => void shutdownHandler());

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

@@ -1,3 +1,3 @@
 import type { QvacErrorOptions } from "@qvac/error";
-export declare const createErrorOptions: (code: number, adds?: string | (string | number)[], cause?: unknown) => QvacErrorOptions;
+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

@@ -1,4 +1,4 @@
-export const createErrorOptions = (code, adds, cause) => {
+export function createErrorOptions(code, adds, cause) {
     const options = { code };
     if (adds !== undefined) {
         options.adds = adds;
@@ -10,4 +10,4 @@ export const createErrorOptions = (code, adds, cause) => {
                 : new Error(typeof cause === "string" ? cause : JSON.stringify(cause));
     }
     return options;
-};
+}

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

@@ -20,6 +20,9 @@ export declare class InvalidToolsArrayError extends QvacErrorBase {
 export declare class InvalidToolSchemaError extends QvacErrorBase {
     constructor(details: string, cause?: unknown);
 }
+export declare class OCRFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
 export declare class RPCNoHandlerError extends QvacErrorBase {
     constructor(requestType: string, cause?: unknown);
 }
@@ -56,6 +59,18 @@ export declare class SDKNotFoundInNodeModulesError extends QvacErrorBase {
 export declare class WorkerFileNotFoundError extends QvacErrorBase {
     constructor(workerPath: string, cause?: unknown);
 }
+export declare class ConfigFileNotFoundError extends QvacErrorBase {
+    constructor(searchPaths: string, cause?: unknown);
+}
+export declare class ConfigFileInvalidError extends QvacErrorBase {
+    constructor(filePath: string, reason: string, cause?: unknown);
+}
+export declare class ConfigFileParseFailedError extends QvacErrorBase {
+    constructor(filePath: string, error: string, cause?: unknown);
+}
+export declare class ConfigValidationFailedError extends QvacErrorBase {
+    constructor(errors: string, cause?: unknown);
+}
 export declare class ModelUnloadFailedError extends QvacErrorBase {
     constructor(modelId?: string, cause?: unknown);
 }
@@ -71,6 +86,9 @@ export declare class TranslationFailedError extends QvacErrorBase {
 export declare class CancelFailedError extends QvacErrorBase {
     constructor(details?: string, cause?: unknown);
 }
+export declare class RAGChunkFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
 export declare class RAGSaveFailedError extends QvacErrorBase {
     constructor(details?: string, cause?: unknown);
 }
@@ -80,6 +98,12 @@ export declare class RAGSearchFailedError extends QvacErrorBase {
 export declare class RAGDeleteFailedError extends QvacErrorBase {
     constructor(details?: string, cause?: unknown);
 }
+export declare class RAGCloseWorkspaceFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
+export declare class RAGListWorkspacesFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
 export declare class DownloadAssetFailedError extends QvacErrorBase {
     constructor(details?: string, cause?: unknown);
 }

package/dist/utils/errors-client.js

@@ -37,6 +37,11 @@ export class InvalidToolSchemaError extends QvacErrorBase {
         super(createErrorOptions(SDK_CLIENT_ERROR_CODES.INVALID_TOOL_SCHEMA, [details], cause));
     }
 }
+export class OCRFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.OCR_FAILED, details ? [details] : undefined, cause));
+    }
+}
 // ============== RPC Communication Errors ==============
 export class RPCNoHandlerError extends QvacErrorBase {
     constructor(requestType, cause) {
@@ -100,6 +105,26 @@ export class WorkerFileNotFoundError extends QvacErrorBase {
         super(createErrorOptions(SDK_CLIENT_ERROR_CODES.WORKER_FILE_NOT_FOUND, [workerPath], cause));
     }
 }
+export class ConfigFileNotFoundError extends QvacErrorBase {
+    constructor(searchPaths, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.CONFIG_FILE_NOT_FOUND, [searchPaths], cause));
+    }
+}
+export class ConfigFileInvalidError extends QvacErrorBase {
+    constructor(filePath, reason, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.CONFIG_FILE_INVALID, [filePath, reason], cause));
+    }
+}
+export class ConfigFileParseFailedError extends QvacErrorBase {
+    constructor(filePath, error, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.CONFIG_FILE_PARSE_FAILED, [filePath, error], cause));
+    }
+}
+export class ConfigValidationFailedError extends QvacErrorBase {
+    constructor(errors, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.CONFIG_VALIDATION_FAILED, [errors], cause));
+    }
+}
 // ============== Operation Errors (Client-side wrappers for server operations) ==============
 // These are used by client API to throw errors based on server responses
 // They reference server error codes but are thrown on client side
@@ -129,6 +154,11 @@ export class CancelFailedError extends QvacErrorBase {
         super(createErrorOptions(SDK_SERVER_ERROR_CODES.CANCEL_FAILED, details ? [details] : undefined, cause));
     }
 }
+export class RAGChunkFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.RAG_CHUNK_FAILED, details ? [details] : undefined, cause));
+    }
+}
 export class RAGSaveFailedError extends QvacErrorBase {
     constructor(details, cause) {
         super(createErrorOptions(SDK_SERVER_ERROR_CODES.RAG_SAVE_FAILED, details ? [details] : undefined, cause));
@@ -144,6 +174,16 @@ export class RAGDeleteFailedError extends QvacErrorBase {
         super(createErrorOptions(SDK_SERVER_ERROR_CODES.RAG_DELETE_FAILED, details ? [details] : undefined, cause));
     }
 }
+export class RAGCloseWorkspaceFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.RAG_WORKSPACE_CLOSE_FAILED, details ? [details] : undefined, cause));
+    }
+}
+export class RAGListWorkspacesFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.RAG_LIST_WORKSPACES_FAILED, details ? [details] : undefined, cause));
+    }
+}
 export class DownloadAssetFailedError extends QvacErrorBase {
     constructor(details, cause) {
         super(createErrorOptions(SDK_SERVER_ERROR_CODES.DOWNLOAD_ASSET_FAILED, details ? [details] : undefined, cause));

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

@@ -68,6 +68,21 @@ export declare class CancelFailedError extends QvacErrorBase {
 export declare class TextToSpeechFailedError extends QvacErrorBase {
     constructor(details?: string, cause?: unknown);
 }
+export declare class ConfigReloadNotSupportedError extends QvacErrorBase {
+    constructor(modelId: string, cause?: unknown);
+}
+export declare class ModelTypeMismatchError extends QvacErrorBase {
+    constructor(expectedType: string, providedType: string, cause?: unknown);
+}
+export declare class OCRFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
+export declare class ImageFileNotFoundError extends QvacErrorBase {
+    constructor(filePath: string, cause?: unknown);
+}
+export declare class InvalidImageInputError extends QvacErrorBase {
+    constructor(cause?: unknown);
+}
 export declare class RAGSaveFailedError extends QvacErrorBase {
     constructor(details?: string, cause?: unknown);
 }
@@ -113,6 +128,21 @@ export declare class SeedingNotSupportedError extends QvacErrorBase {
 export declare class HyperdriveDownloadFailedError extends QvacErrorBase {
     constructor(details: string, cause?: unknown);
 }
+export declare class InvalidShardUrlPatternError extends QvacErrorBase {
+    constructor(url: string, cause?: unknown);
+}
+export declare class ArchiveExtractionFailedError extends QvacErrorBase {
+    constructor(archivePath: string, cause?: unknown);
+}
+export declare class ArchiveUnsupportedTypeError extends QvacErrorBase {
+    constructor(archivePath: string, cause?: unknown);
+}
+export declare class ArchiveMissingShardsError extends QvacErrorBase {
+    constructor(missingFile: string, cause?: unknown);
+}
+export declare class PartialDownloadOfflineError extends QvacErrorBase {
+    constructor(url: string, downloadedBytes: number, cause?: unknown);
+}
 export declare class DeleteCacheFailedError extends QvacErrorBase {
     constructor(details?: string, cause?: unknown);
 }
@@ -125,6 +155,9 @@ export declare class CacheDirNotAbsoluteError extends QvacErrorBase {
 export declare class CacheDirNotWritableError extends QvacErrorBase {
     constructor(cacheDir: string, details?: string, cause?: unknown);
 }
+export declare class ConfigAlreadySetError extends QvacErrorBase {
+    constructor(cause?: unknown);
+}
 export declare class FFmpegNotAvailableError extends QvacErrorBase {
     constructor(cause?: unknown);
 }
@@ -137,6 +170,15 @@ export declare class InvalidAudioChunkError extends QvacErrorBase {
 export declare class RAGWorkspaceModelMismatchError extends QvacErrorBase {
     constructor(workspace: string, existingModelId: string, newModelId: string, cause?: unknown);
 }
+export declare class RAGWorkspaceNotFoundError extends QvacErrorBase {
+    constructor(workspace: string, cause?: unknown);
+}
+export declare class RAGWorkspaceInUseError extends QvacErrorBase {
+    constructor(workspace: string, cause?: unknown);
+}
+export declare class RAGWorkspaceNotOpenError extends QvacErrorBase {
+    constructor(workspace: string, cause?: unknown);
+}
 export declare class DelegateNoFinalResponseError extends QvacErrorBase {
     constructor(cause?: unknown);
 }

package/dist/utils/errors-server.js

@@ -120,6 +120,31 @@ export class TextToSpeechFailedError extends QvacErrorBase {
         super(createErrorOptions(SDK_SERVER_ERROR_CODES.TEXT_TO_SPEECH_FAILED, details ? [details] : undefined, cause));
     }
 }
+export class ConfigReloadNotSupportedError extends QvacErrorBase {
+    constructor(modelId, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.CONFIG_RELOAD_NOT_SUPPORTED, [modelId], cause));
+    }
+}
+export class ModelTypeMismatchError extends QvacErrorBase {
+    constructor(expectedType, providedType, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.MODEL_TYPE_MISMATCH, [expectedType, providedType], cause));
+    }
+}
+export class OCRFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.OCR_FAILED, details ? [details] : undefined, cause));
+    }
+}
+export class ImageFileNotFoundError extends QvacErrorBase {
+    constructor(filePath, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.IMAGE_FILE_NOT_FOUND, [filePath], cause));
+    }
+}
+export class InvalidImageInputError extends QvacErrorBase {
+    constructor(cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.INVALID_IMAGE_INPUT, undefined, cause));
+    }
+}
 // ============== RAG Operation Errors ==============
 export class RAGSaveFailedError extends QvacErrorBase {
     constructor(details, cause) {
@@ -197,6 +222,31 @@ export class HyperdriveDownloadFailedError extends QvacErrorBase {
         super(createErrorOptions(SDK_SERVER_ERROR_CODES.HYPERDRIVE_DOWNLOAD_FAILED, [details], cause));
     }
 }
+export class InvalidShardUrlPatternError extends QvacErrorBase {
+    constructor(url, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.INVALID_SHARD_URL_PATTERN, [url], cause));
+    }
+}
+export class ArchiveExtractionFailedError extends QvacErrorBase {
+    constructor(archivePath, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.ARCHIVE_EXTRACTION_FAILED, [archivePath], cause));
+    }
+}
+export class ArchiveUnsupportedTypeError extends QvacErrorBase {
+    constructor(archivePath, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.ARCHIVE_UNSUPPORTED_TYPE, [archivePath], cause));
+    }
+}
+export class ArchiveMissingShardsError extends QvacErrorBase {
+    constructor(missingFile, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.ARCHIVE_MISSING_SHARDS, [missingFile], cause));
+    }
+}
+export class PartialDownloadOfflineError extends QvacErrorBase {
+    constructor(url, downloadedBytes, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.PARTIAL_DOWNLOAD_OFFLINE, [url, String(downloadedBytes)], cause));
+    }
+}
 // ============== Cache Operation Errors ==============
 export class DeleteCacheFailedError extends QvacErrorBase {
     constructor(details, cause) {
@@ -218,6 +268,12 @@ export class CacheDirNotWritableError extends QvacErrorBase {
         super(createErrorOptions(SDK_SERVER_ERROR_CODES.CACHE_DIR_NOT_WRITABLE, details ? [cacheDir, details] : [cacheDir], cause));
     }
 }
+// ============== Config Operations Errors ==============
+export class ConfigAlreadySetError extends QvacErrorBase {
+    constructor(cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.CONFIG_ALREADY_SET, undefined, cause));
+    }
+}
 // ============== System/Runtime Errors ==============
 export class FFmpegNotAvailableError extends QvacErrorBase {
     constructor(cause) {
@@ -240,6 +296,21 @@ export class RAGWorkspaceModelMismatchError extends QvacErrorBase {
         super(createErrorOptions(SDK_SERVER_ERROR_CODES.RAG_WORKSPACE_MODEL_MISMATCH, [workspace, existingModelId, newModelId], cause));
     }
 }
+export class RAGWorkspaceNotFoundError extends QvacErrorBase {
+    constructor(workspace, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.RAG_WORKSPACE_NOT_FOUND, [workspace], cause));
+    }
+}
+export class RAGWorkspaceInUseError extends QvacErrorBase {
+    constructor(workspace, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.RAG_WORKSPACE_IN_USE, [workspace], cause));
+    }
+}
+export class RAGWorkspaceNotOpenError extends QvacErrorBase {
+    constructor(workspace, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.RAG_WORKSPACE_NOT_OPEN, [workspace], cause));
+    }
+}
 // ============== RPC/Delegation Errors (Server-side) ==============
 export class DelegateNoFinalResponseError extends QvacErrorBase {
     constructor(cause) {

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

@@ -0,0 +1,12 @@
+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[];
+    handlers: ToolHandlerMap;
+};
+export declare function getMcpToolsWithHandlers(clients: McpClientInput[]): Promise<McpToolsResult>;
+export declare function getMcpTools(clients: McpClientInput[]): Promise<Tool[]>;
+//# sourceMappingURL=mcp-adapter.d.ts.map

package/dist/utils/mcp-adapter.js

@@ -0,0 +1,103 @@
+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);
+}
+function convertMcpToolToTool(mcpTool) {
+    const inputSchema = mcpTool.inputSchema;
+    const properties = inputSchema.properties ?? {};
+    const required = inputSchema.required ?? [];
+    const convertedProperties = mapValues(properties, (prop) => {
+        const { type, description, enum: enumVal } = prop;
+        return {
+            type: isValidType(type) ? type : "string",
+            ...(description && { description }),
+            ...(enumVal && { enum: enumVal }),
+        };
+    });
+    return {
+        type: "function",
+        name: mcpTool.name,
+        description: mcpTool.description ?? "",
+        parameters: {
+            type: "object",
+            properties: convertedProperties,
+            required: required.length > 0 ? required : undefined,
+        },
+    };
+}
+function createMcpToolHandler(client, toolName) {
+    return async (args) => {
+        return client.callTool({ name: toolName, arguments: args });
+    };
+}
+export async function getMcpToolsWithHandlers(clients) {
+    const allTools = [];
+    const handlers = new Map();
+    for (const { client, includeResources } of clients) {
+        const { tools: mcpTools } = await client.listTools();
+        for (const mcpTool of mcpTools) {
+            allTools.push(convertMcpToolToTool(mcpTool));
+            handlers.set(mcpTool.name, createMcpToolHandler(client, mcpTool.name));
+        }
+        if (includeResources !== false && client.listResources) {
+            allTools.push({
+                type: "function",
+                name: "list_resources",
+                description: "List available resources from MCP server",
+                parameters: {
+                    type: "object",
+                    properties: {},
+                },
+            });
+            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),
+                };
+            });
+            if (client.readResource) {
+                allTools.push({
+                    type: "function",
+                    name: "read_resource",
+                    description: "Read content of a specific resource by URI",
+                    parameters: {
+                        type: "object",
+                        properties: {
+                            uri: {
+                                type: "string",
+                                description: "The URI of the resource to read",
+                            },
+                        },
+                        required: ["uri"],
+                    },
+                });
+                handlers.set("read_resource", async (args) => {
+                    if (!client.readResource) {
+                        return { error: "readResource not available" };
+                    }
+                    const result = await client.readResource({
+                        uri: args["uri"],
+                    });
+                    return result.contents[0];
+                });
+            }
+        }
+    }
+    return { tools: allTools, handlers };
+}
+export async function getMcpTools(clients) {
+    const { tools } = await getMcpToolsWithHandlers(clients);
+    return tools;
+}

package/dist/utils/object.d.ts

@@ -0,0 +1,2 @@
+export declare function mapValues<T, U>(obj: Record<string, T>, fn: (value: T, key: string) => U): Record<string, U>;
+//# sourceMappingURL=object.d.ts.map

package/dist/utils/object.js

@@ -0,0 +1,3 @@
+export function mapValues(obj, fn) {
+    return Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, fn(value, key)]));
+}

package/dist/utils/tool-helpers.d.ts

@@ -1,10 +1,12 @@
 import type { z } from "zod";
-import { type Tool } from "../schemas/tools";
+import { type Tool, type ToolCall, type ToolCallWithCall } from "../schemas/tools";
 type ZodObjectType = z.ZodObject<z.ZodRawShape>;
+export type ToolHandler = (args: Record<string, unknown>) => Promise<unknown>;
 export type ToolInput<T extends ZodObjectType = ZodObjectType> = {
     name: string;
     description: string;
     parameters: T;
+    handler?: ToolHandler;
 };
 export declare function convertToolInput(input: ToolInput): Tool;
 export declare function convertTools(inputs: ToolInput[]): Tool[];
@@ -12,6 +14,12 @@ export declare function convertTools(inputs: ToolInput[]): Tool[];
  * Validates and converts tools from either ToolInput (with Zod schemas) or full Tool format.
  * Returns validated Tool[] array.
  */
-export declare function validateTools(tools: Tool[] | ToolInput[]): Tool[];
+export type ToolHandlerMap = Map<string, ToolHandler>;
+export type ValidateToolsResult = {
+    tools: Tool[];
+    handlers: ToolHandlerMap;
+};
+export declare function validateTools(tools: Tool[] | ToolInput[]): ValidateToolsResult;
+export declare function attachHandlersToToolCalls(toolCalls: ToolCall[], handlers: ToolHandlerMap): ToolCallWithCall[];
 export {};
 //# sourceMappingURL=tool-helpers.d.ts.map

package/dist/utils/tool-helpers.js

@@ -1,4 +1,4 @@
-import { toolSchema } from "../schemas/tools.js";
+import { toolSchema, } from "../schemas/tools.js";
 import { InvalidToolsArrayError, InvalidToolSchemaError, } from "./errors-client.js";
 function zodTypeToJsonSchemaType(type) {
     switch (type) {
@@ -66,22 +66,17 @@ export function convertToolInput(input) {
 export function convertTools(inputs) {
     return inputs.map(convertToolInput);
 }
-/**
- * Validates and converts tools from either ToolInput (with Zod schemas) or full Tool format.
- * Returns validated Tool[] array.
- */
 export function validateTools(tools) {
     if (tools.length === 0) {
-        return [];
+        return { tools: [], handlers: new Map() };
     }
     const firstTool = tools[0];
     if (!firstTool) {
         throw new InvalidToolsArrayError();
     }
-    // Try to validate as full Tool format first
+    const handlers = new Map();
     const parseResult = toolSchema.safeParse(firstTool);
     if (parseResult.success) {
-        // It's already in full Tool format - validate all tools
         const validatedTools = [];
         for (const tool of tools) {
             const result = toolSchema.safeParse(tool);
@@ -90,10 +85,28 @@ export function validateTools(tools) {
             }
             validatedTools.push(result.data);
         }
-        return validatedTools;
+        return { tools: validatedTools, handlers };
     }
     else {
-        // It's ToolInput format with Zod schemas - convert them
-        return convertTools(tools);
+        const toolInputs = tools;
+        const convertedTools = convertTools(toolInputs);
+        for (const toolInput of toolInputs) {
+            if (toolInput.handler) {
+                handlers.set(toolInput.name, toolInput.handler);
+            }
+        }
+        return { tools: convertedTools, handlers };
     }
 }
+export function attachHandlersToToolCalls(toolCalls, handlers) {
+    return toolCalls.map((toolCall) => {
+        const handler = handlers.get(toolCall.name);
+        if (handler) {
+            return {
+                ...toolCall,
+                invoke: async () => await handler(toolCall.arguments),
+            };
+        }
+        return toolCall;
+    });
+}