v0-sdk 0.0.5 → 0.0.7

package/dist/index.cjs

@@ -0,0 +1,275 @@
+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
+            };
+            return fetcher(`/chats`, 'POST', {
+                body
+            });
+        },
+        async find (params) {
+            const query = params ? Object.fromEntries(Object.entries({
+                limit: params.limit,
+                offset: params.offset,
+                isFavorite: params.isFavorite
+            }).filter(([_, value])=>value !== undefined)) : {};
+            const hasQuery = Object.keys(query).length > 0;
+            return fetcher(`/chats`, 'GET', {
+                ...hasQuery ? {
+                    query
+                } : {}
+            });
+        },
+        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 update (params) {
+            const pathParams = {
+                chatId: params.chatId
+            };
+            const body = {
+                privacy: params.privacy
+            };
+            return fetcher(`/chats/${pathParams.chatId}`, 'PATCH', {
+                body
+            });
+        },
+        async favorite (params) {
+            const pathParams = {
+                chatId: params.chatId
+            };
+            const body = {
+                isFavorite: params.isFavorite
+            };
+            return fetcher(`/chats/${pathParams.chatId}/favorite`, 'PUT', {
+                body
+            });
+        },
+        async fork (params) {
+            const pathParams = {
+                chatId: params.chatId
+            };
+            const body = {
+                versionId: params.versionId
+            };
+            return fetcher(`/chats/${pathParams.chatId}/fork`, 'POST', {
+                body
+            });
+        },
+        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 findIframe (params) {
+            const pathParams = {
+                chatId: params.chatId,
+                versionId: params.versionId
+            };
+            return fetcher(`/chats/${pathParams.chatId}/versions/${pathParams.versionId}/iframe`, 'GET', {
+                });
+        },
+        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 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', {
+                });
+        }
+    },
+    projects: {
+        async getByChatId (params) {
+            const pathParams = {
+                chatId: params.chatId
+            };
+            return fetcher(`/chats/${pathParams.chatId}/project`, 'GET', {
+                });
+        },
+        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
+            });
+        }
+    },
+    deployments: {
+        async findLogs (params) {
+            const pathParams = {
+                deploymentId: params.deploymentId
+            };
+            const query = Object.fromEntries(Object.entries({
+                since: params.since
+            }).filter(([_, value])=>value !== undefined));
+            const hasQuery = Object.keys(query).length > 0;
+            return fetcher(`/deployments/${pathParams.deploymentId}/logs`, 'GET', {
+                ...hasQuery ? {
+                    query
+                } : {}
+            });
+        },
+        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
+                    });
+                }
+            }
+        }
+    },
+    rateLimits: {
+        async find (params) {
+            const query = params ? Object.fromEntries(Object.entries({
+                scope: params.scope
+            }).filter(([_, value])=>value !== undefined)) : {};
+            const hasQuery = Object.keys(query).length > 0;
+            return fetcher(`/rate-limits`, 'GET', {
+                ...hasQuery ? {
+                    query
+                } : {}
+            });
+        }
+    },
+    user: {
+        async get () {
+            return fetcher(`/user`, 'GET', {});
+        },
+        async getBilling (params) {
+            const query = params ? Object.fromEntries(Object.entries({
+                scope: params.scope
+            }).filter(([_, value])=>value !== undefined)) : {};
+            const hasQuery = Object.keys(query).length > 0;
+            return fetcher(`/user/billing`, 'GET', {
+                ...hasQuery ? {
+                    query
+                } : {}
+            });
+        },
+        async getPlan () {
+            return fetcher(`/user/plan`, 'GET', {});
+        },
+        async getScopes () {
+            return fetcher(`/user/scopes`, 'GET', {});
+        }
+    }
+};
+
+exports.v0 = v0;

package/dist/index.d.ts

@@ -0,0 +1,355 @@
+type ChatDetail = {
+    id: string;
+    object: 'chat';
+    url: string;
+    shareable: boolean;
+    privacy?: 'public' | 'private' | 'team' | 'team-edit' | 'unlisted';
+    title?: string;
+    updatedAt?: string;
+    favorite: boolean;
+    authorId: string;
+    latestBlockId?: string;
+    messages: {
+        id: string;
+        object: 'message';
+        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';
+    }[];
+};
+interface ChatSummary {
+    id: string;
+    object: 'chat';
+    shareable: boolean;
+    privacy: string;
+    title?: string;
+    updatedAt: string;
+    favorite: boolean;
+    authorId: string;
+    latestVersionId?: string;
+}
+type MessageDetail = {
+    id: string;
+    object: 'message';
+    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 ProjectDetail {
+    id: string;
+    object: 'project';
+    name: string;
+    vercelProjectId?: string;
+}
+interface ScopeSummary {
+    id: string;
+    object: 'scope';
+    name?: string;
+}
+interface UserDetail {
+    id: string;
+    object: 'user';
+    name?: string;
+    email: string;
+    avatar: string;
+}
+interface VercelProjectDetail {
+    id: string;
+    object: 'vercel_project';
+    name: 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;
+    };
+}
+type ChatsCreateResponse = {
+    id: string;
+    object: 'chat';
+    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 ChatsFindResponse {
+    object: 'list';
+    data: ChatSummary[];
+}
+interface ChatsDeleteResponse {
+    id: string;
+    object: 'chat';
+    deleted: true;
+}
+type ChatsGetByIdResponse = ChatDetail;
+interface ChatsUpdateRequest {
+    privacy?: 'public' | 'private' | 'team' | 'team-edit' | 'unlisted';
+}
+type ChatsUpdateResponse = ChatDetail;
+interface ChatsFavoriteRequest {
+    isFavorite: boolean;
+}
+interface ChatsFavoriteResponse {
+    id: string;
+    object: 'chat';
+    favorited: boolean;
+}
+interface ChatsForkRequest {
+    versionId: string;
+}
+type ChatsForkResponse = ChatDetail;
+type ProjectsGetByChatIdResponse = ProjectDetail;
+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 = MessageDetail;
+interface ChatsFindIframeResponse {
+    id: string;
+    object: 'iframe';
+    url: string;
+}
+interface ChatsGetVersionFrameTokenResponse {
+    token: string;
+}
+interface ChatsGetMetadataResponse {
+    git: {
+        branch: string;
+        commit: string;
+    };
+    deployment: {
+        id: string;
+    };
+    project: {
+        id: string;
+        name: string;
+        url: string;
+    };
+}
+interface ChatsUploadRequest {
+    file: any;
+}
+interface ChatsUploadResponse {
+    url: string;
+}
+type ChatsResumeResponse = MessageDetail;
+interface DeploymentsFindLogsResponse {
+    error?: string;
+    logs: string[];
+    nextSince?: number;
+}
+interface DeploymentsFindErrorsResponse {
+    error?: string;
+    fullErrorText?: string;
+    errorType?: string;
+    formattedError?: string;
+}
+interface IntegrationsVercelProjectsFindResponse {
+    object: 'list';
+    data: VercelProjectDetail[];
+}
+interface IntegrationsVercelProjectsCreateRequest {
+    projectId: string;
+    name: string;
+}
+type IntegrationsVercelProjectsCreateResponse = VercelProjectDetail;
+interface ProjectsFindResponse {
+    object: 'list';
+    data: ProjectDetail[];
+}
+interface ProjectsCreateRequest {
+    name: string;
+    description?: string;
+    icon?: string;
+    environmentVariables?: {
+        key: string;
+        value: string;
+    }[];
+    instructions?: string;
+}
+type ProjectsCreateResponse = ProjectDetail;
+interface ProjectsAssignRequest {
+    chatId: string;
+}
+interface ProjectsAssignResponse {
+    object: 'project';
+    id: string;
+    assigned: true;
+}
+interface RateLimitsFindResponse {
+    remaining?: number;
+    reset?: number;
+    limit: number;
+}
+type UserGetResponse = UserDetail;
+type UserGetBillingResponse = {
+    billingType: 'token';
+    data: {
+        plan: string;
+        billingMode?: 'test';
+        role: string;
+        billingCycle: {
+            start: number;
+            end: number;
+        };
+        balance: {
+            remaining: number;
+            total: number;
+        };
+        onDemand: {
+            balance: number;
+            blocks?: {
+                expirationDate?: number;
+                effectiveDate: number;
+                originalBalance: number;
+                currentBalance: number;
+            }[];
+        };
+    };
+} | {
+    billingType: 'legacy';
+    data: {
+        remaining?: number;
+        reset?: number;
+        limit: number;
+    };
+};
+interface UserGetPlanResponse {
+    object: 'plan';
+    plan: string;
+    billingCycle: {
+        start: number;
+        end: number;
+    };
+    balance: {
+        remaining: number;
+        total: number;
+    };
+}
+interface UserGetScopesResponse {
+    object: 'list';
+    data: ScopeSummary[];
+}
+declare const v0: {
+    chats: {
+        create(params: ChatsCreateRequest): Promise<ChatsCreateResponse>;
+        find(params?: {
+            limit?: string;
+            offset?: string;
+            isFavorite?: string;
+        }): Promise<ChatsFindResponse>;
+        delete(params: {
+            chatId: string;
+        }): Promise<ChatsDeleteResponse>;
+        getById(params: {
+            chatId: string;
+        }): Promise<ChatsGetByIdResponse>;
+        update(params: {
+            chatId: string;
+        } & ChatsUpdateRequest): Promise<ChatsUpdateResponse>;
+        favorite(params: {
+            chatId: string;
+        } & ChatsFavoriteRequest): Promise<ChatsFavoriteResponse>;
+        fork(params: {
+            chatId: string;
+        } & ChatsForkRequest): Promise<ChatsForkResponse>;
+        createMessage(params: {
+            chatId: string;
+        } & ChatsCreateMessageRequest): Promise<ChatsCreateMessageResponse>;
+        findIframe(params: {
+            chatId: string;
+            versionId: string;
+        }): Promise<ChatsFindIframeResponse>;
+        getVersionFrameToken(params: {
+            chatId: string;
+            versionId: string;
+        }): Promise<ChatsGetVersionFrameTokenResponse>;
+        getMetadata(params: {
+            chatId: string;
+        }): Promise<ChatsGetMetadataResponse>;
+        upload(params: {
+            chatId: string;
+        } & ChatsUploadRequest): Promise<ChatsUploadResponse>;
+        resume(params: {
+            chatId: string;
+            messageId: string;
+        }): Promise<ChatsResumeResponse>;
+    };
+    projects: {
+        getByChatId(params: {
+            chatId: string;
+        }): Promise<ProjectsGetByChatIdResponse>;
+        find(): Promise<ProjectsFindResponse>;
+        create(params: ProjectsCreateRequest): Promise<ProjectsCreateResponse>;
+        assign(params: {
+            projectId: string;
+        } & ProjectsAssignRequest): Promise<ProjectsAssignResponse>;
+    };
+    deployments: {
+        findLogs(params: {
+            deploymentId: string;
+            since?: string;
+        }): Promise<DeploymentsFindLogsResponse>;
+        findErrors(params: {
+            deploymentId: string;
+        }): Promise<DeploymentsFindErrorsResponse>;
+    };
+    integrations: {
+        vercel: {
+            projects: {
+                find(): Promise<IntegrationsVercelProjectsFindResponse>;
+                create(params: IntegrationsVercelProjectsCreateRequest): Promise<IntegrationsVercelProjectsCreateResponse>;
+            };
+        };
+    };
+    rateLimits: {
+        find(params?: {
+            scope?: string;
+        }): Promise<RateLimitsFindResponse>;
+    };
+    user: {
+        get(): Promise<UserGetResponse>;
+        getBilling(params?: {
+            scope?: string;
+        }): Promise<UserGetBillingResponse>;
+        getPlan(): Promise<UserGetPlanResponse>;
+        getScopes(): Promise<UserGetScopesResponse>;
+    };
+};
+
+export { v0 };