modality-kit 0.12.6 → 0.12.8

package/dist/types/index.d.ts

@@ -1,5 +1,5 @@
 export { setupAITools, ModalityFastMCP } from "./util_mcp_tools_converter";
-export type { AITools, AITool } from "./schemas/schemas_tool_config";
+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/dist/types/schemas/schemas_tool_config.d.ts

@@ -1,22 +1,66 @@
 /**
- * TypeScript interfaces for tool configuration objects
+ * 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 z.ZodSchema = z.ZodSchema> {
-    name?: string;
-    annotations?: any;
-    description: string;
-    inputSchema: T;
-    execute: (args: z.infer<T>) => Promise<string>;
+export interface AITool<T extends Record<string, unknown> | undefined = any, TParams extends ToolParameters = ToolParameters> {
+    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;
 }
 /**
  * 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, z.ZodSchema> = Record<string, z.ZodSchema>> = {
-    [K in keyof T]: AITool<T[K]>;
+export type AITools<T extends Record<string, ToolParameters> = Record<string, ToolParameters>> = {
+    [K in keyof T]: AITool<any, T[K]>;
 };

package/dist/types/util_mcp_tools_converter.d.ts

@@ -1,66 +1,10 @@
-import type { AITools } from "./schemas/schemas_tool_config.ts";
-import type { z } from "zod";
-/**
- * Copy of StandardSchemaV1 interface for compatibility
- */
-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"];
-}
-/**
- * Copy of FastMCP's Tool type for compatibility
- */
-export type Tool<T extends Record<string, unknown> | undefined = any, Params extends ToolParameters = ToolParameters> = {
-    annotations?: {
-        streamingHint?: boolean;
-    } & {
-        destructiveHint?: boolean;
-        idempotentHint?: boolean;
-        openWorldHint?: boolean;
-        readOnlyHint?: boolean;
-        title?: string;
-    };
-    canAccess?: (auth: T) => boolean;
-    description?: string;
-    execute: (args: ToolParameters.InferOutput<Params>, context: any) => Promise<any>;
-    name: string;
-    parameters?: Params;
-    timeoutMs?: number;
-};
+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: Tool<any, Params>): void;
+    addTool<Params extends ToolParameters>(tool: FastMCPTool<any, Params>): void;
 }
 /**
  * ModalityFastMCP - A FastMCP-compatible implementation
@@ -71,17 +15,14 @@ export declare class ModalityFastMCP implements FastMCPCompatible {
     /**
      * Add a tool to the server
      */
-    addTool<Params extends ToolParameters>(tool: Tool<any, Params>): void;
+    addTool<Params extends ToolParameters>(tool: FastMCPTool<any, Params>): void;
     /**
      * Get all registered tools
      */
-    getTools(): Tool<any, any>[];
+    getTools(): FastMCPTool<any, any>[];
 }
 /**
  * Setup function that optionally registers AITools with MCP server
  * Automatically infers and preserves schema types from the input
- * @param aiTools - The AITools object with schema mapping
- * @param mcpServer - Optional MCP server to register tools with
- * @returns The same AITools object with preserved types
  */
-export declare const setupAITools: <T extends Record<string, z.ZodSchema>>(aiTools: AITools<T>, mcpServer?: FastMCPCompatible) => AITools<T>;
+export declare const setupAITools: <T extends Record<string, ToolParameters>>(aiTools: AITools<T>, mcpServer?: FastMCPCompatible) => AITools<T>;

package/package.json

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