v0-api 0.0.2 → 0.0.3

package/dist/generated/mcp.js

@@ -0,0 +1,554 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chatsCreate = chatsCreate;
+exports.chatsFind = chatsFind;
+exports.chatsInitCreate = chatsInitCreate;
+exports.chatsDelete = chatsDelete;
+exports.chatsGetById = chatsGetById;
+exports.chatsUpdate = chatsUpdate;
+exports.chatsFavorite = chatsFavorite;
+exports.chatsFork = chatsFork;
+exports.projectsGetByChatId = projectsGetByChatId;
+exports.chatsSendMessage = chatsSendMessage;
+exports.chatsGetMetadata = chatsGetMetadata;
+exports.chatsResume = chatsResume;
+exports.deploymentsFindLogs = deploymentsFindLogs;
+exports.deploymentsFindErrors = deploymentsFindErrors;
+exports.integrationsVercelProjectsFind = integrationsVercelProjectsFind;
+exports.integrationsVercelProjectsCreate = integrationsVercelProjectsCreate;
+exports.projectsFind = projectsFind;
+exports.projectsCreate = projectsCreate;
+exports.projectsAssign = projectsAssign;
+exports.rateLimitsFind = rateLimitsFind;
+exports.userGet = userGet;
+exports.userGetBilling = userGetBilling;
+exports.userGetPlan = userGetPlan;
+exports.userGetScopes = userGetScopes;
+exports.initMcpTools = initMcpTools;
+const fetcher_1 = __importDefault(require("../utils/fetcher.js"));
+const schemas_ts_1 = require("./schemas.js");
+/**
+ * @description Create a new chat
+ * @summary Create Chat
+ * {@link /chats}
+ */
+async function chatsCreate({ config = {} }) {
+    const { client: request = fetcher_1.default, ...requestConfig } = config;
+    const data = await request({
+        method: 'POST',
+        url: `/chats`,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
+    return { content: [{ type: 'text', text: JSON.stringify(data) }] };
+}
+/**
+ * @description Find all chats
+ * @summary Find Chats
+ * {@link /chats}
+ */
+async function chatsFind({ queryParams, config = {} }) {
+    const { client: request = fetcher_1.default, ...requestConfig } = config;
+    const data = await request({ method: 'GET', url: `/chats`, queryParams, ...requestConfig });
+    return { content: [{ type: 'text', text: JSON.stringify(data) }] };
+}
+/**
+ * @description Initialize a new chat from files
+ * @summary Initialize Chat
+ * {@link /chats/init}
+ */
+async function chatsInitCreate({ config = {} }) {
+    const { client: request = fetcher_1.default, ...requestConfig } = config;
+    const data = await request({
+        method: 'POST',
+        url: `/chats/init`,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
+    return { content: [{ type: 'text', text: JSON.stringify(data) }] };
+}
+/**
+ * @description Delete a chat
+ * @summary Delete Chat
+ * {@link /chats/:chatId}
+ */
+async function chatsDelete({ pathParams: { chatId }, config = {} }) {
+    const { client: request = fetcher_1.default, ...requestConfig } = config;
+    if (!chatId) {
+        throw new Error(`Missing required path parameter: chatId`);
+    }
+    const data = await request({ method: 'DELETE', url: `/chats/${chatId}`, ...requestConfig });
+    return { content: [{ type: 'text', text: JSON.stringify(data) }] };
+}
+/**
+ * @description Get a chat
+ * @summary Get Chat
+ * {@link /chats/:chatId}
+ */
+async function chatsGetById({ pathParams: { chatId }, config = {} }) {
+    const { client: request = fetcher_1.default, ...requestConfig } = config;
+    if (!chatId) {
+        throw new Error(`Missing required path parameter: chatId`);
+    }
+    const data = await request({ method: 'GET', url: `/chats/${chatId}`, ...requestConfig });
+    return { content: [{ type: 'text', text: JSON.stringify(data) }] };
+}
+/**
+ * @description Update a chat
+ * @summary Update Chat
+ * {@link /chats/:chatId}
+ */
+async function chatsUpdate({ pathParams: { chatId }, config = {} }) {
+    const { client: request = fetcher_1.default, ...requestConfig } = config;
+    if (!chatId) {
+        throw new Error(`Missing required path parameter: chatId`);
+    }
+    const data = await request({
+        method: 'PATCH',
+        url: `/chats/${chatId}`,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
+    return { content: [{ type: 'text', text: JSON.stringify(data) }] };
+}
+/**
+ * @description Favorite a chat
+ * @summary Favorite Chat
+ * {@link /chats/:chatId/favorite}
+ */
+async function chatsFavorite({ pathParams: { chatId }, config = {} }) {
+    const { client: request = fetcher_1.default, ...requestConfig } = config;
+    if (!chatId) {
+        throw new Error(`Missing required path parameter: chatId`);
+    }
+    const data = await request({
+        method: 'PUT',
+        url: `/chats/${chatId}/favorite`,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
+    return { content: [{ type: 'text', text: JSON.stringify(data) }] };
+}
+/**
+ * @description Fork a version in a chat
+ * @summary Fork Chat
+ * {@link /chats/:chatId/fork}
+ */
+async function chatsFork({ pathParams: { chatId }, config = {} }) {
+    const { client: request = fetcher_1.default, ...requestConfig } = config;
+    if (!chatId) {
+        throw new Error(`Missing required path parameter: chatId`);
+    }
+    const data = await request({
+        method: 'POST',
+        url: `/chats/${chatId}/fork`,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
+    return { content: [{ type: 'text', text: JSON.stringify(data) }] };
+}
+/**
+ * @description Get the project for a chat
+ * @summary Get Project by Chat ID
+ * {@link /chats/:chatId/project}
+ */
+async function projectsGetByChatId({ pathParams: { chatId }, config = {} }) {
+    const { client: request = fetcher_1.default, ...requestConfig } = config;
+    if (!chatId) {
+        throw new Error(`Missing required path parameter: chatId`);
+    }
+    const data = await request({ method: 'GET', url: `/chats/${chatId}/project`, ...requestConfig });
+    return { content: [{ type: 'text', text: JSON.stringify(data) }] };
+}
+/**
+ * @description Create a new message in a chat
+ * @summary Create Message
+ * {@link /chats/:chatId/messages}
+ */
+async function chatsSendMessage({ pathParams: { chatId }, config = {} }) {
+    const { client: request = fetcher_1.default, ...requestConfig } = config;
+    if (!chatId) {
+        throw new Error(`Missing required path parameter: chatId`);
+    }
+    const data = await request({
+        method: 'POST',
+        url: `/chats/${chatId}/messages`,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
+    return { content: [{ type: 'text', text: JSON.stringify(data) }] };
+}
+/**
+ * @description Get the metadata for a chat
+ * @summary Get Chat Metadata
+ * {@link /chats/:chatId/metadata}
+ */
+async function chatsGetMetadata({ pathParams: { chatId }, config = {} }) {
+    const { client: request = fetcher_1.default, ...requestConfig } = config;
+    if (!chatId) {
+        throw new Error(`Missing required path parameter: chatId`);
+    }
+    const data = await request({ method: 'GET', url: `/chats/${chatId}/metadata`, ...requestConfig });
+    return { content: [{ type: 'text', text: JSON.stringify(data) }] };
+}
+/**
+ * @description Resume a chat message
+ * @summary Resume Chat Message
+ * {@link /chats/:chatId/messages/:messageId/resume}
+ */
+async function chatsResume({ pathParams: { chatId, messageId }, config = {} }) {
+    const { client: request = fetcher_1.default, ...requestConfig } = config;
+    if (!chatId) {
+        throw new Error(`Missing required path parameter: chatId`);
+    }
+    if (!messageId) {
+        throw new Error(`Missing required path parameter: messageId`);
+    }
+    const data = await request({ method: 'POST', url: `/chats/${chatId}/messages/${messageId}/resume`, ...requestConfig });
+    return { content: [{ type: 'text', text: JSON.stringify(data) }] };
+}
+/**
+ * @description Find logs for a deployment
+ * @summary Find Deployment Logs
+ * {@link /deployments/:deploymentId/logs}
+ */
+async function deploymentsFindLogs({ pathParams: { deploymentId }, queryParams, config = {} }) {
+    const { client: request = fetcher_1.default, ...requestConfig } = config;
+    if (!deploymentId) {
+        throw new Error(`Missing required path parameter: deploymentId`);
+    }
+    const data = await request({ method: 'GET', url: `/deployments/${deploymentId}/logs`, queryParams, ...requestConfig });
+    return { content: [{ type: 'text', text: JSON.stringify(data) }] };
+}
+/**
+ * @description Find errors for a deployment
+ * @summary Find Deployment Errors
+ * {@link /deployments/:deploymentId/errors}
+ */
+async function deploymentsFindErrors({ pathParams: { deploymentId }, config = {} }) {
+    const { client: request = fetcher_1.default, ...requestConfig } = config;
+    if (!deploymentId) {
+        throw new Error(`Missing required path parameter: deploymentId`);
+    }
+    const data = await request({ method: 'GET', url: `/deployments/${deploymentId}/errors`, ...requestConfig });
+    return { content: [{ type: 'text', text: JSON.stringify(data) }] };
+}
+/**
+ * @description Find all Vercel projects
+ * @summary Find Vercel Projects
+ * {@link /integrations/vercel/projects}
+ */
+async function integrationsVercelProjectsFind({ config = {} }) {
+    const { client: request = fetcher_1.default, ...requestConfig } = config;
+    const data = await request({ method: 'GET', url: `/integrations/vercel/projects`, ...requestConfig });
+    return { content: [{ type: 'text', text: JSON.stringify(data) }] };
+}
+/**
+ * @description Create a new Vercel project
+ * @summary Create Vercel Project
+ * {@link /integrations/vercel/projects}
+ */
+async function integrationsVercelProjectsCreate({ config = {} }) {
+    const { client: request = fetcher_1.default, ...requestConfig } = config;
+    const data = await request({
+        method: 'POST',
+        url: `/integrations/vercel/projects`,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
+    return { content: [{ type: 'text', text: JSON.stringify(data) }] };
+}
+/**
+ * @description Find all projects
+ * @summary Find Projects
+ * {@link /projects}
+ */
+async function projectsFind({ config = {} }) {
+    const { client: request = fetcher_1.default, ...requestConfig } = config;
+    const data = await request({ method: 'GET', url: `/projects`, ...requestConfig });
+    return { content: [{ type: 'text', text: JSON.stringify(data) }] };
+}
+/**
+ * @description Create a new project
+ * @summary Create Project
+ * {@link /projects}
+ */
+async function projectsCreate({ config = {} }) {
+    const { client: request = fetcher_1.default, ...requestConfig } = config;
+    const data = await request({
+        method: 'POST',
+        url: `/projects`,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
+    return { content: [{ type: 'text', text: JSON.stringify(data) }] };
+}
+/**
+ * @description Assign a project to a chat
+ * @summary Assign Project to Chat
+ * {@link /projects/:projectId/assign}
+ */
+async function projectsAssign({ pathParams: { projectId }, config = {} }) {
+    const { client: request = fetcher_1.default, ...requestConfig } = config;
+    if (!projectId) {
+        throw new Error(`Missing required path parameter: projectId`);
+    }
+    const data = await request({
+        method: 'POST',
+        url: `/projects/${projectId}/assign`,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
+    return { content: [{ type: 'text', text: JSON.stringify(data) }] };
+}
+/**
+ * @description Find the rate limit for a scope
+ * @summary Find Rate Limit
+ * {@link /rate-limits}
+ */
+async function rateLimitsFind({ queryParams, config = {} }) {
+    const { client: request = fetcher_1.default, ...requestConfig } = config;
+    const data = await request({ method: 'GET', url: `/rate-limits`, queryParams, ...requestConfig });
+    return { content: [{ type: 'text', text: JSON.stringify(data) }] };
+}
+/**
+ * @description Get the user
+ * @summary Get User
+ * {@link /user}
+ */
+async function userGet({ config = {} }) {
+    const { client: request = fetcher_1.default, ...requestConfig } = config;
+    const data = await request({ method: 'GET', url: `/user`, ...requestConfig });
+    return { content: [{ type: 'text', text: JSON.stringify(data) }] };
+}
+/**
+ * @description Get the billing for the user
+ * @summary Get Billing
+ * {@link /user/billing}
+ */
+async function userGetBilling({ queryParams, config = {} }) {
+    const { client: request = fetcher_1.default, ...requestConfig } = config;
+    const data = await request({ method: 'GET', url: `/user/billing`, queryParams, ...requestConfig });
+    return { content: [{ type: 'text', text: JSON.stringify(data) }] };
+}
+/**
+ * @description Get the plan for the user
+ * @summary Get Plan
+ * {@link /user/plan}
+ */
+async function userGetPlan({ config = {} }) {
+    const { client: request = fetcher_1.default, ...requestConfig } = config;
+    const data = await request({ method: 'GET', url: `/user/plan`, ...requestConfig });
+    return { content: [{ type: 'text', text: JSON.stringify(data) }] };
+}
+/**
+ * @description Get all scopes for the user
+ * @summary Get User Scopes
+ * {@link /user/scopes}
+ */
+async function userGetScopes({ config = {} }) {
+    const { client: request = fetcher_1.default, ...requestConfig } = config;
+    const data = await request({ method: 'GET', url: `/user/scopes`, ...requestConfig });
+    return { content: [{ type: 'text', text: JSON.stringify(data) }] };
+}
+function initMcpTools(serverLike, config) {
+    const server = serverLike;
+    server.tool('chatsCreate', 'Create a new chat', async () => {
+        try {
+            return await chatsCreate({ config });
+        }
+        catch (error) {
+            return { isError: true, content: [{ type: 'text', text: JSON.stringify(error) }] };
+        }
+    });
+    server.tool('chatsFind', 'Find all chats', { queryParams: schemas_ts_1.chatsFindQueryParamsSchema }, async ({ queryParams }) => {
+        try {
+            return await chatsFind({ queryParams, config });
+        }
+        catch (error) {
+            return { isError: true, content: [{ type: 'text', text: JSON.stringify(error) }] };
+        }
+    });
+    server.tool('chatsInitCreate', 'Initialize a new chat from files', async () => {
+        try {
+            return await chatsInitCreate({ config });
+        }
+        catch (error) {
+            return { isError: true, content: [{ type: 'text', text: JSON.stringify(error) }] };
+        }
+    });
+    server.tool('chatsDelete', 'Delete a chat', { chatId: schemas_ts_1.chatsDeletePathParamsSchema.shape.chatId }, async ({ chatId }) => {
+        try {
+            return await chatsDelete({ pathParams: { chatId }, config });
+        }
+        catch (error) {
+            return { isError: true, content: [{ type: 'text', text: JSON.stringify(error) }] };
+        }
+    });
+    server.tool('chatsGetById', 'Get a chat', { chatId: schemas_ts_1.chatsGetByIdPathParamsSchema.shape.chatId }, async ({ chatId }) => {
+        try {
+            return await chatsGetById({ pathParams: { chatId }, config });
+        }
+        catch (error) {
+            return { isError: true, content: [{ type: 'text', text: JSON.stringify(error) }] };
+        }
+    });
+    server.tool('chatsUpdate', 'Update a chat', { chatId: schemas_ts_1.chatsUpdatePathParamsSchema.shape.chatId }, async ({ chatId }) => {
+        try {
+            return await chatsUpdate({ pathParams: { chatId }, config });
+        }
+        catch (error) {
+            return { isError: true, content: [{ type: 'text', text: JSON.stringify(error) }] };
+        }
+    });
+    server.tool('chatsFavorite', 'Favorite a chat', { chatId: schemas_ts_1.chatsFavoritePathParamsSchema.shape.chatId }, async ({ chatId }) => {
+        try {
+            return await chatsFavorite({ pathParams: { chatId }, config });
+        }
+        catch (error) {
+            return { isError: true, content: [{ type: 'text', text: JSON.stringify(error) }] };
+        }
+    });
+    server.tool('chatsFork', 'Fork a version in a chat', { chatId: schemas_ts_1.chatsForkPathParamsSchema.shape.chatId }, async ({ chatId }) => {
+        try {
+            return await chatsFork({ pathParams: { chatId }, config });
+        }
+        catch (error) {
+            return { isError: true, content: [{ type: 'text', text: JSON.stringify(error) }] };
+        }
+    });
+    server.tool('projectsGetByChatId', 'Get the project for a chat', { chatId: schemas_ts_1.projectsGetByChatIdPathParamsSchema.shape.chatId }, async ({ chatId }) => {
+        try {
+            return await projectsGetByChatId({ pathParams: { chatId }, config });
+        }
+        catch (error) {
+            return { isError: true, content: [{ type: 'text', text: JSON.stringify(error) }] };
+        }
+    });
+    server.tool('chatsSendMessage', 'Create a new message in a chat', { chatId: schemas_ts_1.chatsSendMessagePathParamsSchema.shape.chatId }, async ({ chatId }) => {
+        try {
+            return await chatsSendMessage({ pathParams: { chatId }, config });
+        }
+        catch (error) {
+            return { isError: true, content: [{ type: 'text', text: JSON.stringify(error) }] };
+        }
+    });
+    server.tool('chatsGetMetadata', 'Get the metadata for a chat', { chatId: schemas_ts_1.chatsGetMetadataPathParamsSchema.shape.chatId }, async ({ chatId }) => {
+        try {
+            return await chatsGetMetadata({ pathParams: { chatId }, config });
+        }
+        catch (error) {
+            return { isError: true, content: [{ type: 'text', text: JSON.stringify(error) }] };
+        }
+    });
+    server.tool('chatsResume', 'Resume a chat message', { chatId: schemas_ts_1.chatsResumePathParamsSchema.shape.chatId, messageId: schemas_ts_1.chatsResumePathParamsSchema.shape.messageId }, async ({ chatId, messageId }) => {
+        try {
+            return await chatsResume({ pathParams: { chatId, messageId }, config });
+        }
+        catch (error) {
+            return { isError: true, content: [{ type: 'text', text: JSON.stringify(error) }] };
+        }
+    });
+    server.tool('deploymentsFindLogs', 'Find logs for a deployment', {
+        deploymentId: schemas_ts_1.deploymentsFindLogsPathParamsSchema.shape.deploymentId,
+        queryParams: schemas_ts_1.deploymentsFindLogsQueryParamsSchema
+    }, async ({ deploymentId, queryParams }) => {
+        try {
+            return await deploymentsFindLogs({ pathParams: { deploymentId }, queryParams, config });
+        }
+        catch (error) {
+            return { isError: true, content: [{ type: 'text', text: JSON.stringify(error) }] };
+        }
+    });
+    server.tool('deploymentsFindErrors', 'Find errors for a deployment', { deploymentId: schemas_ts_1.deploymentsFindErrorsPathParamsSchema.shape.deploymentId }, async ({ deploymentId }) => {
+        try {
+            return await deploymentsFindErrors({ pathParams: { deploymentId }, config });
+        }
+        catch (error) {
+            return { isError: true, content: [{ type: 'text', text: JSON.stringify(error) }] };
+        }
+    });
+    server.tool('integrationsVercelProjectsFind', 'Find all Vercel projects', async () => {
+        try {
+            return await integrationsVercelProjectsFind({ config });
+        }
+        catch (error) {
+            return { isError: true, content: [{ type: 'text', text: JSON.stringify(error) }] };
+        }
+    });
+    server.tool('integrationsVercelProjectsCreate', 'Create a new Vercel project', async () => {
+        try {
+            return await integrationsVercelProjectsCreate({ config });
+        }
+        catch (error) {
+            return { isError: true, content: [{ type: 'text', text: JSON.stringify(error) }] };
+        }
+    });
+    server.tool('projectsFind', 'Find all projects', async () => {
+        try {
+            return await projectsFind({ config });
+        }
+        catch (error) {
+            return { isError: true, content: [{ type: 'text', text: JSON.stringify(error) }] };
+        }
+    });
+    server.tool('projectsCreate', 'Create a new project', async () => {
+        try {
+            return await projectsCreate({ config });
+        }
+        catch (error) {
+            return { isError: true, content: [{ type: 'text', text: JSON.stringify(error) }] };
+        }
+    });
+    server.tool('projectsAssign', 'Assign a project to a chat', { projectId: schemas_ts_1.projectsAssignPathParamsSchema.shape.projectId }, async ({ projectId }) => {
+        try {
+            return await projectsAssign({ pathParams: { projectId }, config });
+        }
+        catch (error) {
+            return { isError: true, content: [{ type: 'text', text: JSON.stringify(error) }] };
+        }
+    });
+    server.tool('rateLimitsFind', 'Find the rate limit for a scope', { queryParams: schemas_ts_1.rateLimitsFindQueryParamsSchema }, async ({ queryParams }) => {
+        try {
+            return await rateLimitsFind({ queryParams, config });
+        }
+        catch (error) {
+            return { isError: true, content: [{ type: 'text', text: JSON.stringify(error) }] };
+        }
+    });
+    server.tool('userGet', 'Get the user', async () => {
+        try {
+            return await userGet({ config });
+        }
+        catch (error) {
+            return { isError: true, content: [{ type: 'text', text: JSON.stringify(error) }] };
+        }
+    });
+    server.tool('userGetBilling', 'Get the billing for the user', { queryParams: schemas_ts_1.userGetBillingQueryParamsSchema }, async ({ queryParams }) => {
+        try {
+            return await userGetBilling({ queryParams, config });
+        }
+        catch (error) {
+            return { isError: true, content: [{ type: 'text', text: JSON.stringify(error) }] };
+        }
+    });
+    server.tool('userGetPlan', 'Get the plan for the user', async () => {
+        try {
+            return await userGetPlan({ config });
+        }
+        catch (error) {
+            return { isError: true, content: [{ type: 'text', text: JSON.stringify(error) }] };
+        }
+    });
+    server.tool('userGetScopes', 'Get all scopes for the user', async () => {
+        try {
+            return await userGetScopes({ config });
+        }
+        catch (error) {
+            return { isError: true, content: [{ type: 'text', text: JSON.stringify(error) }] };
+        }
+    });
+}