@tpmjs/types 0.2.0 → 0.2.1

package/dist/agent.d.ts

@@ -0,0 +1,300 @@
+import { z } from 'zod';
+
+declare const AIProviderSchema: z.ZodEnum<{
+    OPENAI: "OPENAI";
+    ANTHROPIC: "ANTHROPIC";
+    GOOGLE: "GOOGLE";
+    GROQ: "GROQ";
+    MISTRAL: "MISTRAL";
+}>;
+declare const MessageRoleSchema: z.ZodEnum<{
+    USER: "USER";
+    ASSISTANT: "ASSISTANT";
+    TOOL: "TOOL";
+    SYSTEM: "SYSTEM";
+}>;
+type AIProvider = z.infer<typeof AIProviderSchema>;
+type MessageRole = z.infer<typeof MessageRoleSchema>;
+declare const CreateAgentSchema: z.ZodObject<{
+    name: z.ZodString;
+    uid: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    provider: z.ZodEnum<{
+        OPENAI: "OPENAI";
+        ANTHROPIC: "ANTHROPIC";
+        GOOGLE: "GOOGLE";
+        GROQ: "GROQ";
+        MISTRAL: "MISTRAL";
+    }>;
+    modelId: z.ZodString;
+    systemPrompt: z.ZodOptional<z.ZodString>;
+    temperature: z.ZodDefault<z.ZodNumber>;
+    maxToolCallsPerTurn: z.ZodDefault<z.ZodNumber>;
+    maxMessagesInContext: z.ZodDefault<z.ZodNumber>;
+    isPublic: z.ZodDefault<z.ZodBoolean>;
+    collectionIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    toolIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+declare const UpdateAgentSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    uid: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    provider: z.ZodOptional<z.ZodEnum<{
+        OPENAI: "OPENAI";
+        ANTHROPIC: "ANTHROPIC";
+        GOOGLE: "GOOGLE";
+        GROQ: "GROQ";
+        MISTRAL: "MISTRAL";
+    }>>;
+    modelId: z.ZodOptional<z.ZodString>;
+    systemPrompt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    maxToolCallsPerTurn: z.ZodOptional<z.ZodNumber>;
+    maxMessagesInContext: z.ZodOptional<z.ZodNumber>;
+    isPublic: z.ZodOptional<z.ZodBoolean>;
+    executorType: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        default: "default";
+        custom_url: "custom_url";
+    }>>>;
+    executorConfig: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        url: z.ZodString;
+        apiKey: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    envVars: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>>;
+}, z.core.$strip>;
+declare const AddCollectionToAgentSchema: z.ZodObject<{
+    collectionId: z.ZodString;
+    position: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const AddToolToAgentSchema: z.ZodObject<{
+    toolId: z.ZodString;
+    position: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const CloneAgentSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    uid: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const SUPPORTED_PROVIDERS: readonly ["OPENAI", "ANTHROPIC", "GOOGLE", "GROQ", "MISTRAL"];
+declare const AddApiKeySchema: z.ZodObject<{
+    provider: z.ZodEnum<{
+        OPENAI: "OPENAI";
+        ANTHROPIC: "ANTHROPIC";
+        GOOGLE: "GOOGLE";
+        GROQ: "GROQ";
+        MISTRAL: "MISTRAL";
+    }>;
+    apiKey: z.ZodString;
+}, z.core.$strip>;
+declare const ApiKeyInfoSchema: z.ZodObject<{
+    provider: z.ZodEnum<{
+        OPENAI: "OPENAI";
+        ANTHROPIC: "ANTHROPIC";
+        GOOGLE: "GOOGLE";
+        GROQ: "GROQ";
+        MISTRAL: "MISTRAL";
+    }>;
+    keyHint: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+}, z.core.$strip>;
+declare const CreateConversationSchema: z.ZodObject<{
+    slug: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const SendMessageSchema: z.ZodObject<{
+    message: z.ZodString;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+declare const ToolCallSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    arguments: z.ZodString;
+}, z.core.$strip>;
+declare const MessageSchema: z.ZodObject<{
+    id: z.ZodString;
+    role: z.ZodEnum<{
+        USER: "USER";
+        ASSISTANT: "ASSISTANT";
+        TOOL: "TOOL";
+        SYSTEM: "SYSTEM";
+    }>;
+    content: z.ZodString;
+    toolCalls: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        arguments: z.ZodString;
+    }, z.core.$strip>>>;
+    toolCallId: z.ZodNullable<z.ZodString>;
+    toolName: z.ZodNullable<z.ZodString>;
+    toolResult: z.ZodNullable<z.ZodAny>;
+    inputTokens: z.ZodNullable<z.ZodNumber>;
+    outputTokens: z.ZodNullable<z.ZodNumber>;
+    createdAt: z.ZodDate;
+}, z.core.$strip>;
+declare const AgentSchema: z.ZodObject<{
+    id: z.ZodString;
+    uid: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    provider: z.ZodEnum<{
+        OPENAI: "OPENAI";
+        ANTHROPIC: "ANTHROPIC";
+        GOOGLE: "GOOGLE";
+        GROQ: "GROQ";
+        MISTRAL: "MISTRAL";
+    }>;
+    modelId: z.ZodString;
+    systemPrompt: z.ZodNullable<z.ZodString>;
+    temperature: z.ZodNumber;
+    maxToolCallsPerTurn: z.ZodNumber;
+    maxMessagesInContext: z.ZodNumber;
+    isPublic: z.ZodBoolean;
+    toolCount: z.ZodNumber;
+    collectionCount: z.ZodNumber;
+    forkCount: z.ZodDefault<z.ZodNumber>;
+    forkedFromId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+}, z.core.$strip>;
+declare const ConversationSchema: z.ZodObject<{
+    id: z.ZodString;
+    agentId: z.ZodString;
+    slug: z.ZodString;
+    title: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+    messageCount: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const ConversationWithMessagesSchema: z.ZodObject<{
+    id: z.ZodString;
+    agentId: z.ZodString;
+    slug: z.ZodString;
+    title: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+    messageCount: z.ZodOptional<z.ZodNumber>;
+    messages: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        role: z.ZodEnum<{
+            USER: "USER";
+            ASSISTANT: "ASSISTANT";
+            TOOL: "TOOL";
+            SYSTEM: "SYSTEM";
+        }>;
+        content: z.ZodString;
+        toolCalls: z.ZodNullable<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            arguments: z.ZodString;
+        }, z.core.$strip>>>;
+        toolCallId: z.ZodNullable<z.ZodString>;
+        toolName: z.ZodNullable<z.ZodString>;
+        toolResult: z.ZodNullable<z.ZodAny>;
+        inputTokens: z.ZodNullable<z.ZodNumber>;
+        outputTokens: z.ZodNullable<z.ZodNumber>;
+        createdAt: z.ZodDate;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type CreateAgentInput = z.infer<typeof CreateAgentSchema>;
+type UpdateAgentInput = z.infer<typeof UpdateAgentSchema>;
+type AddCollectionToAgentInput = z.infer<typeof AddCollectionToAgentSchema>;
+type AddToolToAgentInput = z.infer<typeof AddToolToAgentSchema>;
+type CloneAgentInput = z.infer<typeof CloneAgentSchema>;
+type AddApiKeyInput = z.infer<typeof AddApiKeySchema>;
+type ApiKeyInfo = z.infer<typeof ApiKeyInfoSchema>;
+type CreateConversationInput = z.infer<typeof CreateConversationSchema>;
+type SendMessageInput = z.infer<typeof SendMessageSchema>;
+type ToolCall = z.infer<typeof ToolCallSchema>;
+type Message = z.infer<typeof MessageSchema>;
+type Agent = z.infer<typeof AgentSchema>;
+type Conversation = z.infer<typeof ConversationSchema>;
+type ConversationWithMessages = z.infer<typeof ConversationWithMessagesSchema>;
+declare const AGENT_LIMITS: {
+    readonly MAX_AGENTS_PER_USER: 20;
+    readonly MAX_COLLECTIONS_PER_AGENT: 10;
+    readonly MAX_TOOLS_PER_AGENT: 50;
+    readonly MAX_SYSTEM_PROMPT_LENGTH: 10000;
+    readonly MAX_NAME_LENGTH: 100;
+    readonly MAX_DESCRIPTION_LENGTH: 500;
+    readonly MAX_UID_LENGTH: 50;
+};
+declare const CONVERSATION_LIMITS: {
+    readonly MAX_CONVERSATIONS_PER_AGENT: 100;
+    readonly MAX_MESSAGE_LENGTH: 50000;
+    readonly MAX_TITLE_LENGTH: 200;
+    readonly MAX_SLUG_LENGTH: 100;
+};
+declare const PROVIDER_MODELS: {
+    readonly OPENAI: readonly [{
+        readonly id: "gpt-4o";
+        readonly name: "GPT-4o";
+        readonly contextWindow: 128000;
+    }, {
+        readonly id: "gpt-4o-mini";
+        readonly name: "GPT-4o Mini";
+        readonly contextWindow: 128000;
+    }, {
+        readonly id: "gpt-4-turbo";
+        readonly name: "GPT-4 Turbo";
+        readonly contextWindow: 128000;
+    }, {
+        readonly id: "gpt-3.5-turbo";
+        readonly name: "GPT-3.5 Turbo";
+        readonly contextWindow: 16385;
+    }];
+    readonly ANTHROPIC: readonly [{
+        readonly id: "claude-3-5-sonnet-20241022";
+        readonly name: "Claude 3.5 Sonnet";
+        readonly contextWindow: 200000;
+    }, {
+        readonly id: "claude-3-5-haiku-20241022";
+        readonly name: "Claude 3.5 Haiku";
+        readonly contextWindow: 200000;
+    }, {
+        readonly id: "claude-3-opus-20240229";
+        readonly name: "Claude 3 Opus";
+        readonly contextWindow: 200000;
+    }];
+    readonly GOOGLE: readonly [{
+        readonly id: "gemini-2.0-flash-exp";
+        readonly name: "Gemini 2.0 Flash";
+        readonly contextWindow: 1000000;
+    }, {
+        readonly id: "gemini-1.5-pro";
+        readonly name: "Gemini 1.5 Pro";
+        readonly contextWindow: 1000000;
+    }, {
+        readonly id: "gemini-1.5-flash";
+        readonly name: "Gemini 1.5 Flash";
+        readonly contextWindow: 1000000;
+    }];
+    readonly GROQ: readonly [{
+        readonly id: "llama-3.3-70b-versatile";
+        readonly name: "Llama 3.3 70B";
+        readonly contextWindow: 131072;
+    }, {
+        readonly id: "llama-3.1-8b-instant";
+        readonly name: "Llama 3.1 8B";
+        readonly contextWindow: 131072;
+    }, {
+        readonly id: "mixtral-8x7b-32768";
+        readonly name: "Mixtral 8x7B";
+        readonly contextWindow: 32768;
+    }];
+    readonly MISTRAL: readonly [{
+        readonly id: "mistral-large-latest";
+        readonly name: "Mistral Large";
+        readonly contextWindow: 128000;
+    }, {
+        readonly id: "mistral-small-latest";
+        readonly name: "Mistral Small";
+        readonly contextWindow: 128000;
+    }];
+};
+type ProviderModel = {
+    id: string;
+    name: string;
+    contextWindow: number;
+};
+
+export { AGENT_LIMITS, type AIProvider, AIProviderSchema, type AddApiKeyInput, AddApiKeySchema, type AddCollectionToAgentInput, AddCollectionToAgentSchema, type AddToolToAgentInput, AddToolToAgentSchema, type Agent, AgentSchema, type ApiKeyInfo, ApiKeyInfoSchema, CONVERSATION_LIMITS, type CloneAgentInput, CloneAgentSchema, type Conversation, ConversationSchema, type ConversationWithMessages, ConversationWithMessagesSchema, type CreateAgentInput, CreateAgentSchema, type CreateConversationInput, CreateConversationSchema, type Message, type MessageRole, MessageRoleSchema, MessageSchema, PROVIDER_MODELS, type ProviderModel, SUPPORTED_PROVIDERS, type SendMessageInput, SendMessageSchema, type ToolCall, ToolCallSchema, type UpdateAgentInput, UpdateAgentSchema };

package/dist/agent.js

@@ -0,0 +1,206 @@
+import { z } from 'zod';
+
+// src/agent.ts
+var ExecutorTypeSchema = z.enum(["default", "custom_url"]);
+var DefaultExecutorConfigSchema = z.object({
+  type: z.literal("default")
+});
+var CustomUrlExecutorConfigSchema = z.object({
+  type: z.literal("custom_url"),
+  /** URL of the custom executor (must be HTTPS in production) */
+  url: z.string().url(),
+  /** Optional API key for Bearer token authentication */
+  apiKey: z.string().optional()
+});
+z.discriminatedUnion("type", [
+  DefaultExecutorConfigSchema,
+  CustomUrlExecutorConfigSchema
+]);
+z.object({
+  packageName: z.string().min(1),
+  name: z.string().min(1),
+  version: z.string().optional(),
+  importUrl: z.string().url().optional(),
+  params: z.record(z.string(), z.unknown()),
+  env: z.record(z.string(), z.string()).optional()
+});
+z.object({
+  success: z.boolean(),
+  output: z.unknown().optional(),
+  error: z.string().optional(),
+  executionTimeMs: z.number()
+});
+z.object({
+  status: z.enum(["ok", "degraded", "error"]),
+  version: z.string().optional(),
+  info: z.record(z.string(), z.unknown()).optional()
+});
+z.object({
+  url: z.string().url(),
+  apiKey: z.string().optional()
+});
+
+// src/agent.ts
+var UID_REGEX = /^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$/;
+var ExecutorConfigUpdateSchema = z.object({
+  url: z.string().url(),
+  apiKey: z.string().optional()
+}).nullable().optional();
+var AIProviderSchema = z.enum(["OPENAI", "ANTHROPIC", "GOOGLE", "GROQ", "MISTRAL"]);
+var MessageRoleSchema = z.enum(["USER", "ASSISTANT", "TOOL", "SYSTEM"]);
+var CreateAgentSchema = z.object({
+  name: z.string().min(1, "Name is required").max(100, "Name must be 100 characters or less"),
+  uid: z.string().min(1, "UID is required").max(50, "UID must be 50 characters or less").regex(UID_REGEX, "UID must be lowercase alphanumeric with hyphens").optional(),
+  description: z.string().max(500, "Description must be 500 characters or less").optional(),
+  provider: AIProviderSchema,
+  modelId: z.string().min(1, "Model ID is required").max(100),
+  systemPrompt: z.string().max(1e4, "System prompt must be 10,000 characters or less").optional(),
+  temperature: z.number().min(0).max(2).default(0.7),
+  maxToolCallsPerTurn: z.number().int().min(1).max(100).default(20),
+  maxMessagesInContext: z.number().int().min(1).max(100).default(10),
+  isPublic: z.boolean().default(true),
+  collectionIds: z.array(z.string()).optional(),
+  toolIds: z.array(z.string()).optional()
+});
+var UpdateAgentSchema = z.object({
+  name: z.string().min(1).max(100).optional(),
+  uid: z.string().min(1).max(50).regex(UID_REGEX).optional(),
+  description: z.string().max(500).nullable().optional(),
+  provider: AIProviderSchema.optional(),
+  modelId: z.string().min(1).max(100).optional(),
+  systemPrompt: z.string().max(1e4).nullable().optional(),
+  temperature: z.number().min(0).max(2).optional(),
+  maxToolCallsPerTurn: z.number().int().min(1).max(100).optional(),
+  maxMessagesInContext: z.number().int().min(1).max(100).optional(),
+  isPublic: z.boolean().optional(),
+  // Executor configuration
+  executorType: ExecutorTypeSchema.nullable().optional(),
+  executorConfig: ExecutorConfigUpdateSchema,
+  // Tool environment variables
+  envVars: z.record(z.string(), z.string()).nullable().optional()
+});
+var AddCollectionToAgentSchema = z.object({
+  collectionId: z.string().min(1, "Collection ID is required"),
+  position: z.number().int().min(0).optional()
+});
+var AddToolToAgentSchema = z.object({
+  toolId: z.string().min(1, "Tool ID is required"),
+  position: z.number().int().min(0).optional()
+});
+var CloneAgentSchema = z.object({
+  name: z.string().min(1).max(100).optional(),
+  // If not provided, will append "(copy)"
+  uid: z.string().min(1).max(50).regex(UID_REGEX, "UID must be lowercase alphanumeric with hyphens").optional()
+  // If not provided, will generate from name
+});
+var SUPPORTED_PROVIDERS = ["OPENAI", "ANTHROPIC", "GOOGLE", "GROQ", "MISTRAL"];
+var AddApiKeySchema = z.object({
+  provider: AIProviderSchema,
+  apiKey: z.string().min(10, "API key is required")
+});
+var ApiKeyInfoSchema = z.object({
+  provider: AIProviderSchema,
+  keyHint: z.string().nullable(),
+  createdAt: z.date(),
+  updatedAt: z.date()
+});
+var CreateConversationSchema = z.object({
+  slug: z.string().min(1).max(100).regex(/^[a-z0-9-]+$/, "Slug must be lowercase alphanumeric with hyphens").optional(),
+  title: z.string().max(200).optional()
+});
+var SendMessageSchema = z.object({
+  message: z.string().min(1, "Message is required").max(5e4, "Message too long"),
+  env: z.record(z.string(), z.string()).optional()
+});
+var ToolCallSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  arguments: z.string()
+});
+var MessageSchema = z.object({
+  id: z.string(),
+  role: MessageRoleSchema,
+  content: z.string(),
+  toolCalls: z.array(ToolCallSchema).nullable(),
+  toolCallId: z.string().nullable(),
+  toolName: z.string().nullable(),
+  toolResult: z.any().nullable(),
+  inputTokens: z.number().nullable(),
+  outputTokens: z.number().nullable(),
+  createdAt: z.date()
+});
+var AgentSchema = z.object({
+  id: z.string(),
+  uid: z.string(),
+  name: z.string(),
+  description: z.string().nullable(),
+  provider: AIProviderSchema,
+  modelId: z.string(),
+  systemPrompt: z.string().nullable(),
+  temperature: z.number(),
+  maxToolCallsPerTurn: z.number(),
+  maxMessagesInContext: z.number(),
+  isPublic: z.boolean(),
+  toolCount: z.number(),
+  collectionCount: z.number(),
+  forkCount: z.number().default(0),
+  forkedFromId: z.string().nullable().optional(),
+  createdAt: z.date(),
+  updatedAt: z.date()
+});
+var ConversationSchema = z.object({
+  id: z.string(),
+  agentId: z.string(),
+  slug: z.string(),
+  title: z.string().nullable(),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+  messageCount: z.number().optional()
+});
+var ConversationWithMessagesSchema = ConversationSchema.extend({
+  messages: z.array(MessageSchema)
+});
+var AGENT_LIMITS = {
+  MAX_AGENTS_PER_USER: 20,
+  MAX_COLLECTIONS_PER_AGENT: 10,
+  MAX_TOOLS_PER_AGENT: 50,
+  MAX_SYSTEM_PROMPT_LENGTH: 1e4,
+  MAX_NAME_LENGTH: 100,
+  MAX_DESCRIPTION_LENGTH: 500,
+  MAX_UID_LENGTH: 50
+};
+var CONVERSATION_LIMITS = {
+  MAX_CONVERSATIONS_PER_AGENT: 100,
+  MAX_MESSAGE_LENGTH: 5e4,
+  MAX_TITLE_LENGTH: 200,
+  MAX_SLUG_LENGTH: 100
+};
+var PROVIDER_MODELS = {
+  OPENAI: [
+    { id: "gpt-4o", name: "GPT-4o", contextWindow: 128e3 },
+    { id: "gpt-4o-mini", name: "GPT-4o Mini", contextWindow: 128e3 },
+    { id: "gpt-4-turbo", name: "GPT-4 Turbo", contextWindow: 128e3 },
+    { id: "gpt-3.5-turbo", name: "GPT-3.5 Turbo", contextWindow: 16385 }
+  ],
+  ANTHROPIC: [
+    { id: "claude-3-5-sonnet-20241022", name: "Claude 3.5 Sonnet", contextWindow: 2e5 },
+    { id: "claude-3-5-haiku-20241022", name: "Claude 3.5 Haiku", contextWindow: 2e5 },
+    { id: "claude-3-opus-20240229", name: "Claude 3 Opus", contextWindow: 2e5 }
+  ],
+  GOOGLE: [
+    { id: "gemini-2.0-flash-exp", name: "Gemini 2.0 Flash", contextWindow: 1e6 },
+    { id: "gemini-1.5-pro", name: "Gemini 1.5 Pro", contextWindow: 1e6 },
+    { id: "gemini-1.5-flash", name: "Gemini 1.5 Flash", contextWindow: 1e6 }
+  ],
+  GROQ: [
+    { id: "llama-3.3-70b-versatile", name: "Llama 3.3 70B", contextWindow: 131072 },
+    { id: "llama-3.1-8b-instant", name: "Llama 3.1 8B", contextWindow: 131072 },
+    { id: "mixtral-8x7b-32768", name: "Mixtral 8x7B", contextWindow: 32768 }
+  ],
+  MISTRAL: [
+    { id: "mistral-large-latest", name: "Mistral Large", contextWindow: 128e3 },
+    { id: "mistral-small-latest", name: "Mistral Small", contextWindow: 128e3 }
+  ]
+};
+
+export { AGENT_LIMITS, AIProviderSchema, AddApiKeySchema, AddCollectionToAgentSchema, AddToolToAgentSchema, AgentSchema, ApiKeyInfoSchema, CONVERSATION_LIMITS, CloneAgentSchema, ConversationSchema, ConversationWithMessagesSchema, CreateAgentSchema, CreateConversationSchema, MessageRoleSchema, MessageSchema, PROVIDER_MODELS, SUPPORTED_PROVIDERS, SendMessageSchema, ToolCallSchema, UpdateAgentSchema };

package/dist/collection.d.ts

@@ -0,0 +1,125 @@
+import { z } from 'zod';
+
+declare const CreateCollectionSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    isPublic: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const UpdateCollectionSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    isPublic: z.ZodOptional<z.ZodBoolean>;
+    executorType: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        default: "default";
+        custom_url: "custom_url";
+    }>>>;
+    executorConfig: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        url: z.ZodString;
+        apiKey: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    envVars: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>>;
+}, z.core.$strip>;
+declare const AddToolToCollectionSchema: z.ZodObject<{
+    toolId: z.ZodString;
+    note: z.ZodOptional<z.ZodString>;
+    position: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const UpdateCollectionToolSchema: z.ZodObject<{
+    note: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    position: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const ReorderToolsSchema: z.ZodObject<{
+    toolIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+declare const AddBridgeToolToCollectionSchema: z.ZodObject<{
+    serverId: z.ZodString;
+    toolName: z.ZodString;
+    displayName: z.ZodOptional<z.ZodString>;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const UpdateCollectionBridgeToolSchema: z.ZodObject<{
+    displayName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    note: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+declare const CloneCollectionSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const CollectionSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    slug: z.ZodNullable<z.ZodString>;
+    description: z.ZodNullable<z.ZodString>;
+    isPublic: z.ZodBoolean;
+    toolCount: z.ZodNumber;
+    forkCount: z.ZodDefault<z.ZodNumber>;
+    forkedFromId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+}, z.core.$strip>;
+declare const CollectionToolSchema: z.ZodObject<{
+    id: z.ZodString;
+    toolId: z.ZodString;
+    position: z.ZodNumber;
+    note: z.ZodNullable<z.ZodString>;
+    addedAt: z.ZodDate;
+    tool: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        package: z.ZodObject<{
+            id: z.ZodString;
+            npmPackageName: z.ZodString;
+            category: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const CollectionWithToolsSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    slug: z.ZodNullable<z.ZodString>;
+    description: z.ZodNullable<z.ZodString>;
+    isPublic: z.ZodBoolean;
+    toolCount: z.ZodNumber;
+    forkCount: z.ZodDefault<z.ZodNumber>;
+    forkedFromId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+    tools: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        toolId: z.ZodString;
+        position: z.ZodNumber;
+        note: z.ZodNullable<z.ZodString>;
+        addedAt: z.ZodDate;
+        tool: z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodString;
+            package: z.ZodObject<{
+                id: z.ZodString;
+                npmPackageName: z.ZodString;
+                category: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type CreateCollectionInput = z.infer<typeof CreateCollectionSchema>;
+type UpdateCollectionInput = z.infer<typeof UpdateCollectionSchema>;
+type AddToolToCollectionInput = z.infer<typeof AddToolToCollectionSchema>;
+type UpdateCollectionToolInput = z.infer<typeof UpdateCollectionToolSchema>;
+type ReorderToolsInput = z.infer<typeof ReorderToolsSchema>;
+type CloneCollectionInput = z.infer<typeof CloneCollectionSchema>;
+type AddBridgeToolToCollectionInput = z.infer<typeof AddBridgeToolToCollectionSchema>;
+type UpdateCollectionBridgeToolInput = z.infer<typeof UpdateCollectionBridgeToolSchema>;
+type Collection = z.infer<typeof CollectionSchema>;
+type CollectionTool = z.infer<typeof CollectionToolSchema>;
+type CollectionWithTools = z.infer<typeof CollectionWithToolsSchema>;
+declare const COLLECTION_LIMITS: {
+    readonly MAX_COLLECTIONS_PER_USER: 50;
+    readonly MAX_TOOLS_PER_COLLECTION: 100;
+    readonly MAX_BRIDGE_TOOLS_PER_COLLECTION: 50;
+    readonly MAX_NAME_LENGTH: 100;
+    readonly MAX_DESCRIPTION_LENGTH: 500;
+    readonly MAX_NOTE_LENGTH: 500;
+};
+
+export { type AddBridgeToolToCollectionInput, AddBridgeToolToCollectionSchema, type AddToolToCollectionInput, AddToolToCollectionSchema, COLLECTION_LIMITS, type CloneCollectionInput, CloneCollectionSchema, type Collection, CollectionSchema, type CollectionTool, CollectionToolSchema, type CollectionWithTools, CollectionWithToolsSchema, type CreateCollectionInput, CreateCollectionSchema, type ReorderToolsInput, ReorderToolsSchema, type UpdateCollectionBridgeToolInput, UpdateCollectionBridgeToolSchema, type UpdateCollectionInput, UpdateCollectionSchema, type UpdateCollectionToolInput, UpdateCollectionToolSchema };

package/dist/collection.js

@@ -0,0 +1,131 @@
+import { z } from 'zod';
+
+// src/collection.ts
+var ExecutorTypeSchema = z.enum(["default", "custom_url"]);
+var DefaultExecutorConfigSchema = z.object({
+  type: z.literal("default")
+});
+var CustomUrlExecutorConfigSchema = z.object({
+  type: z.literal("custom_url"),
+  /** URL of the custom executor (must be HTTPS in production) */
+  url: z.string().url(),
+  /** Optional API key for Bearer token authentication */
+  apiKey: z.string().optional()
+});
+z.discriminatedUnion("type", [
+  DefaultExecutorConfigSchema,
+  CustomUrlExecutorConfigSchema
+]);
+z.object({
+  packageName: z.string().min(1),
+  name: z.string().min(1),
+  version: z.string().optional(),
+  importUrl: z.string().url().optional(),
+  params: z.record(z.string(), z.unknown()),
+  env: z.record(z.string(), z.string()).optional()
+});
+z.object({
+  success: z.boolean(),
+  output: z.unknown().optional(),
+  error: z.string().optional(),
+  executionTimeMs: z.number()
+});
+z.object({
+  status: z.enum(["ok", "degraded", "error"]),
+  version: z.string().optional(),
+  info: z.record(z.string(), z.unknown()).optional()
+});
+z.object({
+  url: z.string().url(),
+  apiKey: z.string().optional()
+});
+
+// src/collection.ts
+var NAME_REGEX = /^[a-zA-Z0-9\s\-_]+$/;
+var ExecutorConfigUpdateSchema = z.object({
+  url: z.string().url(),
+  apiKey: z.string().optional()
+}).nullable().optional();
+var CreateCollectionSchema = z.object({
+  name: z.string().min(1, "Name is required").max(100, "Name must be 100 characters or less").regex(NAME_REGEX, "Name can only contain letters, numbers, spaces, hyphens, and underscores"),
+  description: z.string().max(500, "Description must be 500 characters or less").optional(),
+  isPublic: z.boolean().default(false)
+});
+var UpdateCollectionSchema = z.object({
+  name: z.string().min(1, "Name is required").max(100, "Name must be 100 characters or less").regex(NAME_REGEX, "Name can only contain letters, numbers, spaces, hyphens, and underscores").optional(),
+  description: z.string().max(500, "Description must be 500 characters or less").nullable().optional(),
+  isPublic: z.boolean().optional(),
+  // Executor configuration
+  executorType: ExecutorTypeSchema.nullable().optional(),
+  executorConfig: ExecutorConfigUpdateSchema,
+  // Tool environment variables
+  envVars: z.record(z.string(), z.string()).nullable().optional()
+});
+var AddToolToCollectionSchema = z.object({
+  toolId: z.string().min(1, "Tool ID is required"),
+  note: z.string().max(500, "Note must be 500 characters or less").optional(),
+  position: z.number().int().min(0).optional()
+});
+var UpdateCollectionToolSchema = z.object({
+  note: z.string().max(500, "Note must be 500 characters or less").nullable().optional(),
+  position: z.number().int().min(0).optional()
+});
+var ReorderToolsSchema = z.object({
+  toolIds: z.array(z.string().min(1))
+});
+var AddBridgeToolToCollectionSchema = z.object({
+  serverId: z.string().min(1, "Server ID is required").max(100),
+  toolName: z.string().min(1, "Tool name is required").max(100),
+  displayName: z.string().max(100).optional(),
+  note: z.string().max(500, "Note must be 500 characters or less").optional()
+});
+var UpdateCollectionBridgeToolSchema = z.object({
+  displayName: z.string().max(100).nullable().optional(),
+  note: z.string().max(500, "Note must be 500 characters or less").nullable().optional()
+});
+var CloneCollectionSchema = z.object({
+  name: z.string().min(1, "Name is required").max(100, "Name must be 100 characters or less").regex(NAME_REGEX, "Name can only contain letters, numbers, spaces, hyphens, and underscores").optional()
+  // If not provided, will use original name or append "(copy)"
+});
+var CollectionSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  slug: z.string().nullable(),
+  description: z.string().nullable(),
+  isPublic: z.boolean(),
+  toolCount: z.number(),
+  forkCount: z.number().default(0),
+  forkedFromId: z.string().nullable().optional(),
+  createdAt: z.date(),
+  updatedAt: z.date()
+});
+var CollectionToolSchema = z.object({
+  id: z.string(),
+  toolId: z.string(),
+  position: z.number(),
+  note: z.string().nullable(),
+  addedAt: z.date(),
+  tool: z.object({
+    id: z.string(),
+    name: z.string(),
+    description: z.string(),
+    package: z.object({
+      id: z.string(),
+      npmPackageName: z.string(),
+      category: z.string()
+    })
+  })
+});
+var CollectionWithToolsSchema = CollectionSchema.extend({
+  tools: z.array(CollectionToolSchema)
+});
+var COLLECTION_LIMITS = {
+  MAX_COLLECTIONS_PER_USER: 50,
+  MAX_TOOLS_PER_COLLECTION: 100,
+  MAX_BRIDGE_TOOLS_PER_COLLECTION: 50,
+  MAX_NAME_LENGTH: 100,
+  MAX_DESCRIPTION_LENGTH: 500,
+  MAX_NOTE_LENGTH: 500
+};
+
+export { AddBridgeToolToCollectionSchema, AddToolToCollectionSchema, COLLECTION_LIMITS, CloneCollectionSchema, CollectionSchema, CollectionToolSchema, CollectionWithToolsSchema, CreateCollectionSchema, ReorderToolsSchema, UpdateCollectionBridgeToolSchema, UpdateCollectionSchema, UpdateCollectionToolSchema };

package/dist/executor.d.ts

@@ -0,0 +1,127 @@
+import { z } from 'zod';
+
+/**
+ * Executor API Types
+ *
+ * These types define the contract between TPMJS and any executor service.
+ * Custom executors must implement the ExecuteToolRequest/Response interface.
+ */
+
+/**
+ * Request payload for POST /execute-tool
+ */
+interface ExecuteToolRequest {
+    /** NPM package name, e.g., "@tpmjs/hello" */
+    packageName: string;
+    /** Tool name within the package, e.g., "helloWorld" */
+    name: string;
+    /** Package version, e.g., "1.0.0" or "latest" */
+    version?: string;
+    /** Direct esm.sh URL override for the package */
+    importUrl?: string;
+    /** Tool parameters to pass to execute() */
+    params: Record<string, unknown>;
+    /** Environment variables to inject during execution */
+    env?: Record<string, string>;
+}
+/**
+ * Response from POST /execute-tool
+ */
+interface ExecuteToolResponse {
+    /** Whether the execution succeeded */
+    success: boolean;
+    /** Tool output on success */
+    output?: unknown;
+    /** Error message on failure */
+    error?: string;
+    /** Execution duration in milliseconds */
+    executionTimeMs: number;
+}
+/**
+ * Response from GET /health (optional but recommended)
+ */
+interface ExecutorHealthResponse {
+    /** Executor status */
+    status: 'ok' | 'degraded' | 'error';
+    /** Executor version string */
+    version?: string;
+    /** Optional additional info */
+    info?: Record<string, unknown>;
+}
+/**
+ * Executor type enum
+ */
+declare const ExecutorTypeSchema: z.ZodEnum<{
+    default: "default";
+    custom_url: "custom_url";
+}>;
+type ExecutorType = z.infer<typeof ExecutorTypeSchema>;
+/**
+ * Default executor config (uses TPMJS Railway executor)
+ */
+declare const DefaultExecutorConfigSchema: z.ZodObject<{
+    type: z.ZodLiteral<"default">;
+}, z.core.$strip>;
+/**
+ * Custom URL executor config
+ */
+declare const CustomUrlExecutorConfigSchema: z.ZodObject<{
+    type: z.ZodLiteral<"custom_url">;
+    url: z.ZodString;
+    apiKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Union of all executor config types
+ */
+declare const ExecutorConfigSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"default">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"custom_url">;
+    url: z.ZodString;
+    apiKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "type">;
+type ExecutorConfig = z.infer<typeof ExecutorConfigSchema>;
+type DefaultExecutorConfig = z.infer<typeof DefaultExecutorConfigSchema>;
+type CustomUrlExecutorConfig = z.infer<typeof CustomUrlExecutorConfigSchema>;
+declare const ExecuteToolRequestSchema: z.ZodObject<{
+    packageName: z.ZodString;
+    name: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    importUrl: z.ZodOptional<z.ZodString>;
+    params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+declare const ExecuteToolResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    output: z.ZodOptional<z.ZodUnknown>;
+    error: z.ZodOptional<z.ZodString>;
+    executionTimeMs: z.ZodNumber;
+}, z.core.$strip>;
+declare const ExecutorHealthResponseSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        ok: "ok";
+        degraded: "degraded";
+        error: "error";
+    }>;
+    version: z.ZodOptional<z.ZodString>;
+    info: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+declare const VerifyExecutorRequestSchema: z.ZodObject<{
+    url: z.ZodString;
+    apiKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+interface VerifyExecutorRequest {
+    url: string;
+    apiKey?: string;
+}
+interface VerifyExecutorResponse {
+    valid: boolean;
+    healthCheck?: ExecutorHealthResponse;
+    testExecution?: {
+        success: boolean;
+        executionTimeMs: number;
+    };
+    errors?: string[];
+}
+
+export { type CustomUrlExecutorConfig, CustomUrlExecutorConfigSchema, type DefaultExecutorConfig, DefaultExecutorConfigSchema, type ExecuteToolRequest, ExecuteToolRequestSchema, type ExecuteToolResponse, ExecuteToolResponseSchema, type ExecutorConfig, ExecutorConfigSchema, type ExecutorHealthResponse, ExecutorHealthResponseSchema, type ExecutorType, ExecutorTypeSchema, type VerifyExecutorRequest, VerifyExecutorRequestSchema, type VerifyExecutorResponse };

package/dist/executor.js

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+
+// src/executor.ts
+var ExecutorTypeSchema = z.enum(["default", "custom_url"]);
+var DefaultExecutorConfigSchema = z.object({
+  type: z.literal("default")
+});
+var CustomUrlExecutorConfigSchema = z.object({
+  type: z.literal("custom_url"),
+  /** URL of the custom executor (must be HTTPS in production) */
+  url: z.string().url(),
+  /** Optional API key for Bearer token authentication */
+  apiKey: z.string().optional()
+});
+var ExecutorConfigSchema = z.discriminatedUnion("type", [
+  DefaultExecutorConfigSchema,
+  CustomUrlExecutorConfigSchema
+]);
+var ExecuteToolRequestSchema = z.object({
+  packageName: z.string().min(1),
+  name: z.string().min(1),
+  version: z.string().optional(),
+  importUrl: z.string().url().optional(),
+  params: z.record(z.string(), z.unknown()),
+  env: z.record(z.string(), z.string()).optional()
+});
+var ExecuteToolResponseSchema = z.object({
+  success: z.boolean(),
+  output: z.unknown().optional(),
+  error: z.string().optional(),
+  executionTimeMs: z.number()
+});
+var ExecutorHealthResponseSchema = z.object({
+  status: z.enum(["ok", "degraded", "error"]),
+  version: z.string().optional(),
+  info: z.record(z.string(), z.unknown()).optional()
+});
+var VerifyExecutorRequestSchema = z.object({
+  url: z.string().url(),
+  apiKey: z.string().optional()
+});
+
+export { CustomUrlExecutorConfigSchema, DefaultExecutorConfigSchema, ExecuteToolRequestSchema, ExecuteToolResponseSchema, ExecutorConfigSchema, ExecutorHealthResponseSchema, ExecutorTypeSchema, VerifyExecutorRequestSchema };

package/dist/tpmjs.d.ts

@@ -3,7 +3,7 @@ import { z } from 'zod';
 /**
  * Valid tool categories for TPMJS registry
  */
-declare const TPMJS_CATEGORIES: readonly ["research", "web", "data", "documentation", "engineering", "security", "statistics", "ops", "agent", "utilities", "html", "compliance", "web-scraping", "data-processing", "file-operations", "communication", "database", "api-integration", "image-processing", "text-analysis", "automation", "ai-ml", "monitoring", "doc", "text"];
+declare const TPMJS_CATEGORIES: readonly ["research", "web", "data", "documentation", "engineering", "security", "statistics", "ops", "agent", "sandbox", "utilities", "html", "compliance", "web-scraping", "data-processing", "file-operations", "communication", "database", "api-integration", "image-processing", "text-analysis", "automation", "ai-ml", "monitoring", "doc", "text"];
 type TpmjsCategory = (typeof TPMJS_CATEGORIES)[number];
 /**
  * Tool parameter schema
@@ -62,15 +62,13 @@ type TpmjsAiAgent = z.infer<typeof TpmjsAiAgentSchema>;
  * 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):
+ * @deprecated fields (now auto-extracted):
  * - 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>;
+declare const TpmjsToolDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
     parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
@@ -88,46 +86,7 @@ declare const TpmjsToolDefinitionSchema: z.ZodPipe<z.ZodObject<{
         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;
-}>>;
+}, z.core.$strip>;
 type TpmjsToolDefinition = z.infer<typeof TpmjsToolDefinitionSchema>;
 /**
  * Multi-tool format - NEW SCHEMA
@@ -147,6 +106,7 @@ declare const TpmjsMultiToolSchema: z.ZodObject<{
         statistics: "statistics";
         ops: "ops";
         agent: "agent";
+        sandbox: "sandbox";
         utilities: "utilities";
         html: "html";
         compliance: "compliance";
@@ -164,9 +124,8 @@ declare const TpmjsMultiToolSchema: z.ZodObject<{
         doc: "doc";
         text: "text";
     }>;
-    tools: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodObject<{
-        name: z.ZodOptional<z.ZodString>;
-        exportName: z.ZodOptional<z.ZodString>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
         description: z.ZodOptional<z.ZodString>;
         parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
             name: z.ZodString;
@@ -184,46 +143,7 @@ declare const TpmjsMultiToolSchema: z.ZodObject<{
             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;
-    }>>>>;
+    }, z.core.$strip>>>;
     env: z.ZodOptional<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         description: z.ZodString;
@@ -254,6 +174,7 @@ declare const TpmjsLegacyMinimalSchema: z.ZodObject<{
         statistics: "statistics";
         ops: "ops";
         agent: "agent";
+        sandbox: "sandbox";
         utilities: "utilities";
         html: "html";
         compliance: "compliance";
@@ -289,6 +210,7 @@ declare const TpmjsLegacyRichSchema: z.ZodObject<{
         statistics: "statistics";
         ops: "ops";
         agent: "agent";
+        sandbox: "sandbox";
         utilities: "utilities";
         html: "html";
         compliance: "compliance";
@@ -359,6 +281,7 @@ declare const TpmjsMinimalSchema: z.ZodObject<{
         statistics: "statistics";
         ops: "ops";
         agent: "agent";
+        sandbox: "sandbox";
         utilities: "utilities";
         html: "html";
         compliance: "compliance";
@@ -389,6 +312,7 @@ declare const TpmjsRichSchema: z.ZodObject<{
         statistics: "statistics";
         ops: "ops";
         agent: "agent";
+        sandbox: "sandbox";
         utilities: "utilities";
         html: "html";
         compliance: "compliance";

package/dist/tpmjs.js

@@ -12,6 +12,7 @@ var TPMJS_CATEGORIES = [
   "statistics",
   "ops",
   "agent",
+  "sandbox",
   "utilities",
   "html",
   "compliance",
@@ -55,10 +56,7 @@ var TpmjsAiAgentSchema = z.object({
 });
 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(),
+  name: z.string().min(1, "Tool name is required"),
   // 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
@@ -67,16 +65,6 @@ var TpmjsToolDefinitionSchema = z.object({
   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, {

package/dist/user.d.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+
+declare const RESERVED_USERNAMES: readonly ["admin", "api", "auth", "dashboard", "help", "support", "system", "www", "settings", "login", "logout", "register", "signup", "signin", "agents", "collections", "tools", "tool", "playground", "explore", "search", "about", "blog", "docs", "pricing", "terms", "privacy", "contact", "status", "tpmjs", "tpm", "official"];
+/**
+ * Username requirements:
+ * - 3-30 characters
+ * - Lowercase alphanumeric and hyphens only
+ * - Must start and end with alphanumeric (unless 1-2 chars)
+ * - No consecutive hyphens
+ */
+declare const USERNAME_REGEX: RegExp;
+declare const UsernameSchema: z.ZodString;
+declare const UpdateUserProfileSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    username: z.ZodOptional<z.ZodString>;
+    image: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+declare const CheckUsernameSchema: z.ZodObject<{
+    username: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+}, z.core.$strip>;
+declare const UserProfileSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    username: z.ZodNullable<z.ZodString>;
+    email: z.ZodString;
+    image: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodDate;
+}, z.core.$strip>;
+declare const PublicUserSchema: z.ZodObject<{
+    id: z.ZodString;
+    username: z.ZodString;
+    name: z.ZodString;
+    image: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+declare const UsernameAvailabilitySchema: z.ZodObject<{
+    username: z.ZodString;
+    available: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type UpdateUserProfileInput = z.infer<typeof UpdateUserProfileSchema>;
+type CheckUsernameInput = z.infer<typeof CheckUsernameSchema>;
+type UserProfile = z.infer<typeof UserProfileSchema>;
+type PublicUser = z.infer<typeof PublicUserSchema>;
+type UsernameAvailability = z.infer<typeof UsernameAvailabilitySchema>;
+/**
+ * Convert a display name to a URL-friendly username suggestion.
+ */
+declare function suggestUsername(name: string): string;
+/**
+ * Check if a username is valid (without checking availability).
+ */
+declare function isValidUsername(username: string): boolean;
+
+export { type CheckUsernameInput, CheckUsernameSchema, type PublicUser, PublicUserSchema, RESERVED_USERNAMES, USERNAME_REGEX, type UpdateUserProfileInput, UpdateUserProfileSchema, type UserProfile, UserProfileSchema, type UsernameAvailability, UsernameAvailabilitySchema, UsernameSchema, isValidUsername, suggestUsername };

package/dist/user.js

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+
+// src/user.ts
+var RESERVED_USERNAMES = [
+  // System routes
+  "admin",
+  "api",
+  "auth",
+  "dashboard",
+  "help",
+  "support",
+  "system",
+  "www",
+  "settings",
+  "login",
+  "logout",
+  "register",
+  "signup",
+  "signin",
+  // Content routes
+  "agents",
+  "collections",
+  "tools",
+  "tool",
+  "playground",
+  "explore",
+  "search",
+  // Reserved for future
+  "about",
+  "blog",
+  "docs",
+  "pricing",
+  "terms",
+  "privacy",
+  "contact",
+  "status",
+  // Brand/official
+  "tpmjs",
+  "tpm",
+  "official"
+];
+var USERNAME_REGEX = /^[a-z0-9](?:[a-z0-9]|(?:-(?!-))){1,28}[a-z0-9]$|^[a-z0-9]{1,2}$/;
+var UsernameSchema = z.string().min(3, "Username must be at least 3 characters").max(30, "Username must be 30 characters or less").regex(USERNAME_REGEX, "Username must be lowercase, alphanumeric, with single hyphens only").refine(
+  (val) => !RESERVED_USERNAMES.includes(val),
+  "This username is reserved"
+);
+var UpdateUserProfileSchema = z.object({
+  name: z.string().min(1, "Name is required").max(100).optional(),
+  username: UsernameSchema.optional(),
+  image: z.string().url("Invalid image URL").nullable().optional()
+});
+var CheckUsernameSchema = z.object({
+  username: z.string().min(3, "Username must be at least 3 characters").max(30, "Username must be 30 characters or less").transform((val) => val.toLowerCase())
+});
+var UserProfileSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  username: z.string().nullable(),
+  email: z.string().email(),
+  image: z.string().nullable(),
+  createdAt: z.date()
+});
+var PublicUserSchema = z.object({
+  id: z.string(),
+  username: z.string(),
+  name: z.string(),
+  image: z.string().nullable()
+});
+var UsernameAvailabilitySchema = z.object({
+  username: z.string(),
+  available: z.boolean(),
+  reason: z.string().optional()
+});
+function suggestUsername(name) {
+  return name.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").slice(0, 30);
+}
+function isValidUsername(username) {
+  return UsernameSchema.safeParse(username).success;
+}
+
+export { CheckUsernameSchema, PublicUserSchema, RESERVED_USERNAMES, USERNAME_REGEX, UpdateUserProfileSchema, UserProfileSchema, UsernameAvailabilitySchema, UsernameSchema, isValidUsername, suggestUsername };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tpmjs/types",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Shared TypeScript types and Zod schemas for TPMJS",
   "author": "TPMJS",
   "license": "MIT",
@@ -30,16 +30,32 @@
     "./tpmjs": {
       "types": "./dist/tpmjs.d.ts",
       "default": "./dist/tpmjs.js"
+    },
+    "./collection": {
+      "types": "./dist/collection.d.ts",
+      "default": "./dist/collection.js"
+    },
+    "./agent": {
+      "types": "./dist/agent.d.ts",
+      "default": "./dist/agent.js"
+    },
+    "./user": {
+      "types": "./dist/user.d.ts",
+      "default": "./dist/user.js"
+    },
+    "./executor": {
+      "types": "./dist/executor.d.ts",
+      "default": "./dist/executor.js"
     }
   },
   "files": [
     "dist"
   ],
   "dependencies": {
-    "zod": "^4.1.13"
+    "zod": "^4.3.5"
   },
   "devDependencies": {
-    "tsup": "^8.3.5",
+    "tsup": "^8.5.1",
     "typescript": "^5.9.3",
     "@tpmjs/tsconfig": "0.0.0"
   },