v0-sdk 0.0.4 → 0.0.6

package/README.md

@@ -1,10 +1,21 @@
-### v0 Chats API Client
+# v0 Chat SDK
 
-A lightweight client for interacting with the v0 Chats API to create and manage AI-powered chat conversations.
+A TypeScript SDK for interacting with the v0 API to create and manage AI-powered chat conversations, projects, integrations, and more.
+
+## Features
+
+- Full TypeScript support with complete type definitions
+- Chat management - Create, manage, and interact with AI chats
+- Project operations - Create and manage v0 projects
+- Vercel integrations - Seamless Vercel project integration
+- User management - Access user information and billing
+- Deployment logs - Monitor and retrieve deployment information
+- Comprehensive testing - Extensive test coverage for all functions
+- Error handling - Robust error handling with detailed error types
 
 ## Installation
 
-```shellscript
+```bash
 npm install v0-sdk
 # or
 yarn add v0-sdk
@@ -14,25 +25,23 @@ pnpm add v0-sdk
 
 ## Quick Start
 
-Get your API key from [v0.dev/chat/settings/keys](https://v0.dev/chat/settings/keys) and start creating chats.
-
-```javascript
-import { V0Client } from 'v0-sdk'
+Get your API key from [v0.dev/chat/settings/keys](https://v0.dev/chat/settings/keys).
 
-// Initialize with your API key
-const client = new V0Client('your_v0_api_key')
+```typescript
+import { v0 } from 'v0-sdk'
 
 // Create a new chat
-const chat = await client.createChat({
+const chat = await v0.chats.create({
   message: 'Create a responsive navbar with Tailwind CSS',
   system: 'You are an expert React developer',
 })
 
 console.log(`Chat created: ${chat.url}`)
-console.log(`Generated code: ${chat.files.length} files`)
+console.log(`Generated code: ${chat.files?.length} files`)
 
 // Add a message to the chat
-const response = await client.addMessage(chat.chatId, {
+const response = await v0.chats.createMessage({
+  chatId: chat.chatId,
   message: 'Add a dropdown menu to the navbar',
 })
 
@@ -43,22 +52,24 @@ console.log(`AI response: ${response.text}`)
 
 The client requires a v0 API key, which you can create at [v0.dev/chat/settings/keys](https://v0.dev/chat/settings/keys).
 
-```javascript
-// Initialize with API key
-const client = new V0Client('your_v0_api_key')
+```typescript
+// Set your API key as an environment variable
+process.env.V0_API_KEY = 'your_v0_api_key'
 
-// Or set it later
-client.setApiKey('your_v0_api_key')
+// Or pass custom base URL
+// The SDK will automatically use the V0_API_KEY environment variable
 ```
 
 ## API Reference
 
-### Create a Chat
+### Chat Operations
+
+#### Create a Chat
 
 Create a new chat conversation with the AI.
 
-```javascript
-const result = await client.createChat({
+```typescript
+const result = await v0.chats.create({
   message: 'Create a login form with validation',
   system: 'You are an expert in React and form validation',
   chatPrivacy: 'private',
@@ -70,95 +81,196 @@ const result = await client.createChat({
 })
 ```
 
-**Response:**
+#### Get Chat by ID
 
-```javascript
-{
-  chatId: 'abc123',
-  url: 'https://v0.dev/chat/abc123',
-  text: 'I'll create a login form with validation...',
-  files: [
-    {
-      name: 'login-form.tsx',
-      content: '...',
-      type: 'component'
-    }
-  ],
-  demo: 'https://v0.dev/demo/abc123'
-}
+```typescript
+const chat = await v0.chats.getById({ chatId: 'chat_id' })
+console.log(chat.messages) // Fully typed message array
 ```
 
-### Add a Message
+#### Manage Chat Favorites
+
+```typescript
+// Favorite a chat
+await v0.chats.favorite({ chatId: 'chat_id' })
+
+// Unfavorite a chat
+await v0.chats.unfavorite({ chatId: 'chat_id' })
+
+// Get favorite chats
+const favorites = await v0.chats.find()
+```
+
+#### Chat History and Management
+
+```typescript
+// Get chat history
+const chats = await v0.chats.find()
 
-Add a message to an existing chat.
+// Delete a chat
+await v0.chats.delete({ chatId: 'chat_id' })
 
-```javascript
-const response = await client.addMessage('abc123', {
+// Get chat's associated project
+const project = await v0.chats.getProject({ chatId: 'chat_id' })
+```
+
+#### Add Messages to Chat
+
+```typescript
+const response = await v0.chats.createMessage({
+  chatId: 'chat_id',
   message: 'Add password strength indicator',
   attachments: [{ url: 'https://example.com/mockup.jpg' }],
-  modelConfiguration: {},
+  modelConfiguration: {
+    imageGenerations: true
+  },
 })
 ```
 
-### Get Chat History
+#### Get Version Frame Token
 
-Coming soon
+```typescript
+const token = await v0.chats.getVersionFrameToken({ 
+  chatId: 'chat_id', 
+  versionId: 'version_id' 
+})
+```
 
-## Working with Attachments
+### Project Operations
 
-The client supports both URL and base64-encoded attachments:
+#### Create a Project
 
-```javascript
-// URL attachment
-const response = await client.createChat({
-  message: 'Create a component based on this design',
-  attachments: [{ url: 'https://example.com/design.png' }],
+```typescript
+const project = await v0.projects.create({
+  name: 'My New Project',
+  description: 'A sample project',
+  environmentVariables: [
+    { key: 'API_KEY', value: 'secret_value' }
+  ],
+  icon: 'https://example.com/icon.png'
 })
+```
 
-// Base64 attachment (from file input)
-document
-  .querySelector('input[type="file"]')
-  .addEventListener('change', async e => {
-    const file = e.target.files[0]
-    const reader = new FileReader()
+#### Find Projects
 
-    reader.onload = async () => {
-      const response = await client.createChat({
-        message: 'Create a component based on this image',
-        attachments: [{ url: reader.result }],
-      })
+```typescript
+const projects = await v0.projects.find()
+```
 
-      console.log(response)
-    }
+### Vercel Integration
 
-    reader.readAsDataURL(file)
-  })
+#### Create Vercel Integration Project
+
+```typescript
+const integration = await v0.integrations.vercel.projects.create({
+  projectId: 'vercel_project_id',
+  name: 'project_name'
+})
+```
+
+#### Find Vercel Projects
+
+```typescript
+const projects = await v0.integrations.vercel.projects.find()
 ```
 
-## Customizing Model Behavior
+### User Management
 
-Control the AI model's behavior with the `modelConfiguration` parameter:
+#### Get User Information
 
-```javascript
-const response = await client.createChat({
-  message: 'Create a dashboard layout',
-  modelConfiguration: {
-    // Use a specific model version
-    modelId: 'v0-1.5-md',
+```typescript
+const userResponse = await v0.user.get()
+console.log(userResponse.user.name, userResponse.user.email)
+```
 
-    // Enable AI-generated images in the response
-    imageGenerations: true,
-  },
+#### Get User Plan and Billing
+
+```typescript
+const planResponse = await v0.user.getPlan()
+console.log(planResponse.plan, planResponse.balance)
+```
+
+### Deployment and Monitoring
+
+#### Find Deployment Logs
+
+```typescript
+const logs = await v0.deployments.findLogs({
+  deploymentId: 'deployment_id'
+})
+```
+
+### Scopes and Rate Limits
+
+#### Find Scopes
+
+```typescript
+const scopesResponse = await v0.scopes.find()
+console.log(scopesResponse.scopes)
+```
+
+#### Check Rate Limits
+
+```typescript
+const rateLimits = await v0.rateLimits.find()
+console.log(rateLimits.remaining, rateLimits.reset)
+```
+
+## Working with Attachments
+
+The SDK supports URL and base64-encoded attachments:
+
+```typescript
+// URL attachment
+const response = await v0.chats.create({
+  message: 'Create a component based on this design',
+  attachments: [{ url: 'https://example.com/design.png' }],
 })
+
+// Base64 attachment
+const handleFileUpload = async (file: File) => {
+  const reader = new FileReader()
+  
+  reader.onload = async () => {
+    const response = await v0.chats.create({
+      message: 'Create a component based on this image',
+      attachments: [{ url: reader.result as string }],
+    })
+    
+    console.log(response)
+  }
+  
+  reader.readAsDataURL(file)
+}
+```
+
+## TypeScript Support
+
+The SDK includes complete type definitions for all API operations:
+
+```typescript
+import type { 
+  ChatsCreateRequest,
+  ChatsCreateResponse,
+  User,
+  Project,
+  ScopeSummary 
+} from 'v0-sdk'
+
+// All request and response types are fully typed
+const createChatRequest: ChatsCreateRequest = {
+  message: 'Create a component',
+  system: 'You are a helpful assistant',
+}
 ```
 
 ## Error Handling
 
-The client throws descriptive errors for various failure scenarios:
+The SDK provides detailed error information:
 
-```javascript
+```typescript
 try {
-  const chat = await client.createChat({
+  const chat = await v0.chats.create({
     message: 'Create a component',
   })
 } catch (error) {
@@ -172,18 +284,86 @@ try {
 }
 ```
 
+## Testing
+
+The SDK includes comprehensive test coverage. Run tests with:
+
+```bash
+npm test
+```
+
+### Test Structure
+
+Tests are organized by functionality:
+
+```
+tests/
+├── chats/
+│   ├── create.test.ts
+│   ├── find.test.ts
+│   ├── delete.test.ts
+│   ├── getById.test.ts
+│   ├── favorite.test.ts
+│   ├── unfavorite.test.ts
+│   ├── getProject.test.ts
+│   ├── createMessage.test.ts
+│   └── getVersionFrameToken.test.ts
+├── projects/
+│   ├── create.test.ts
+│   └── find.test.ts
+├── integrations/vercel/projects/
+│   ├── create.test.ts
+│   └── find.test.ts
+├── user/
+│   ├── get.test.ts
+│   └── getPlan.test.ts
+├── deployments/
+│   └── findLogs.test.ts
+├── scopes/
+│   └── find.test.ts
+└── rateLimits/
+    └── find.test.ts
+```
+
+## Development
+
+### Building
+
+```bash
+npm run build
+```
+
+### Generating SDK
+
+The SDK is generated from the OpenAPI specification:
+
+```bash
+npm run generate
+```
+
+### Running Tests
+
+```bash
+npm test
+```
+
 ## Advanced Usage
 
-### Streaming Responses
+### Custom Configuration
 
-Coming soon
+```typescript
+const client = new V0Client('your_api_key', 'https://custom-api.example.com', {
+  timeout: 30000,
+  retries: 3
+})
+```
 
 ### Team Collaboration
 
 Share chats with your team:
 
-```javascript
-const chat = await client.createChat({
+```typescript
+const chat = await v0.chats.create({
   message: 'Create a component for our design system',
   chatPrivacy: 'team-edit',
   teamId: 'your-team-id',
@@ -197,22 +377,20 @@ console.log(`Team chat URL: ${chat.url}`)
 
 ### Rate Limiting
 
-The API has rate limits of 100 requests per minute and 1,000 requests per hour. If you hit these limits, you'll receive a 429 status code.
+The API has rate limits. Check your current limits:
 
-### Common Errors
-
-- **403 Forbidden**: Check your API key and ensure you have a valid subscription.
-- **400 Bad Request**: Verify your request parameters match the API requirements.
-- **404 Not Found**: Ensure the chat ID exists and is accessible to your API key.
-- **413 Payload Too Large**: Reduce attachment size (max 10MB per attachment).
-
-### Debugging
+```typescript
+const limits = await v0.rateLimits.find()
+console.log(`Remaining requests: ${limits.remaining}`)
+```
 
-Enable debug mode to see detailed request and response information:
+### Common Errors
 
-```javascript
-const client = new V0Client('your_api_key', undefined, { debug: true })
-```
+- **403 Forbidden**: Check your API key and ensure you have a valid subscription
+- **400 Bad Request**: Verify your request parameters match the API requirements
+- **404 Not Found**: Ensure the resource ID exists and is accessible to your API key
+- **413 Payload Too Large**: Reduce attachment size (max 10MB per attachment)
+- **429 Too Many Requests**: You've hit the rate limit, wait before making more requests
 
 ## Resources
 

package/dist/index.cjs

@@ -0,0 +1,226 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+let BASE_URL = 'https://api.v0.dev/v1';
+async function fetcher(url, method, params = {}) {
+    const queryString = params.query ? '?' + new URLSearchParams(params.query).toString() : '';
+    const finalUrl = BASE_URL + url + queryString;
+    const apiKey = process.env.V0_API_KEY;
+    if (!apiKey) {
+        throw new Error('V0_API_KEY environment variable is required');
+    }
+    const hasBody = method !== 'GET' && params.body;
+    const headers = {
+        'Authorization': `Bearer ${apiKey}`,
+        ...params.headers
+    };
+    if (hasBody) {
+        headers['Content-Type'] = 'application/json';
+    }
+    const res = await fetch(finalUrl, {
+        method,
+        headers,
+        body: hasBody ? JSON.stringify(params.body) : undefined
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`HTTP ${res.status}: ${text}`);
+    }
+    return res.json();
+}
+
+const v0 = {
+    chats: {
+        async create (params) {
+            const body = {
+                message: params.message,
+                attachments: params.attachments,
+                system: params.system,
+                chatPrivacy: params.chatPrivacy,
+                projectId: params.projectId,
+                modelConfiguration: params.modelConfiguration,
+                chatId: params.chatId
+            };
+            return fetcher(`/chats`, 'POST', {
+                body
+            });
+        },
+        async find () {
+            return fetcher(`/chats`, 'GET', {});
+        },
+        async delete (params) {
+            const pathParams = {
+                chatId: params.chatId
+            };
+            return fetcher(`/chats/${pathParams.chatId}`, 'DELETE', {
+                });
+        },
+        async getById (params) {
+            const pathParams = {
+                chatId: params.chatId
+            };
+            return fetcher(`/chats/${pathParams.chatId}`, 'GET', {
+                });
+        },
+        async favorite (params) {
+            const pathParams = {
+                chatId: params.chatId
+            };
+            return fetcher(`/chats/${pathParams.chatId}/favorite`, 'POST', {
+                });
+        },
+        async unfavorite (params) {
+            const pathParams = {
+                chatId: params.chatId
+            };
+            return fetcher(`/chats/${pathParams.chatId}/unfavorite`, 'POST', {
+                });
+        },
+        async getProject (params) {
+            const pathParams = {
+                chatId: params.chatId
+            };
+            return fetcher(`/chats/${pathParams.chatId}/project`, 'GET', {
+                });
+        },
+        async createMessage (params) {
+            const pathParams = {
+                chatId: params.chatId
+            };
+            const body = {
+                message: params.message,
+                attachments: params.attachments,
+                modelConfiguration: params.modelConfiguration
+            };
+            return fetcher(`/chats/${pathParams.chatId}/messages`, 'POST', {
+                body
+            });
+        },
+        async getVersionFrameToken (params) {
+            const pathParams = {
+                chatId: params.chatId,
+                versionId: params.versionId
+            };
+            return fetcher(`/chats/${pathParams.chatId}/versions/${pathParams.versionId}/frame-token`, 'GET', {
+                });
+        },
+        async getMetadata (params) {
+            const pathParams = {
+                chatId: params.chatId
+            };
+            return fetcher(`/chats/${pathParams.chatId}/metadata`, 'GET', {
+                });
+        },
+        async setPrivacy (params) {
+            const pathParams = {
+                chatId: params.chatId
+            };
+            const body = {
+                privacy: params.privacy
+            };
+            return fetcher(`/chats/${pathParams.chatId}/privacy`, 'POST', {
+                body
+            });
+        },
+        async upload (params) {
+            const pathParams = {
+                chatId: params.chatId
+            };
+            const body = {
+                file: params.file
+            };
+            return fetcher(`/chats/${pathParams.chatId}/upload`, 'POST', {
+                body
+            });
+        },
+        async resume (params) {
+            const pathParams = {
+                chatId: params.chatId,
+                messageId: params.messageId
+            };
+            return fetcher(`/chats/${pathParams.chatId}/messages/${pathParams.messageId}/resume`, 'POST', {
+                });
+        }
+    },
+    deployments: {
+        async findLogs (params) {
+            const pathParams = {
+                deploymentId: params.deploymentId
+            };
+            return fetcher(`/deployments/${pathParams.deploymentId}/logs`, 'GET', {
+                });
+        },
+        async findErrors (params) {
+            const pathParams = {
+                deploymentId: params.deploymentId
+            };
+            return fetcher(`/deployments/${pathParams.deploymentId}/errors`, 'GET', {
+                });
+        }
+    },
+    integrations: {
+        vercel: {
+            projects: {
+                async find () {
+                    return fetcher(`/integrations/vercel/projects`, 'GET', {});
+                },
+                async create (params) {
+                    const body = {
+                        projectId: params.projectId,
+                        name: params.name
+                    };
+                    return fetcher(`/integrations/vercel/projects`, 'POST', {
+                        body
+                    });
+                }
+            }
+        }
+    },
+    projects: {
+        async find () {
+            return fetcher(`/projects`, 'GET', {});
+        },
+        async create (params) {
+            const body = {
+                name: params.name,
+                description: params.description,
+                icon: params.icon,
+                environmentVariables: params.environmentVariables,
+                instructions: params.instructions
+            };
+            return fetcher(`/projects`, 'POST', {
+                body
+            });
+        },
+        async assign (params) {
+            const pathParams = {
+                projectId: params.projectId
+            };
+            const body = {
+                chatId: params.chatId
+            };
+            return fetcher(`/projects/${pathParams.projectId}/assign`, 'POST', {
+                body
+            });
+        }
+    },
+    scopes: {
+        async find () {
+            return fetcher(`/scopes`, 'GET', {});
+        }
+    },
+    rateLimits: {
+        async find () {
+            return fetcher(`/rate-limits`, 'GET', {});
+        }
+    },
+    user: {
+        async get () {
+            return fetcher(`/user`, 'GET', {});
+        },
+        async getPlan () {
+            return fetcher(`/user/plan`, 'GET', {});
+        }
+    }
+};
+
+exports.v0 = v0;

package/dist/index.d.ts

@@ -0,0 +1,313 @@
+interface ScopeSummary {
+    id: string;
+    name?: string;
+}
+interface User {
+    id: string;
+    name?: string;
+    email: string;
+    avatar: string;
+    createdAt: string;
+}
+interface ChatsCreateRequest {
+    message: string;
+    attachments?: {
+        url: string;
+    }[];
+    system?: string;
+    chatPrivacy?: 'public' | 'private' | 'team-edit' | 'team' | 'unlisted';
+    projectId?: string;
+    modelConfiguration?: {
+        modelId: 'v0-1.5-sm' | 'v0-1.5-md' | 'v0-1.5-lg';
+        imageGenerations?: boolean;
+        thinking?: boolean;
+    };
+    chatId?: string;
+}
+type ChatsCreateResponse = {
+    chatId: string;
+    url: string;
+    files?: {
+        lang: string;
+        meta: Record<string, any>;
+        source: string;
+    }[];
+    demo?: string;
+    text: string;
+    modelConfiguration: {
+        modelId: 'v0-1.5-sm' | 'v0-1.5-md' | 'v0-1.5-lg';
+        imageGenerations?: boolean;
+        thinking?: boolean;
+    };
+    _deprecation?: {
+        message: string;
+        migration: string;
+        sunset: string;
+    };
+};
+interface ChatsFindResponse {
+    favorites: {
+        chatId: string;
+        shareable: boolean;
+        privacy: string;
+        title: string;
+        updatedAt: string;
+        favorite: boolean;
+        authorId: string;
+    }[];
+    history: {
+        chatId: string;
+        shareable: boolean;
+        privacy: string;
+        title: string;
+        updatedAt: string;
+    }[];
+}
+interface ChatsDeleteResponse {
+    success: boolean;
+}
+type ChatsGetByIdResponse = {
+    chatId: string;
+    url: string;
+    messages: {
+        messageId: string;
+        content: string;
+        createdAt: string;
+        type: 'message' | 'refinement' | 'forked-block' | 'forked-chat' | 'open-in-v0' | 'added-environment-variables' | 'added-integration' | 'deleted-file' | 'moved-file' | 'renamed-file' | 'edited-file' | 'replace-src' | 'reverted-block' | 'fix-with-v0' | 'sync-git';
+    }[];
+};
+type ChatsFavoriteResponse = {
+    success: boolean;
+} | {
+    error: string;
+    success?: any;
+};
+type ChatsUnfavoriteResponse = {
+    success: boolean;
+} | {
+    error: string;
+    success?: any;
+};
+interface ChatsGetProjectResponse {
+    project: {
+        id: string;
+        name: string;
+        url: string;
+    };
+}
+interface ChatsCreateMessageRequest {
+    message: string;
+    attachments?: {
+        url: string;
+    }[];
+    modelConfiguration?: {
+        modelId: 'v0-1.5-sm' | 'v0-1.5-md' | 'v0-1.5-lg';
+        imageGenerations?: boolean;
+        thinking?: boolean;
+    };
+}
+type ChatsCreateMessageResponse = {
+    chatId: string;
+    url: string;
+    files?: {
+        lang: string;
+        meta: Record<string, any>;
+        source: string;
+    }[];
+    demo?: string;
+    text: string;
+    modelConfiguration: {
+        modelId: 'v0-1.5-sm' | 'v0-1.5-md' | 'v0-1.5-lg';
+        imageGenerations?: boolean;
+        thinking?: boolean;
+    };
+};
+interface ChatsGetVersionFrameTokenResponse {
+    token: string;
+}
+interface ChatsGetMetadataResponse {
+    git: {
+        branch: string;
+        commit: string;
+    };
+    deployment: {
+        id: string;
+    };
+    project: {
+        id: string;
+        name: string;
+        url: string;
+    };
+}
+interface ChatsSetPrivacyRequest {
+    privacy: 'public' | 'private' | 'team' | 'team-edit' | 'unlisted';
+}
+type ChatsSetPrivacyResponse = {
+    success: 'true';
+} | {
+    error: string;
+};
+interface ChatsUploadRequest {
+    file: any;
+}
+interface ChatsUploadResponse {
+    url: string;
+}
+interface ChatsResumeResponse {
+    message: {
+        id: string;
+        content: string;
+        createdAt: string;
+        finishReason?: string;
+    };
+}
+interface DeploymentsFindLogsResponse {
+    error?: string;
+    logs: string[];
+    nextSince?: number;
+}
+interface DeploymentsFindErrorsResponse {
+    error?: string;
+    fullErrorText?: string;
+    errorType?: string;
+    formattedError?: string;
+}
+interface IntegrationsVercelProjectsFindResponse {
+    projects: {
+        id: string;
+        name: string;
+        url: string;
+    }[];
+}
+interface IntegrationsVercelProjectsCreateRequest {
+    projectId: string;
+    name: string;
+}
+interface IntegrationsVercelProjectsCreateResponse {
+    success: boolean;
+}
+interface ProjectsFindResponse {
+    id: string;
+    name: string;
+    url: string;
+    env: string[];
+}
+interface ProjectsCreateRequest {
+    name: string;
+    description?: string;
+    icon?: string;
+    environmentVariables?: {
+        key: string;
+        value: string;
+    }[];
+    instructions?: string;
+}
+interface ProjectsCreateResponse {
+    id: string;
+    name: string;
+    vercelProjectId?: string;
+}
+interface ProjectsAssignRequest {
+    chatId: string;
+}
+interface ProjectsAssignResponse {
+    success: boolean;
+}
+interface ScopesFindResponse {
+    scopes: ScopeSummary[];
+}
+interface RateLimitsFindResponse {
+    remaining?: number;
+    reset?: number;
+    limit: number;
+}
+interface UserGetResponse {
+    user: User;
+}
+interface UserGetPlanResponse {
+    plan: string;
+    billingCycle: {
+        start: number;
+        end: number;
+    };
+    balance: {
+        remaining: number;
+        total: number;
+    };
+}
+declare const v0: {
+    chats: {
+        create(params: ChatsCreateRequest): Promise<ChatsCreateResponse>;
+        find(): Promise<ChatsFindResponse>;
+        delete(params: {
+            chatId: string;
+        }): Promise<ChatsDeleteResponse>;
+        getById(params: {
+            chatId: string;
+        }): Promise<ChatsGetByIdResponse>;
+        favorite(params: {
+            chatId: string;
+        }): Promise<ChatsFavoriteResponse>;
+        unfavorite(params: {
+            chatId: string;
+        }): Promise<ChatsUnfavoriteResponse>;
+        getProject(params: {
+            chatId: string;
+        }): Promise<ChatsGetProjectResponse>;
+        createMessage(params: {
+            chatId: string;
+        } & ChatsCreateMessageRequest): Promise<ChatsCreateMessageResponse>;
+        getVersionFrameToken(params: {
+            chatId: string;
+            versionId: string;
+        }): Promise<ChatsGetVersionFrameTokenResponse>;
+        getMetadata(params: {
+            chatId: string;
+        }): Promise<ChatsGetMetadataResponse>;
+        setPrivacy(params: {
+            chatId: string;
+        } & ChatsSetPrivacyRequest): Promise<ChatsSetPrivacyResponse>;
+        upload(params: {
+            chatId: string;
+        } & ChatsUploadRequest): Promise<ChatsUploadResponse>;
+        resume(params: {
+            chatId: string;
+            messageId: string;
+        }): Promise<ChatsResumeResponse>;
+    };
+    deployments: {
+        findLogs(params: {
+            deploymentId: string;
+        }): Promise<DeploymentsFindLogsResponse>;
+        findErrors(params: {
+            deploymentId: string;
+        }): Promise<DeploymentsFindErrorsResponse>;
+    };
+    integrations: {
+        vercel: {
+            projects: {
+                find(): Promise<IntegrationsVercelProjectsFindResponse>;
+                create(params: IntegrationsVercelProjectsCreateRequest): Promise<IntegrationsVercelProjectsCreateResponse>;
+            };
+        };
+    };
+    projects: {
+        find(): Promise<ProjectsFindResponse>;
+        create(params: ProjectsCreateRequest): Promise<ProjectsCreateResponse>;
+        assign(params: {
+            projectId: string;
+        } & ProjectsAssignRequest): Promise<ProjectsAssignResponse>;
+    };
+    scopes: {
+        find(): Promise<ScopesFindResponse>;
+    };
+    rateLimits: {
+        find(): Promise<RateLimitsFindResponse>;
+    };
+    user: {
+        get(): Promise<UserGetResponse>;
+        getPlan(): Promise<UserGetPlanResponse>;
+    };
+};
+
+export { v0 };

package/dist/index.js

@@ -1,105 +1,224 @@
-/**
- * v0 Chats API SDK
- * A client library for interacting with the v0 Chats API
- */ class V0ChatsError extends Error {
-    constructor(message, status, data){
-        super(message);
-        this.name = 'V0ChatsError';
-        this.status = status;
-        this.data = data;
+let BASE_URL = 'https://api.v0.dev/v1';
+async function fetcher(url, method, params = {}) {
+    const queryString = params.query ? '?' + new URLSearchParams(params.query).toString() : '';
+    const finalUrl = BASE_URL + url + queryString;
+    const apiKey = process.env.V0_API_KEY;
+    if (!apiKey) {
+        throw new Error('V0_API_KEY environment variable is required');
     }
-}
-/**
- * Client for the v0 Chats API
- */ class V0Client {
-    /**
-   * Create a new v0 Chats API client
-   *
-   * @param options Client configuration options
-   */ constructor(options){
-        this.apiKey = options.apiKey;
-        this.baseUrl = options.baseUrl || 'https://api.v0.dev/';
-        this.fetchFn = options.fetch || fetch;
-    }
-    /**
-   * Create a new chat
-   *
-   * @param options Options for creating a new chat
-   * @returns Promise with the created chat details
-   */ async createChat(options) {
-        const response = await this.request('POST', '/chats', options);
-        return response;
-    }
-    /**
-   * Add a message to an existing chat
-   *
-   * @param chatId The ID of the chat to add a message to
-   * @param options Options for adding a message
-   * @returns Promise with the updated chat details
-   */ async addMessage(chatId, options) {
-        const response = await this.request('POST', `/chats/${chatId}`, options);
-        return response;
-    }
-    /**
-   * Get chat details and message history
-   *
-   * @param chatId The ID of the chat to retrieve
-   * @returns Promise with the chat details and messages
-   */ async getChat(chatId) {
-        const response = await this.request('GET', `/chats/${chatId}`);
-        return response;
+    const hasBody = method !== 'GET' && params.body;
+    const headers = {
+        'Authorization': `Bearer ${apiKey}`,
+        ...params.headers
+    };
+    if (hasBody) {
+        headers['Content-Type'] = 'application/json';
     }
-    /**
-   * Continue an existing chat (deprecated)
-   *
-   * This method is deprecated. Use addMessage() instead.
-   *
-   * @deprecated Use addMessage() instead
-   * @param chatId The ID of the chat to continue
-   * @param options Options for continuing the chat
-   * @returns Promise with the updated chat details
-   */ async continueChat(chatId, options) {
-        console.warn('continueChat() is deprecated. Use addMessage() instead.');
-        const payload = {
-            ...options,
-            chatId
-        };
-        const response = await this.request('POST', '/chats', payload);
-        return response;
+    const res = await fetch(finalUrl, {
+        method,
+        headers,
+        body: hasBody ? JSON.stringify(params.body) : undefined
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`HTTP ${res.status}: ${text}`);
     }
-    /**
-   * Make a request to the v0 Chats API
-   *
-   * @param method HTTP method
-   * @param path API path
-   * @param data Request data
-   * @returns Promise with the response data
-   */ async request(method, path, data) {
-        const url = `${this.baseUrl}${path}`;
-        const headers = {
-            Authorization: `Bearer ${this.apiKey}`,
-            'Content-Type': 'application/json'
-        };
-        const options = {
-            method,
-            headers,
-            body: data && method !== 'GET' ? JSON.stringify(data) : undefined
-        };
-        try {
-            const response = await this.fetchFn(url, options);
-            const responseData = await response.json();
-            if (!response.ok) {
-                throw new V0ChatsError(responseData.error || `API request failed with status ${response.status}`, response.status, responseData);
-            }
-            return responseData;
-        } catch (error) {
-            if (error instanceof V0ChatsError) {
-                throw error;
+    return res.json();
+}
+
+const v0 = {
+    chats: {
+        async create (params) {
+            const body = {
+                message: params.message,
+                attachments: params.attachments,
+                system: params.system,
+                chatPrivacy: params.chatPrivacy,
+                projectId: params.projectId,
+                modelConfiguration: params.modelConfiguration,
+                chatId: params.chatId
+            };
+            return fetcher(`/chats`, 'POST', {
+                body
+            });
+        },
+        async find () {
+            return fetcher(`/chats`, 'GET', {});
+        },
+        async delete (params) {
+            const pathParams = {
+                chatId: params.chatId
+            };
+            return fetcher(`/chats/${pathParams.chatId}`, 'DELETE', {
+                });
+        },
+        async getById (params) {
+            const pathParams = {
+                chatId: params.chatId
+            };
+            return fetcher(`/chats/${pathParams.chatId}`, 'GET', {
+                });
+        },
+        async favorite (params) {
+            const pathParams = {
+                chatId: params.chatId
+            };
+            return fetcher(`/chats/${pathParams.chatId}/favorite`, 'POST', {
+                });
+        },
+        async unfavorite (params) {
+            const pathParams = {
+                chatId: params.chatId
+            };
+            return fetcher(`/chats/${pathParams.chatId}/unfavorite`, 'POST', {
+                });
+        },
+        async getProject (params) {
+            const pathParams = {
+                chatId: params.chatId
+            };
+            return fetcher(`/chats/${pathParams.chatId}/project`, 'GET', {
+                });
+        },
+        async createMessage (params) {
+            const pathParams = {
+                chatId: params.chatId
+            };
+            const body = {
+                message: params.message,
+                attachments: params.attachments,
+                modelConfiguration: params.modelConfiguration
+            };
+            return fetcher(`/chats/${pathParams.chatId}/messages`, 'POST', {
+                body
+            });
+        },
+        async getVersionFrameToken (params) {
+            const pathParams = {
+                chatId: params.chatId,
+                versionId: params.versionId
+            };
+            return fetcher(`/chats/${pathParams.chatId}/versions/${pathParams.versionId}/frame-token`, 'GET', {
+                });
+        },
+        async getMetadata (params) {
+            const pathParams = {
+                chatId: params.chatId
+            };
+            return fetcher(`/chats/${pathParams.chatId}/metadata`, 'GET', {
+                });
+        },
+        async setPrivacy (params) {
+            const pathParams = {
+                chatId: params.chatId
+            };
+            const body = {
+                privacy: params.privacy
+            };
+            return fetcher(`/chats/${pathParams.chatId}/privacy`, 'POST', {
+                body
+            });
+        },
+        async upload (params) {
+            const pathParams = {
+                chatId: params.chatId
+            };
+            const body = {
+                file: params.file
+            };
+            return fetcher(`/chats/${pathParams.chatId}/upload`, 'POST', {
+                body
+            });
+        },
+        async resume (params) {
+            const pathParams = {
+                chatId: params.chatId,
+                messageId: params.messageId
+            };
+            return fetcher(`/chats/${pathParams.chatId}/messages/${pathParams.messageId}/resume`, 'POST', {
+                });
+        }
+    },
+    deployments: {
+        async findLogs (params) {
+            const pathParams = {
+                deploymentId: params.deploymentId
+            };
+            return fetcher(`/deployments/${pathParams.deploymentId}/logs`, 'GET', {
+                });
+        },
+        async findErrors (params) {
+            const pathParams = {
+                deploymentId: params.deploymentId
+            };
+            return fetcher(`/deployments/${pathParams.deploymentId}/errors`, 'GET', {
+                });
+        }
+    },
+    integrations: {
+        vercel: {
+            projects: {
+                async find () {
+                    return fetcher(`/integrations/vercel/projects`, 'GET', {});
+                },
+                async create (params) {
+                    const body = {
+                        projectId: params.projectId,
+                        name: params.name
+                    };
+                    return fetcher(`/integrations/vercel/projects`, 'POST', {
+                        body
+                    });
+                }
             }
-            throw new V0ChatsError(error instanceof Error ? error.message : 'Unknown error occurred', 500);
+        }
+    },
+    projects: {
+        async find () {
+            return fetcher(`/projects`, 'GET', {});
+        },
+        async create (params) {
+            const body = {
+                name: params.name,
+                description: params.description,
+                icon: params.icon,
+                environmentVariables: params.environmentVariables,
+                instructions: params.instructions
+            };
+            return fetcher(`/projects`, 'POST', {
+                body
+            });
+        },
+        async assign (params) {
+            const pathParams = {
+                projectId: params.projectId
+            };
+            const body = {
+                chatId: params.chatId
+            };
+            return fetcher(`/projects/${pathParams.projectId}/assign`, 'POST', {
+                body
+            });
+        }
+    },
+    scopes: {
+        async find () {
+            return fetcher(`/scopes`, 'GET', {});
+        }
+    },
+    rateLimits: {
+        async find () {
+            return fetcher(`/rate-limits`, 'GET', {});
+        }
+    },
+    user: {
+        async get () {
+            return fetcher(`/user`, 'GET', {});
+        },
+        async getPlan () {
+            return fetcher(`/user/plan`, 'GET', {});
         }
     }
-}
+};
 
-exports.V0ChatsError = V0ChatsError;
-exports.V0Client = V0Client;
+export { v0 };

package/package.json

@@ -1,11 +1,27 @@
 {
   "name": "v0-sdk",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "TypeScript SDK for the v0 Chats API",
+  "type": "module",
   "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
   "files": [
     "dist"
   ],
+  "scripts": {
+    "type-check": "tsc --noEmit",
+    "type-check:go": "tsgo --noEmit",
+    "build": "bunchee",
+    "generate": "tsx src/scripts/generate.ts",
+    "test": "vitest"
+  },
   "keywords": [
     "v0",
     "vercel",
@@ -16,10 +32,10 @@
   "author": "",
   "license": "MIT",
   "devDependencies": {
+    "@types/node": "22.5.5",
+    "@typescript/native-preview": "7.0.0-dev.20250613.1",
     "bunchee": "^6.5.2",
+    "tsx": "^4.19.2",
     "typescript": "5.7.3"
-  },
-  "scripts": {
-    "build": "bunchee"
   }
-}
+}