modality-kit 0.12.20 → 0.13.1

package/dist/index.js

@@ -16,30 +16,6 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
-// src/util_mcp_tools_converter.ts
-class ModalityFastMCP {
-  tools = new Map;
-  addTool(tool) {
-    this.tools.set(tool.name, tool);
-  }
-  getTools() {
-    return Array.from(this.tools.values());
-  }
-}
-var setupAITools = (aiTools, mcpServer) => {
-  if (mcpServer) {
-    Object.entries(aiTools).forEach(([toolName, aiTool]) => {
-      let name = aiTool.name != null ? aiTool.name : toolName;
-      const { inputSchema, ...restAITool } = aiTool;
-      mcpServer.addTool({
-        ...restAITool,
-        parameters: inputSchema,
-        name
-      });
-    });
-  }
-  return aiTools;
-};
 // src/util_logger.ts
 var levels = [null, "debug", "info", "warn", "error", "success"];
 
@@ -232,10 +208,11 @@ function withErrorHandling(fn, operation) {
 // src/util_response.ts
 function formatSuccessResponse(content, meta) {
   const { instructions, ...restContent } = content;
+  const otherContent = JSON.parse(JSON.stringify(restContent || {}));
   return JSON.stringify({
     success: true,
     instructions,
-    content: Object.keys(restContent || {}).length ? restContent : undefined,
+    content: Object.keys(otherContent || {}).length ? otherContent : undefined,
     meta
   });
 }
@@ -5951,7 +5928,6 @@ class LruCache {
 }
 export {
   withErrorHandling,
-  setupAITools,
   loadVersion,
   isTestEnvironment,
   getLoggerInstance,
@@ -5962,7 +5938,6 @@ export {
   compressWithLanguageDetection as compressText,
   WebSocketClient,
   exports_schemas_symbol as SymbolTypes,
-  ModalityFastMCP,
   LruCache,
   JSONRPCUtils,
   JSONRPCManager,

package/dist/types/index.d.ts

@@ -1,5 +1,3 @@
-export { setupAITools, ModalityFastMCP } from "./util_mcp_tools_converter";
-export type { AITools, AITool, FastMCPTool, } from "./schemas/schemas_tool_config";
 export { formatErrorResponse, formatSuccessResponse } from "./util_response";
 export { getLoggerInstance, type ModalityLogger } from "./util_logger";
 export { withErrorHandling, ErrorCode } from "./util_error";

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.12.20",
+  "version": "0.13.1",
   "name": "modality-kit",
   "repository": {
     "type": "git",

package/dist/types/schemas/schemas_tool_config.d.ts

@@ -1,68 +0,0 @@
-/**
- * Copy of StandardSchemaV1 interface for compatibility
- */
-import { z } from "zod";
-export interface ToolParameters<Input = unknown, Output = Input> {
-    readonly "~standard": ToolParameters.Props<Input, Output>;
-}
-export declare namespace ToolParameters {
-    interface Props<Input = unknown, Output = Input> {
-        readonly version: 1;
-        readonly vendor: string;
-        readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
-        readonly types?: Types<Input, Output> | undefined;
-    }
-    type Result<Output> = SuccessResult<Output> | FailureResult;
-    interface SuccessResult<Output> {
-        readonly value: Output;
-        readonly issues?: undefined;
-    }
-    interface FailureResult {
-        readonly issues: ReadonlyArray<Issue>;
-    }
-    interface Issue {
-        readonly message: string;
-        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
-    }
-    interface PathSegment {
-        readonly key: PropertyKey;
-    }
-    interface Types<Input = unknown, Output = Input> {
-        readonly input: Input;
-        readonly output: Output;
-    }
-    type InferInput<Schema extends ToolParameters> = NonNullable<Schema["~standard"]["types"]>["input"];
-    type InferOutput<Schema extends ToolParameters> = NonNullable<Schema["~standard"]["types"]>["output"];
-}
-/**
- * Tool interface for AI SDK compatibility
- */
-export interface AITool<T extends Record<string, unknown> | undefined = any, TParams extends ToolParameters = z.ZodSchema> {
-    annotations?: {
-        streamingHint?: boolean;
-    } & {
-        destructiveHint?: boolean;
-        idempotentHint?: boolean;
-        openWorldHint?: boolean;
-        readOnlyHint?: boolean;
-        title?: string;
-    };
-    canAccess?: (auth: T) => boolean;
-    description?: string;
-    execute: (args: ToolParameters.InferOutput<TParams>, context?: any) => Promise<any>;
-    name?: string;
-    inputSchema?: TParams;
-    timeoutMs?: number;
-}
-export interface FastMCPTool<T extends Record<string, unknown> | undefined = any, TParams extends ToolParameters = ToolParameters> extends AITool<T, TParams> {
-    parameters?: TParams;
-    name: string;
-}
-/**
- * Type for a collection of AI tools with preserved schema types
- * @template T - Record mapping tool names to their inputSchema types
- * @example AITools<{getUserById: z.object({id: z.string()}), createUser: z.object({name: z.string()})}>
- */
-export type AITools<T extends Record<string, ToolParameters> = Record<string, z.ZodSchema>> = {
-    [K in keyof T]: AITool<any, T[K]>;
-};

package/dist/types/util_mcp_tools_converter.d.ts

@@ -1,28 +0,0 @@
-import type { AITools, FastMCPTool, ToolParameters } from "./schemas/schemas_tool_config";
-/**
- * FastMCP-compatible interface for MCP server functionality
- * Provides exact API compatibility with FastMCP.addTool method
- */
-export interface FastMCPCompatible {
-    addTool<Params extends ToolParameters>(tool: FastMCPTool<any, Params>): void;
-}
-/**
- * ModalityFastMCP - A FastMCP-compatible implementation
- * Provides addTool and getTools functionality for managing MCP tools
- */
-export declare class ModalityFastMCP implements FastMCPCompatible {
-    private tools;
-    /**
-     * Add a tool to the server
-     */
-    addTool<Params extends ToolParameters>(tool: FastMCPTool<any, Params>): void;
-    /**
-     * Get all registered tools
-     */
-    getTools(): FastMCPTool<any, any>[];
-}
-/**
- * Setup function that optionally registers AITools with MCP server
- * Automatically infers and preserves schema types from the input
- */
-export declare const setupAITools: <T extends Record<string, ToolParameters>>(aiTools: AITools<T>, mcpServer?: FastMCPCompatible) => AITools<T>;