@v0-sdk/ai-tools 0.3.7 → 3.0.0-canary.bf3a020

package/dist/index.js

@@ -1,1021 +0,0 @@
-import { tool } from 'ai';
-import { z } from 'zod';
-import { createClient } from 'v0-sdk';
-
-/**
- * Creates chat-related AI SDK tools
- */ function createChatTools(config = {}) {
-    const client = createClient(config);
-    const createChat = tool({
-        description: 'Create a new chat with v0',
-        inputSchema: z.object({
-            message: z.string().describe('The initial message to start the chat'),
-            system: z.string().optional().describe('System prompt for the chat'),
-            attachments: z.array(z.object({
-                url: z.string().describe('URL of the attachment')
-            })).optional().describe('File attachments for the chat'),
-            chatPrivacy: z.enum([
-                'public',
-                'private',
-                'team-edit',
-                'team',
-                'unlisted'
-            ]).optional().describe('Privacy setting for the chat'),
-            projectId: z.string().optional().describe('Project ID to associate with the chat'),
-            modelConfiguration: z.object({
-                modelId: z.enum([
-                    'v0-mini',
-                    'v0-pro',
-                    'v0-max',
-                    'v0-max-fast'
-                ]).describe('Model to use for the chat'),
-                imageGenerations: z.boolean().optional().describe('Enable image generations'),
-                thinking: z.boolean().optional().describe('Enable thinking mode')
-            }).optional().describe('Model configuration for the chat'),
-            responseMode: z.enum([
-                'sync',
-                'async'
-            ]).optional().describe('Response mode for the chat')
-        }),
-        execute: async ({ message, system, attachments, chatPrivacy, projectId, modelConfiguration, responseMode })=>{
-            const result = await client.chats.create({
-                message,
-                system,
-                attachments,
-                chatPrivacy,
-                projectId,
-                modelConfiguration,
-                responseMode
-            });
-            // Handle streaming vs non-streaming responses
-            if (result instanceof ReadableStream) {
-                return {
-                    chatId: 'streaming-chat',
-                    webUrl: 'N/A (streaming response)',
-                    apiUrl: 'N/A (streaming response)',
-                    privacy: 'N/A (streaming response)',
-                    name: 'N/A (streaming response)',
-                    favorite: false,
-                    latestVersion: 'N/A (streaming response)',
-                    createdAt: 'N/A (streaming response)'
-                };
-            }
-            return {
-                chatId: result.id,
-                webUrl: result.webUrl,
-                apiUrl: result.apiUrl,
-                privacy: result.privacy,
-                name: result.name,
-                favorite: result.favorite,
-                latestVersion: result.latestVersion,
-                createdAt: result.createdAt
-            };
-        }
-    });
-    const sendMessage = tool({
-        description: 'Send a message to an existing chat',
-        inputSchema: z.object({
-            chatId: z.string().describe('ID of the chat to send message to'),
-            message: z.string().describe('Message content to send'),
-            attachments: z.array(z.object({
-                url: z.string().describe('URL of the attachment')
-            })).optional().describe('File attachments for the message'),
-            modelConfiguration: z.object({
-                modelId: z.enum([
-                    'v0-mini',
-                    'v0-pro',
-                    'v0-max',
-                    'v0-max-fast'
-                ]).describe('Model to use'),
-                imageGenerations: z.boolean().optional().describe('Enable image generations'),
-                thinking: z.boolean().optional().describe('Enable thinking mode')
-            }).optional().describe('Model configuration'),
-            responseMode: z.enum([
-                'sync',
-                'async'
-            ]).optional().describe('Response mode')
-        }),
-        execute: async ({ chatId, message, attachments, modelConfiguration, responseMode })=>{
-            const result = await client.chats.sendMessage({
-                chatId,
-                message,
-                attachments,
-                modelConfiguration,
-                responseMode
-            });
-            // Handle streaming vs non-streaming responses
-            if (result instanceof ReadableStream) {
-                return {
-                    chatId: 'streaming-chat',
-                    webUrl: 'N/A (streaming response)',
-                    latestVersion: 'N/A (streaming response)',
-                    updatedAt: 'N/A (streaming response)'
-                };
-            }
-            return {
-                chatId: result.id,
-                webUrl: result.webUrl,
-                latestVersion: result.latestVersion,
-                updatedAt: result.updatedAt
-            };
-        }
-    });
-    const getChat = tool({
-        description: 'Get details of an existing chat',
-        inputSchema: z.object({
-            chatId: z.string().describe('ID of the chat to retrieve')
-        }),
-        execute: async (params)=>{
-            const { chatId } = params;
-            const result = await client.chats.getById({
-                chatId
-            });
-            return {
-                chatId: result.id,
-                name: result.name,
-                privacy: result.privacy,
-                webUrl: result.webUrl,
-                favorite: result.favorite,
-                createdAt: result.createdAt,
-                updatedAt: result.updatedAt,
-                latestVersion: result.latestVersion,
-                messagesCount: result.messages.length
-            };
-        }
-    });
-    const updateChat = tool({
-        description: 'Update properties of an existing chat',
-        inputSchema: z.object({
-            chatId: z.string().describe('ID of the chat to update'),
-            name: z.string().optional().describe('New name for the chat'),
-            privacy: z.enum([
-                'public',
-                'private',
-                'team',
-                'team-edit',
-                'unlisted'
-            ]).optional().describe('New privacy setting')
-        }),
-        execute: async (params)=>{
-            const { chatId, name, privacy } = params;
-            const result = await client.chats.update({
-                chatId,
-                name,
-                privacy
-            });
-            return {
-                chatId: result.id,
-                name: result.name,
-                privacy: result.privacy,
-                updatedAt: result.updatedAt
-            };
-        }
-    });
-    const deleteChat = tool({
-        description: 'Delete an existing chat',
-        inputSchema: z.object({
-            chatId: z.string().describe('ID of the chat to delete')
-        }),
-        execute: async (params)=>{
-            const { chatId } = params;
-            const result = await client.chats.delete({
-                chatId
-            });
-            return {
-                chatId: result.id,
-                deleted: result.deleted
-            };
-        }
-    });
-    const favoriteChat = tool({
-        description: 'Toggle favorite status of a chat',
-        inputSchema: z.object({
-            chatId: z.string().describe('ID of the chat'),
-            isFavorite: z.boolean().describe('Whether to mark as favorite or not')
-        }),
-        execute: async (params)=>{
-            const { chatId, isFavorite } = params;
-            const result = await client.chats.favorite({
-                chatId,
-                isFavorite
-            });
-            return {
-                chatId: result.id,
-                favorited: result.favorited
-            };
-        }
-    });
-    const forkChat = tool({
-        description: 'Fork an existing chat to create a new version',
-        inputSchema: z.object({
-            chatId: z.string().describe('ID of the chat to fork'),
-            versionId: z.string().optional().describe('Specific version ID to fork from'),
-            privacy: z.enum([
-                'public',
-                'private',
-                'team',
-                'team-edit',
-                'unlisted'
-            ]).optional().describe('Privacy setting for the forked chat')
-        }),
-        execute: async (params)=>{
-            const { chatId, versionId, privacy } = params;
-            const result = await client.chats.fork({
-                chatId,
-                versionId,
-                privacy
-            });
-            return {
-                originalChatId: chatId,
-                newChatId: result.id,
-                webUrl: result.webUrl,
-                privacy: result.privacy,
-                createdAt: result.createdAt
-            };
-        }
-    });
-    const listChats = tool({
-        description: 'List all chats',
-        inputSchema: z.object({
-            limit: z.number().optional().describe('Number of chats to return'),
-            offset: z.number().optional().describe('Offset for pagination'),
-            isFavorite: z.boolean().optional().describe('Filter by favorite status')
-        }),
-        execute: async (params)=>{
-            const { limit, offset, isFavorite } = params;
-            const result = await client.chats.find({
-                limit,
-                offset,
-                isFavorite
-            });
-            return {
-                chats: result.data.map((chat)=>({
-                        chatId: chat.id,
-                        name: chat.name,
-                        privacy: chat.privacy,
-                        webUrl: chat.webUrl,
-                        favorite: chat.favorite,
-                        createdAt: chat.createdAt,
-                        updatedAt: chat.updatedAt
-                    }))
-            };
-        }
-    });
-    return {
-        createChat,
-        sendMessage,
-        getChat,
-        updateChat,
-        deleteChat,
-        favoriteChat,
-        forkChat,
-        listChats
-    };
-}
-
-/**
- * Creates project-related AI SDK tools
- */ function createProjectTools(config = {}) {
-    const client = createClient(config);
-    const createProject = tool({
-        description: 'Create a new project in v0',
-        inputSchema: z.object({
-            name: z.string().describe('Name of the project'),
-            description: z.string().optional().describe('Description of the project'),
-            icon: z.string().optional().describe('Icon for the project'),
-            environmentVariables: z.array(z.object({
-                key: z.string().describe('Environment variable key'),
-                value: z.string().describe('Environment variable value')
-            })).optional().describe('Environment variables for the project'),
-            instructions: z.string().optional().describe('Custom instructions for the project'),
-            vercelProjectId: z.string().optional().describe('Associated Vercel project ID'),
-            privacy: z.enum([
-                'private',
-                'team'
-            ]).optional().describe('Privacy setting for the project')
-        }),
-        execute: async ({ name, description, icon, environmentVariables, instructions, vercelProjectId, privacy })=>{
-            const result = await client.projects.create({
-                name,
-                description,
-                icon,
-                environmentVariables,
-                instructions,
-                vercelProjectId,
-                privacy
-            });
-            return {
-                projectId: result.id,
-                name: result.name,
-                description: result.description,
-                privacy: result.privacy,
-                webUrl: result.webUrl,
-                apiUrl: result.apiUrl,
-                createdAt: result.createdAt,
-                vercelProjectId: result.vercelProjectId
-            };
-        }
-    });
-    const getProject = tool({
-        description: 'Get details of an existing project',
-        inputSchema: z.object({
-            projectId: z.string().describe('ID of the project to retrieve')
-        }),
-        execute: async (params)=>{
-            const { projectId } = params;
-            const result = await client.projects.getById({
-                projectId
-            });
-            return {
-                projectId: result.id,
-                name: result.name,
-                description: result.description,
-                instructions: result.instructions,
-                privacy: result.privacy,
-                webUrl: result.webUrl,
-                apiUrl: result.apiUrl,
-                createdAt: result.createdAt,
-                updatedAt: result.updatedAt,
-                vercelProjectId: result.vercelProjectId,
-                chatsCount: result.chats.length
-            };
-        }
-    });
-    const updateProject = tool({
-        description: 'Update properties of an existing project',
-        inputSchema: z.object({
-            projectId: z.string().describe('ID of the project to update'),
-            name: z.string().optional().describe('New name for the project'),
-            description: z.string().optional().describe('New description for the project'),
-            instructions: z.string().optional().describe('New instructions for the project'),
-            privacy: z.enum([
-                'private',
-                'team'
-            ]).optional().describe('New privacy setting')
-        }),
-        execute: async ({ projectId, name, description, instructions, privacy })=>{
-            const result = await client.projects.update({
-                projectId,
-                name,
-                description,
-                instructions,
-                privacy
-            });
-            return {
-                projectId: result.id,
-                name: result.name,
-                description: result.description,
-                instructions: result.instructions,
-                privacy: result.privacy,
-                updatedAt: result.updatedAt
-            };
-        }
-    });
-    const listProjects = tool({
-        description: 'List all projects',
-        inputSchema: z.object({}),
-        execute: async ()=>{
-            const result = await client.projects.find();
-            return {
-                projects: result.data.map((project)=>({
-                        projectId: project.id,
-                        name: project.name,
-                        privacy: project.privacy,
-                        webUrl: project.webUrl,
-                        createdAt: project.createdAt,
-                        updatedAt: project.updatedAt,
-                        vercelProjectId: project.vercelProjectId
-                    }))
-            };
-        }
-    });
-    const assignChatToProject = tool({
-        description: 'Assign a chat to a project',
-        inputSchema: z.object({
-            projectId: z.string().describe('ID of the project'),
-            chatId: z.string().describe('ID of the chat to assign')
-        }),
-        execute: async (params)=>{
-            const { projectId, chatId } = params;
-            const result = await client.projects.assign({
-                projectId,
-                chatId
-            });
-            return {
-                projectId: result.id,
-                assigned: result.assigned
-            };
-        }
-    });
-    const getProjectByChat = tool({
-        description: 'Get project details by chat ID',
-        inputSchema: z.object({
-            chatId: z.string().describe('ID of the chat')
-        }),
-        execute: async (params)=>{
-            const { chatId } = params;
-            const result = await client.projects.getByChatId({
-                chatId
-            });
-            return {
-                projectId: result.id,
-                name: result.name,
-                description: result.description,
-                privacy: result.privacy,
-                webUrl: result.webUrl,
-                createdAt: result.createdAt,
-                chatsCount: result.chats.length
-            };
-        }
-    });
-    // Environment Variables Tools
-    const createEnvironmentVariables = tool({
-        description: 'Create environment variables for a project',
-        inputSchema: z.object({
-            projectId: z.string().describe('ID of the project'),
-            environmentVariables: z.array(z.object({
-                key: z.string().describe('Environment variable key'),
-                value: z.string().describe('Environment variable value')
-            })).describe('Environment variables to create'),
-            upsert: z.boolean().optional().describe('Whether to upsert existing variables'),
-            decrypted: z.boolean().optional().describe('Whether to return decrypted values')
-        }),
-        execute: async (params)=>{
-            const { projectId, environmentVariables, upsert, decrypted } = params;
-            const result = await client.projects.createEnvVars({
-                projectId,
-                environmentVariables,
-                upsert,
-                decrypted
-            });
-            return {
-                environmentVariables: result.data.map((envVar)=>({
-                        id: envVar.id,
-                        key: envVar.key,
-                        value: envVar.value,
-                        decrypted: envVar.decrypted,
-                        createdAt: envVar.createdAt
-                    }))
-            };
-        }
-    });
-    const listEnvironmentVariables = tool({
-        description: 'List environment variables for a project',
-        inputSchema: z.object({
-            projectId: z.string().describe('ID of the project'),
-            decrypted: z.boolean().optional().describe('Whether to return decrypted values')
-        }),
-        execute: async (params)=>{
-            const { projectId, decrypted } = params;
-            const result = await client.projects.findEnvVars({
-                projectId,
-                decrypted
-            });
-            return {
-                environmentVariables: result.data.map((envVar)=>({
-                        id: envVar.id,
-                        key: envVar.key,
-                        value: envVar.value,
-                        decrypted: envVar.decrypted,
-                        createdAt: envVar.createdAt,
-                        updatedAt: envVar.updatedAt
-                    }))
-            };
-        }
-    });
-    const updateEnvironmentVariables = tool({
-        description: 'Update environment variables for a project',
-        inputSchema: z.object({
-            projectId: z.string().describe('ID of the project'),
-            environmentVariables: z.array(z.object({
-                id: z.string().describe('Environment variable ID'),
-                value: z.string().describe('New environment variable value')
-            })).describe('Environment variables to update'),
-            decrypted: z.boolean().optional().describe('Whether to return decrypted values')
-        }),
-        execute: async (params)=>{
-            const { projectId, environmentVariables, decrypted } = params;
-            const result = await client.projects.updateEnvVars({
-                projectId,
-                environmentVariables,
-                decrypted
-            });
-            return {
-                environmentVariables: result.data.map((envVar)=>({
-                        id: envVar.id,
-                        key: envVar.key,
-                        value: envVar.value,
-                        decrypted: envVar.decrypted,
-                        updatedAt: envVar.updatedAt
-                    }))
-            };
-        }
-    });
-    const deleteEnvironmentVariables = tool({
-        description: 'Delete environment variables from a project',
-        inputSchema: z.object({
-            projectId: z.string().describe('ID of the project'),
-            environmentVariableIds: z.array(z.string()).describe('IDs of environment variables to delete')
-        }),
-        execute: async (params)=>{
-            const { projectId, environmentVariableIds } = params;
-            const result = await client.projects.deleteEnvVars({
-                projectId,
-                environmentVariableIds
-            });
-            return {
-                deletedVariables: result.data.map((envVar)=>({
-                        id: envVar.id,
-                        deleted: envVar.deleted
-                    }))
-            };
-        }
-    });
-    return {
-        createProject,
-        getProject,
-        updateProject,
-        listProjects,
-        assignChatToProject,
-        getProjectByChat,
-        createEnvironmentVariables,
-        listEnvironmentVariables,
-        updateEnvironmentVariables,
-        deleteEnvironmentVariables
-    };
-}
-
-/**
- * Creates deployment-related AI SDK tools
- */ function createDeploymentTools(config = {}) {
-    const client = createClient(config);
-    const createDeployment = tool({
-        description: 'Create a new deployment from a chat version',
-        inputSchema: z.object({
-            projectId: z.string().describe('ID of the project to deploy to'),
-            chatId: z.string().describe('ID of the chat to deploy'),
-            versionId: z.string().describe('ID of the specific version to deploy')
-        }),
-        execute: async (params)=>{
-            const { projectId, chatId, versionId } = params;
-            const result = await client.deployments.create({
-                projectId,
-                chatId,
-                versionId
-            });
-            return {
-                deploymentId: result.id,
-                projectId: result.projectId,
-                chatId: result.chatId,
-                versionId: result.versionId,
-                inspectorUrl: result.inspectorUrl,
-                webUrl: result.webUrl,
-                apiUrl: result.apiUrl
-            };
-        }
-    });
-    const getDeployment = tool({
-        description: 'Get details of an existing deployment',
-        inputSchema: z.object({
-            deploymentId: z.string().describe('ID of the deployment to retrieve')
-        }),
-        execute: async (params)=>{
-            const { deploymentId } = params;
-            const result = await client.deployments.getById({
-                deploymentId
-            });
-            return {
-                deploymentId: result.id,
-                projectId: result.projectId,
-                chatId: result.chatId,
-                versionId: result.versionId,
-                inspectorUrl: result.inspectorUrl,
-                webUrl: result.webUrl,
-                apiUrl: result.apiUrl
-            };
-        }
-    });
-    const deleteDeployment = tool({
-        description: 'Delete an existing deployment',
-        inputSchema: z.object({
-            deploymentId: z.string().describe('ID of the deployment to delete')
-        }),
-        execute: async (params)=>{
-            const { deploymentId } = params;
-            const result = await client.deployments.delete({
-                deploymentId
-            });
-            return {
-                deploymentId: result.id,
-                deleted: result.deleted
-            };
-        }
-    });
-    const listDeployments = tool({
-        description: 'List deployments by project, chat, and version',
-        inputSchema: z.object({
-            projectId: z.string().describe('ID of the project'),
-            chatId: z.string().describe('ID of the chat'),
-            versionId: z.string().describe('ID of the version')
-        }),
-        execute: async (params)=>{
-            const { projectId, chatId, versionId } = params;
-            const result = await client.deployments.find({
-                projectId,
-                chatId,
-                versionId
-            });
-            return {
-                deployments: result.data.map((deployment)=>({
-                        deploymentId: deployment.id,
-                        projectId: deployment.projectId,
-                        chatId: deployment.chatId,
-                        versionId: deployment.versionId,
-                        inspectorUrl: deployment.inspectorUrl,
-                        webUrl: deployment.webUrl,
-                        apiUrl: deployment.apiUrl
-                    }))
-            };
-        }
-    });
-    const getDeploymentLogs = tool({
-        description: 'Get logs for a deployment',
-        inputSchema: z.object({
-            deploymentId: z.string().describe('ID of the deployment'),
-            since: z.number().optional().describe('Timestamp to get logs since')
-        }),
-        execute: async (params)=>{
-            const { deploymentId, since } = params;
-            const result = await client.deployments.findLogs({
-                deploymentId,
-                since
-            });
-            return {
-                logs: result.logs,
-                nextSince: result.nextSince
-            };
-        }
-    });
-    const getDeploymentErrors = tool({
-        description: 'Get errors for a deployment',
-        inputSchema: z.object({
-            deploymentId: z.string().describe('ID of the deployment')
-        }),
-        execute: async (params)=>{
-            const { deploymentId } = params;
-            const result = await client.deployments.findErrors({
-                deploymentId
-            });
-            return {
-                fullErrorText: result.fullErrorText,
-                errorType: result.errorType,
-                formattedError: result.formattedError
-            };
-        }
-    });
-    return {
-        createDeployment,
-        getDeployment,
-        deleteDeployment,
-        listDeployments,
-        getDeploymentLogs,
-        getDeploymentErrors
-    };
-}
-
-/**
- * Creates user-related AI SDK tools
- */ function createUserTools(config = {}) {
-    const client = createClient(config);
-    const getCurrentUser = tool({
-        description: 'Get current user information',
-        inputSchema: z.object({}),
-        execute: async ()=>{
-            const result = await client.user.get();
-            return {
-                userId: result.id,
-                name: result.name,
-                email: result.email,
-                avatar: result.avatar
-            };
-        }
-    });
-    const getUserBilling = tool({
-        description: 'Get current user billing information',
-        inputSchema: z.object({
-            scope: z.string().optional().describe('Scope for billing information')
-        }),
-        execute: async (params)=>{
-            const { scope } = params;
-            const result = await client.user.getBilling({
-                scope
-            });
-            if (result.billingType === 'token') {
-                return {
-                    billingType: result.billingType,
-                    plan: result.data.plan,
-                    role: result.data.role,
-                    billingMode: result.data.billingMode,
-                    billingCycle: {
-                        start: result.data.billingCycle.start,
-                        end: result.data.billingCycle.end
-                    },
-                    balance: {
-                        remaining: result.data.balance.remaining,
-                        total: result.data.balance.total
-                    },
-                    onDemand: {
-                        balance: result.data.onDemand.balance,
-                        blocks: result.data.onDemand.blocks
-                    }
-                };
-            } else {
-                return {
-                    billingType: result.billingType,
-                    remaining: result.data.remaining,
-                    reset: result.data.reset,
-                    limit: result.data.limit
-                };
-            }
-        }
-    });
-    const getUserPlan = tool({
-        description: 'Get current user plan information',
-        inputSchema: z.object({}),
-        execute: async ()=>{
-            const result = await client.user.getPlan();
-            return {
-                plan: result.plan,
-                billingCycle: {
-                    start: result.billingCycle.start,
-                    end: result.billingCycle.end
-                },
-                balance: {
-                    remaining: result.balance.remaining,
-                    total: result.balance.total
-                }
-            };
-        }
-    });
-    const getUserScopes = tool({
-        description: 'Get user scopes/permissions',
-        inputSchema: z.object({}),
-        execute: async ()=>{
-            const result = await client.user.getScopes();
-            return {
-                scopes: result.data.map((scope)=>({
-                        id: scope.id,
-                        name: scope.name
-                    }))
-            };
-        }
-    });
-    const getRateLimits = tool({
-        description: 'Get current rate limit information',
-        inputSchema: z.object({
-            scope: z.string().optional().describe('Scope for rate limit information')
-        }),
-        execute: async (params)=>{
-            const { scope } = params;
-            const result = await client.rateLimits.find({
-                scope
-            });
-            return {
-                remaining: result.remaining,
-                reset: result.reset,
-                limit: result.limit
-            };
-        }
-    });
-    return {
-        getCurrentUser,
-        getUserBilling,
-        getUserPlan,
-        getUserScopes,
-        getRateLimits
-    };
-}
-
-/**
- * Creates webhook-related AI SDK tools
- */ function createHookTools(config = {}) {
-    const client = createClient(config);
-    const createHook = tool({
-        description: 'Create a new webhook for v0 events',
-        inputSchema: z.object({
-            name: z.string().describe('Name of the webhook'),
-            url: z.string().describe('URL to send webhook events to'),
-            events: z.array(z.enum([
-                'chat.created',
-                'chat.updated',
-                'chat.deleted',
-                'message.created',
-                'message.updated',
-                'message.deleted'
-            ])).describe('Events to listen for'),
-            chatId: z.string().optional().describe('Specific chat ID to listen to events for')
-        }),
-        execute: async (params)=>{
-            const { name, url, events, chatId } = params;
-            const result = await client.hooks.create({
-                name,
-                url,
-                events,
-                chatId
-            });
-            return {
-                hookId: result.id,
-                name: result.name,
-                url: result.url,
-                events: result.events,
-                chatId: result.chatId
-            };
-        }
-    });
-    const getHook = tool({
-        description: 'Get details of an existing webhook',
-        inputSchema: z.object({
-            hookId: z.string().describe('ID of the webhook to retrieve')
-        }),
-        execute: async (params)=>{
-            const { hookId } = params;
-            const result = await client.hooks.getById({
-                hookId
-            });
-            return {
-                hookId: result.id,
-                name: result.name,
-                url: result.url,
-                events: result.events,
-                chatId: result.chatId
-            };
-        }
-    });
-    const updateHook = tool({
-        description: 'Update properties of an existing webhook',
-        inputSchema: z.object({
-            hookId: z.string().describe('ID of the webhook to update'),
-            name: z.string().optional().describe('New name for the webhook'),
-            url: z.string().optional().describe('New URL for the webhook'),
-            events: z.array(z.enum([
-                'chat.created',
-                'chat.updated',
-                'chat.deleted',
-                'message.created',
-                'message.updated',
-                'message.deleted'
-            ])).optional().describe('New events to listen for')
-        }),
-        execute: async (params)=>{
-            const { hookId, name, url, events } = params;
-            const result = await client.hooks.update({
-                hookId,
-                name,
-                url,
-                events
-            });
-            return {
-                hookId: result.id,
-                name: result.name,
-                url: result.url,
-                events: result.events,
-                chatId: result.chatId
-            };
-        }
-    });
-    const deleteHook = tool({
-        description: 'Delete an existing webhook',
-        inputSchema: z.object({
-            hookId: z.string().describe('ID of the webhook to delete')
-        }),
-        execute: async (params)=>{
-            const { hookId } = params;
-            const result = await client.hooks.delete({
-                hookId
-            });
-            return {
-                hookId: result.id,
-                deleted: result.deleted
-            };
-        }
-    });
-    const listHooks = tool({
-        description: 'List all webhooks',
-        inputSchema: z.object({}),
-        execute: async ()=>{
-            const result = await client.hooks.find();
-            return {
-                hooks: result.data.map((hook)=>({
-                        hookId: hook.id,
-                        name: hook.name
-                    }))
-            };
-        }
-    });
-    return {
-        createHook,
-        getHook,
-        updateHook,
-        deleteHook,
-        listHooks
-    };
-}
-
-/**
- * Creates all v0 AI SDK tools as a flat object.
- *
- * ⚠️ Note: This includes ALL available tools (~20+ tools) which adds significant context.
- * Consider using v0ToolsByCategory() to select only the tools you need.
- *
- * @param config Configuration for v0 client
- * @returns Flat object with all v0 tools ready to use with AI SDK
- *
- * @example
- * ```typescript
- * import { generateText } from 'ai'
- * import { v0Tools } from '@v0-sdk/ai-tools'
- *
- * const result = await generateText({
- *   model: 'openai/gpt-4',
- *   prompt: 'Create a new React component',
- *   tools: v0Tools({
- *     apiKey: process.env.V0_API_KEY
- *   })
- * })
- * ```
- */ function v0Tools(config = {}) {
-    // Use environment variable if apiKey not provided
-    const clientConfig = {
-        ...config,
-        apiKey: config.apiKey || process.env.V0_API_KEY
-    };
-    const chatTools = createChatTools(clientConfig);
-    const projectTools = createProjectTools(clientConfig);
-    const deploymentTools = createDeploymentTools(clientConfig);
-    const userTools = createUserTools(clientConfig);
-    const hookTools = createHookTools(clientConfig);
-    return {
-        ...chatTools,
-        ...projectTools,
-        ...deploymentTools,
-        ...userTools,
-        ...hookTools
-    };
-}
-/**
- * Creates v0 tools organized by category for selective usage (recommended).
- * This allows you to include only the tools you need, reducing context size.
- *
- * @param config Configuration for v0 client
- * @returns Object containing all v0 tools organized by category
- *
- * @example
- * ```typescript
- * import { generateText } from 'ai'
- * import { v0ToolsByCategory } from '@v0-sdk/ai-tools'
- *
- * const tools = v0ToolsByCategory({
- *   apiKey: process.env.V0_API_KEY
- * })
- *
- * // Only include chat and project tools
- * const result = await generateText({
- *   model: 'openai/gpt-4',
- *   prompt: 'Create a new React component',
- *   tools: {
- *     ...tools.chat,
- *     ...tools.project
- *   }
- * })
- * ```
- */ function v0ToolsByCategory(config = {}) {
-    // Use environment variable if apiKey not provided
-    const clientConfig = {
-        ...config,
-        apiKey: config.apiKey || process.env.V0_API_KEY
-    };
-    return {
-        /**
-     * Chat-related tools for creating, managing, and interacting with v0 chats
-     */ chat: createChatTools(clientConfig),
-        /**
-     * Project-related tools for creating and managing v0 projects
-     */ project: createProjectTools(clientConfig),
-        /**
-     * Deployment-related tools for creating and managing deployments
-     */ deployment: createDeploymentTools(clientConfig),
-        /**
-     * User-related tools for getting user information, billing, and rate limits
-     */ user: createUserTools(clientConfig),
-        /**
-     * Webhook tools for creating and managing event hooks
-     */ hook: createHookTools(clientConfig)
-    };
-}
-/**
- * @deprecated Use v0Tools instead (now returns flat structure by default)
- */ function v0ToolsFlat(config = {}) {
-    return v0Tools(config);
-}
-
-export { createChatTools, createDeploymentTools, createHookTools, createProjectTools, createUserTools, v0Tools as default, v0Tools, v0ToolsByCategory, v0ToolsFlat };