@v0-sdk/ai-tools 0.1.0

package/dist/index.js

@@ -0,0 +1,1003 @@
+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-1.5-sm',
+                    'v0-1.5-md',
+                    'v0-1.5-lg',
+                    'v0-gpt-5'
+                ]).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
+            });
+            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-1.5-sm',
+                    'v0-1.5-md',
+                    'v0-1.5-lg',
+                    'v0-gpt-5'
+                ]).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
+            });
+            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.string().optional().describe('Number of chats to return'),
+            offset: z.string().optional().describe('Offset for pagination'),
+            isFavorite: z.string().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.string().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.string().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.string().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.string().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,
+                error: result.error,
+                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 {
+                error: result.error,
+                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 { openai } from '@ai-sdk/openai'
+ * 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 { openai } from '@ai-sdk/openai'
+ * 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 };