@tpmjs/types 0.1.1 → 0.1.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-2025 TPMJS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/registry.d.ts

@@ -3,32 +3,18 @@ import { z } from 'zod';
 declare const RegistrySearchResultSchema: z.ZodObject<{
     toolId: z.ZodString;
     score: z.ZodNumber;
-    matchType: z.ZodEnum<["exact", "fuzzy", "semantic"]>;
-}, "strip", z.ZodTypeAny, {
-    toolId: string;
-    score: number;
-    matchType: "exact" | "fuzzy" | "semantic";
-}, {
-    toolId: string;
-    score: number;
-    matchType: "exact" | "fuzzy" | "semantic";
-}>;
+    matchType: z.ZodEnum<{
+        exact: "exact";
+        fuzzy: "fuzzy";
+        semantic: "semantic";
+    }>;
+}, z.core.$strip>;
 declare const RegistrySearchOptionsSchema: z.ZodObject<{
     query: z.ZodString;
     category: z.ZodOptional<z.ZodString>;
     limit: z.ZodDefault<z.ZodNumber>;
     offset: z.ZodDefault<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    query: string;
-    limit: number;
-    offset: number;
-    category?: string | undefined;
-}, {
-    query: string;
-    category?: string | undefined;
-    limit?: number | undefined;
-    offset?: number | undefined;
-}>;
+}, z.core.$strip>;
 type RegistrySearchResult = z.infer<typeof RegistrySearchResultSchema>;
 type RegistrySearchOptions = z.infer<typeof RegistrySearchOptionsSchema>;
 

package/dist/tool.d.ts

@@ -5,17 +5,7 @@ declare const ToolParameterSchema: z.ZodObject<{
     description: z.ZodString;
     schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     required: z.ZodDefault<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    description: string;
-    schema: Record<string, unknown>;
-    required: boolean;
-}, {
-    name: string;
-    description: string;
-    schema: Record<string, unknown>;
-    required?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 declare const ToolSchema: z.ZodObject<{
     id: z.ZodString;
     name: z.ZodString;
@@ -27,45 +17,9 @@ declare const ToolSchema: z.ZodObject<{
         description: z.ZodString;
         schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         required: z.ZodDefault<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        name: string;
-        description: string;
-        schema: Record<string, unknown>;
-        required: boolean;
-    }, {
-        name: string;
-        description: string;
-        schema: Record<string, unknown>;
-        required?: boolean | undefined;
-    }>, "many">;
-    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    description: string;
-    id: string;
-    category: string;
-    version: string;
-    parameters: {
-        name: string;
-        description: string;
-        schema: Record<string, unknown>;
-        required: boolean;
-    }[];
-    tags: string[];
-}, {
-    name: string;
-    description: string;
-    id: string;
-    category: string;
-    version: string;
-    parameters: {
-        name: string;
-        description: string;
-        schema: Record<string, unknown>;
-        required?: boolean | undefined;
-    }[];
-    tags?: string[] | undefined;
-}>;
+    }, z.core.$strip>>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
 type Tool = z.infer<typeof ToolSchema>;
 type ToolParameter = z.infer<typeof ToolParameterSchema>;
 

package/dist/tool.js

@@ -4,7 +4,7 @@ import { z } from 'zod';
 var ToolParameterSchema = z.object({
   name: z.string(),
   description: z.string(),
-  schema: z.record(z.unknown()),
+  schema: z.record(z.string(), z.unknown()),
   required: z.boolean().default(false)
 });
 var ToolSchema = z.object({

package/dist/tpmjs.d.ts

@@ -0,0 +1,411 @@
+import { z } from 'zod';
+
+/**
+ * Valid tool categories for TPMJS registry
+ */
+declare const TPMJS_CATEGORIES: readonly ["web-scraping", "data-processing", "file-operations", "communication", "database", "api-integration", "image-processing", "text-analysis", "automation", "ai-ml", "security", "monitoring", "research"];
+type TpmjsCategory = (typeof TPMJS_CATEGORIES)[number];
+/**
+ * Tool parameter schema
+ *
+ * @deprecated Parameters are now auto-extracted from the tool's inputSchema at runtime.
+ * You no longer need to manually specify parameters in your package.json.
+ * This schema is kept for backward compatibility as a fallback if auto-extraction fails.
+ */
+declare const TpmjsParameterSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodString;
+    description: z.ZodString;
+    required: z.ZodDefault<z.ZodBoolean>;
+    default: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+type TpmjsParameter = z.infer<typeof TpmjsParameterSchema>;
+/**
+ * Return value schema
+ *
+ * @deprecated Return type information is now auto-extracted from the tool at runtime.
+ * You no longer need to manually specify returns in your package.json.
+ */
+declare const TpmjsReturnsSchema: z.ZodObject<{
+    type: z.ZodString;
+    description: z.ZodString;
+}, z.core.$strip>;
+type TpmjsReturns = z.infer<typeof TpmjsReturnsSchema>;
+/**
+ * Environment variable schema
+ */
+declare const TpmjsEnvSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    required: z.ZodDefault<z.ZodBoolean>;
+    default: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type TpmjsEnv = z.infer<typeof TpmjsEnvSchema>;
+/**
+ * AI Agent guidance schema
+ *
+ * @deprecated AI agent guidance is now auto-extracted from the tool at runtime.
+ * You no longer need to manually specify aiAgent in your package.json.
+ */
+declare const TpmjsAiAgentSchema: z.ZodObject<{
+    useCase: z.ZodString;
+    limitations: z.ZodOptional<z.ZodString>;
+    examples: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type TpmjsAiAgent = z.infer<typeof TpmjsAiAgentSchema>;
+/**
+ * Individual tool definition within a multi-tool package
+ *
+ * Required fields:
+ * - name: The export name of the tool from the package
+ *
+ * Optional fields (auto-extracted if not provided):
+ * - description: A description of what the tool does (20-500 chars) - auto-extracted from tool
+ *
+ * @deprecated fields (now auto-extracted, kept for backward compatibility):
+ * - parameters: Tool input parameters - auto-extracted from inputSchema
+ * - returns: Tool return type - auto-extracted from tool
+ * - aiAgent: AI agent guidance - auto-extracted from tool
+ * - exportName: Renamed to 'name' - kept for backward compatibility with published packages
+ */
+declare const TpmjsToolDefinitionSchema: z.ZodPipe<z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    exportName: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        description: z.ZodString;
+        required: z.ZodDefault<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>>>;
+    returns: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strip>>;
+    aiAgent: z.ZodOptional<z.ZodObject<{
+        useCase: z.ZodString;
+        limitations: z.ZodOptional<z.ZodString>;
+        examples: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodTransform<{
+    name: string;
+    description: string | undefined;
+    parameters: {
+        name: string;
+        type: string;
+        description: string;
+        required: boolean;
+        default?: unknown;
+    }[] | undefined;
+    returns: {
+        type: string;
+        description: string;
+    } | undefined;
+    aiAgent: {
+        useCase: string;
+        limitations?: string | undefined;
+        examples?: string[] | undefined;
+    } | undefined;
+}, {
+    name?: string | undefined;
+    exportName?: string | undefined;
+    description?: string | undefined;
+    parameters?: {
+        name: string;
+        type: string;
+        description: string;
+        required: boolean;
+        default?: unknown;
+    }[] | undefined;
+    returns?: {
+        type: string;
+        description: string;
+    } | undefined;
+    aiAgent?: {
+        useCase: string;
+        limitations?: string | undefined;
+        examples?: string[] | undefined;
+    } | undefined;
+}>>;
+type TpmjsToolDefinition = z.infer<typeof TpmjsToolDefinitionSchema>;
+/**
+ * Multi-tool format - NEW SCHEMA
+ * Package-level metadata with optional array of tools
+ *
+ * If tools is not provided, TPMJS will auto-discover exports from the package.
+ * Authors can override auto-discovery by providing explicit tool definitions.
+ */
+declare const TpmjsMultiToolSchema: z.ZodObject<{
+    category: z.ZodEnum<{
+        "web-scraping": "web-scraping";
+        "data-processing": "data-processing";
+        "file-operations": "file-operations";
+        communication: "communication";
+        database: "database";
+        "api-integration": "api-integration";
+        "image-processing": "image-processing";
+        "text-analysis": "text-analysis";
+        automation: "automation";
+        "ai-ml": "ai-ml";
+        security: "security";
+        monitoring: "monitoring";
+        research: "research";
+    }>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        exportName: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodString;
+            description: z.ZodString;
+            required: z.ZodDefault<z.ZodBoolean>;
+            default: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strip>>>;
+        returns: z.ZodOptional<z.ZodObject<{
+            type: z.ZodString;
+            description: z.ZodString;
+        }, z.core.$strip>>;
+        aiAgent: z.ZodOptional<z.ZodObject<{
+            useCase: z.ZodString;
+            limitations: z.ZodOptional<z.ZodString>;
+            examples: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodTransform<{
+        name: string;
+        description: string | undefined;
+        parameters: {
+            name: string;
+            type: string;
+            description: string;
+            required: boolean;
+            default?: unknown;
+        }[] | undefined;
+        returns: {
+            type: string;
+            description: string;
+        } | undefined;
+        aiAgent: {
+            useCase: string;
+            limitations?: string | undefined;
+            examples?: string[] | undefined;
+        } | undefined;
+    }, {
+        name?: string | undefined;
+        exportName?: string | undefined;
+        description?: string | undefined;
+        parameters?: {
+            name: string;
+            type: string;
+            description: string;
+            required: boolean;
+            default?: unknown;
+        }[] | undefined;
+        returns?: {
+            type: string;
+            description: string;
+        } | undefined;
+        aiAgent?: {
+            useCase: string;
+            limitations?: string | undefined;
+            examples?: string[] | undefined;
+        } | undefined;
+    }>>>>;
+    env: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        required: z.ZodDefault<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    frameworks: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        "vercel-ai": "vercel-ai";
+        langchain: "langchain";
+        llamaindex: "llamaindex";
+        haystack: "haystack";
+        "semantic-kernel": "semantic-kernel";
+    }>>>;
+}, z.core.$strip>;
+type TpmjsMultiTool = z.infer<typeof TpmjsMultiToolSchema>;
+/**
+ * Legacy minimal tier schema - DEPRECATED
+ * Kept for backward compatibility with auto-migration
+ */
+declare const TpmjsLegacyMinimalSchema: z.ZodObject<{
+    category: z.ZodEnum<{
+        "web-scraping": "web-scraping";
+        "data-processing": "data-processing";
+        "file-operations": "file-operations";
+        communication: "communication";
+        database: "database";
+        "api-integration": "api-integration";
+        "image-processing": "image-processing";
+        "text-analysis": "text-analysis";
+        automation: "automation";
+        "ai-ml": "ai-ml";
+        security: "security";
+        monitoring: "monitoring";
+        research: "research";
+    }>;
+    description: z.ZodString;
+}, z.core.$strip>;
+type TpmjsLegacyMinimal = z.infer<typeof TpmjsLegacyMinimalSchema>;
+/**
+ * Legacy rich tier schema - DEPRECATED
+ * Kept for backward compatibility with auto-migration
+ */
+declare const TpmjsLegacyRichSchema: z.ZodObject<{
+    category: z.ZodEnum<{
+        "web-scraping": "web-scraping";
+        "data-processing": "data-processing";
+        "file-operations": "file-operations";
+        communication: "communication";
+        database: "database";
+        "api-integration": "api-integration";
+        "image-processing": "image-processing";
+        "text-analysis": "text-analysis";
+        automation: "automation";
+        "ai-ml": "ai-ml";
+        security: "security";
+        monitoring: "monitoring";
+        research: "research";
+    }>;
+    description: z.ZodString;
+    parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        description: z.ZodString;
+        required: z.ZodDefault<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>>>;
+    returns: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strip>>;
+    env: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        required: z.ZodDefault<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    frameworks: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        "vercel-ai": "vercel-ai";
+        langchain: "langchain";
+        llamaindex: "llamaindex";
+        haystack: "haystack";
+        "semantic-kernel": "semantic-kernel";
+    }>>>;
+    aiAgent: z.ZodOptional<z.ZodObject<{
+        useCase: z.ZodString;
+        limitations: z.ZodOptional<z.ZodString>;
+        examples: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type TpmjsLegacyRich = z.infer<typeof TpmjsLegacyRichSchema>;
+/**
+ * Union type for legacy formats
+ */
+type TpmjsLegacy = TpmjsLegacyMinimal | TpmjsLegacyRich;
+/**
+ * Union type for all formats (new multi-tool + legacy)
+ */
+type TpmjsField = TpmjsMultiTool | TpmjsLegacy;
+type TpmjsMinimal = TpmjsLegacyMinimal;
+type TpmjsRich = TpmjsLegacyRich;
+declare const TpmjsMinimalSchema: z.ZodObject<{
+    category: z.ZodEnum<{
+        "web-scraping": "web-scraping";
+        "data-processing": "data-processing";
+        "file-operations": "file-operations";
+        communication: "communication";
+        database: "database";
+        "api-integration": "api-integration";
+        "image-processing": "image-processing";
+        "text-analysis": "text-analysis";
+        automation: "automation";
+        "ai-ml": "ai-ml";
+        security: "security";
+        monitoring: "monitoring";
+        research: "research";
+    }>;
+    description: z.ZodString;
+}, z.core.$strip>;
+declare const TpmjsRichSchema: z.ZodObject<{
+    category: z.ZodEnum<{
+        "web-scraping": "web-scraping";
+        "data-processing": "data-processing";
+        "file-operations": "file-operations";
+        communication: "communication";
+        database: "database";
+        "api-integration": "api-integration";
+        "image-processing": "image-processing";
+        "text-analysis": "text-analysis";
+        automation: "automation";
+        "ai-ml": "ai-ml";
+        security: "security";
+        monitoring: "monitoring";
+        research: "research";
+    }>;
+    description: z.ZodString;
+    parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        description: z.ZodString;
+        required: z.ZodDefault<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>>>;
+    returns: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strip>>;
+    env: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        required: z.ZodDefault<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    frameworks: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        "vercel-ai": "vercel-ai";
+        langchain: "langchain";
+        llamaindex: "llamaindex";
+        haystack: "haystack";
+        "semantic-kernel": "semantic-kernel";
+    }>>>;
+    aiAgent: z.ZodOptional<z.ZodObject<{
+        useCase: z.ZodString;
+        limitations: z.ZodOptional<z.ZodString>;
+        examples: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Extended validation result type for multi-tool support
+ */
+interface ValidationResult {
+    valid: boolean;
+    tier: 'minimal' | 'rich' | null;
+    data?: TpmjsField;
+    errors?: z.ZodError;
+    packageData?: {
+        category: TpmjsCategory;
+        env?: TpmjsEnv[];
+        frameworks?: string[];
+    };
+    tools?: TpmjsToolDefinition[];
+    wasLegacyFormat?: boolean;
+    needsAutoDiscovery?: boolean;
+}
+/**
+ * Validates a tpmjs field and determines its tier
+ * Supports both new multi-tool format and legacy single-tool format with auto-migration
+ */
+declare function validateTpmjsField(tpmjs: unknown): ValidationResult;
+/**
+ * Type guard for minimal tier
+ */
+declare function isTpmjsMinimal(tpmjs: unknown): tpmjs is TpmjsMinimal;
+/**
+ * Type guard for rich tier
+ */
+declare function isTpmjsRich(tpmjs: unknown): tpmjs is TpmjsRich;
+
+export { TPMJS_CATEGORIES, type TpmjsAiAgent, TpmjsAiAgentSchema, type TpmjsCategory, type TpmjsEnv, TpmjsEnvSchema, type TpmjsField, type TpmjsLegacy, type TpmjsLegacyMinimal, TpmjsLegacyMinimalSchema, type TpmjsLegacyRich, TpmjsLegacyRichSchema, type TpmjsMinimal, TpmjsMinimalSchema, type TpmjsMultiTool, TpmjsMultiToolSchema, type TpmjsParameter, TpmjsParameterSchema, type TpmjsReturns, TpmjsReturnsSchema, type TpmjsRich, TpmjsRichSchema, type TpmjsToolDefinition, TpmjsToolDefinitionSchema, type ValidationResult, isTpmjsMinimal, isTpmjsRich, validateTpmjsField };

package/dist/tpmjs.js

@@ -0,0 +1,169 @@
+import { z } from 'zod';
+
+// src/tpmjs.ts
+var TPMJS_CATEGORIES = [
+  "web-scraping",
+  "data-processing",
+  "file-operations",
+  "communication",
+  "database",
+  "api-integration",
+  "image-processing",
+  "text-analysis",
+  "automation",
+  "ai-ml",
+  "security",
+  "monitoring",
+  "research"
+];
+var TpmjsParameterSchema = z.object({
+  name: z.string().min(1),
+  type: z.string().min(1),
+  description: z.string().min(1),
+  required: z.boolean().default(false),
+  default: z.unknown().optional()
+});
+var TpmjsReturnsSchema = z.object({
+  type: z.string().min(1),
+  description: z.string().min(1)
+});
+var TpmjsEnvSchema = z.object({
+  name: z.string().min(1),
+  description: z.string().min(1),
+  required: z.boolean().default(true),
+  default: z.string().optional()
+});
+var TpmjsAiAgentSchema = z.object({
+  useCase: z.string().min(10),
+  limitations: z.string().optional(),
+  examples: z.array(z.string()).optional()
+});
+var TpmjsToolDefinitionSchema = z.object({
+  // Required: The export name of the tool from the package
+  // Accepts both 'name' and legacy 'exportName' field
+  name: z.string().min(1).optional(),
+  // @deprecated - renamed to 'name', kept for backward compatibility
+  exportName: z.string().min(1).optional(),
+  // Optional - auto-extracted from tool if not provided
+  description: z.string().min(20, "Description must be at least 20 characters").max(500).optional(),
+  // @deprecated - now auto-extracted from tool's inputSchema
+  parameters: z.array(TpmjsParameterSchema).optional(),
+  // @deprecated - now auto-extracted from tool
+  returns: TpmjsReturnsSchema.optional(),
+  // @deprecated - now auto-extracted from tool
+  aiAgent: TpmjsAiAgentSchema.optional()
+}).transform((data) => ({
+  // Transform exportName to name for backward compatibility
+  name: data.name || data.exportName || "",
+  description: data.description,
+  parameters: data.parameters,
+  returns: data.returns,
+  aiAgent: data.aiAgent
+})).refine((data) => data.name.length > 0, {
+  message: "Either name or exportName is required",
+  path: ["name"]
+});
+var TpmjsMultiToolSchema = z.object({
+  category: z.enum(TPMJS_CATEGORIES, {
+    message: `Category must be one of: ${TPMJS_CATEGORIES.join(", ")}`
+  }),
+  // Optional - if not provided, tools are auto-discovered from package exports
+  tools: z.array(TpmjsToolDefinitionSchema).optional(),
+  env: z.array(TpmjsEnvSchema).optional(),
+  frameworks: z.array(z.enum(["vercel-ai", "langchain", "llamaindex", "haystack", "semantic-kernel"])).optional()
+});
+var TpmjsLegacyMinimalSchema = z.object({
+  category: z.enum(TPMJS_CATEGORIES, {
+    message: `Category must be one of: ${TPMJS_CATEGORIES.join(", ")}`
+  }),
+  description: z.string().min(20, "Description must be at least 20 characters").max(500)
+});
+var TpmjsLegacyRichSchema = TpmjsLegacyMinimalSchema.extend({
+  parameters: z.array(TpmjsParameterSchema).optional(),
+  returns: TpmjsReturnsSchema.optional(),
+  env: z.array(TpmjsEnvSchema).optional(),
+  frameworks: z.array(z.enum(["vercel-ai", "langchain", "llamaindex", "haystack", "semantic-kernel"])).optional(),
+  aiAgent: TpmjsAiAgentSchema.optional()
+});
+var TpmjsMinimalSchema = TpmjsLegacyMinimalSchema;
+var TpmjsRichSchema = TpmjsLegacyRichSchema;
+function validateTpmjsField(tpmjs) {
+  const multiResult = TpmjsMultiToolSchema.safeParse(tpmjs);
+  if (multiResult.success) {
+    const data = multiResult.data;
+    const needsAutoDiscovery = !data.tools || data.tools.length === 0;
+    const hasRichFields = (data.tools?.some((tool) => tool.parameters || tool.returns || tool.aiAgent) ?? false) || data.env || data.frameworks;
+    return {
+      valid: true,
+      tier: hasRichFields ? "rich" : "minimal",
+      data,
+      packageData: {
+        category: data.category,
+        env: data.env,
+        frameworks: data.frameworks
+      },
+      tools: data.tools,
+      wasLegacyFormat: false,
+      needsAutoDiscovery
+    };
+  }
+  const richResult = TpmjsLegacyRichSchema.safeParse(tpmjs);
+  if (richResult.success) {
+    const legacyData = richResult.data;
+    const tool = {
+      name: "default",
+      description: legacyData.description,
+      parameters: legacyData.parameters,
+      returns: legacyData.returns,
+      aiAgent: legacyData.aiAgent
+    };
+    const hasRichFields = legacyData.parameters || legacyData.returns || legacyData.env || legacyData.frameworks || legacyData.aiAgent;
+    return {
+      valid: true,
+      tier: hasRichFields ? "rich" : "minimal",
+      data: legacyData,
+      packageData: {
+        category: legacyData.category,
+        env: legacyData.env,
+        frameworks: legacyData.frameworks
+      },
+      tools: [tool],
+      wasLegacyFormat: true,
+      needsAutoDiscovery: false
+    };
+  }
+  const minimalResult = TpmjsLegacyMinimalSchema.safeParse(tpmjs);
+  if (minimalResult.success) {
+    const tool = {
+      name: "default",
+      description: minimalResult.data.description,
+      parameters: void 0,
+      returns: void 0,
+      aiAgent: void 0
+    };
+    return {
+      valid: true,
+      tier: "minimal",
+      data: minimalResult.data,
+      packageData: {
+        category: minimalResult.data.category
+      },
+      tools: [tool],
+      wasLegacyFormat: true,
+      needsAutoDiscovery: false
+    };
+  }
+  return {
+    valid: false,
+    tier: null,
+    errors: multiResult.error
+  };
+}
+function isTpmjsMinimal(tpmjs) {
+  return TpmjsMinimalSchema.safeParse(tpmjs).success;
+}
+function isTpmjsRich(tpmjs) {
+  return TpmjsRichSchema.safeParse(tpmjs).success;
+}
+
+export { TPMJS_CATEGORIES, TpmjsAiAgentSchema, TpmjsEnvSchema, TpmjsLegacyMinimalSchema, TpmjsLegacyRichSchema, TpmjsMinimalSchema, TpmjsMultiToolSchema, TpmjsParameterSchema, TpmjsReturnsSchema, TpmjsRichSchema, TpmjsToolDefinitionSchema, isTpmjsMinimal, isTpmjsRich, validateTpmjsField };

package/package.json

@@ -1,6 +1,22 @@
 {
   "name": "@tpmjs/types",
-  "version": "0.1.1",
+  "version": "0.1.2",
+  "description": "Shared TypeScript types and Zod schemas for TPMJS",
+  "author": "TPMJS",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tpmjs/tpmjs.git",
+    "directory": "packages/types"
+  },
+  "homepage": "https://tpmjs.com",
+  "keywords": [
+    "tpmjs",
+    "typescript",
+    "types",
+    "zod",
+    "schemas"
+  ],
   "type": "module",
   "exports": {
     "./tool": {
@@ -10,13 +26,17 @@
     "./registry": {
       "types": "./dist/registry.d.ts",
       "default": "./dist/registry.js"
+    },
+    "./tpmjs": {
+      "types": "./dist/tpmjs.d.ts",
+      "default": "./dist/tpmjs.js"
     }
   },
   "files": [
     "dist"
   ],
   "dependencies": {
-    "zod": "^3.24.1"
+    "zod": "^4.1.13"
   },
   "devDependencies": {
     "tsup": "^8.3.5",