v0-api 0.0.2 → 0.0.4

package/dist/mcp.cjs

@@ -0,0 +1,519 @@
+'use strict';
+
+const schemas = require('./shared/v0-api.D3CFh7k4.cjs');
+require('zod');
+
+async function chatsCreate({
+  config = {}
+}) {
+  const { client: request = schemas.client, ...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) }] };
+}
+async function chatsFind({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "GET", url: `/chats`, queryParams, ...requestConfig });
+  return { content: [{ type: "text", text: JSON.stringify(data) }] };
+}
+async function chatsInitCreate({
+  config = {}
+}) {
+  const { client: request = schemas.client, ...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) }] };
+}
+async function chatsDelete({
+  pathParams: { chatId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...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) }] };
+}
+async function chatsGetById({
+  pathParams: { chatId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...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) }] };
+}
+async function chatsUpdate({
+  pathParams: { chatId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...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) }] };
+}
+async function chatsFavorite({
+  pathParams: { chatId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...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) }] };
+}
+async function chatsFork({
+  pathParams: { chatId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...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) }] };
+}
+async function projectsGetByChatId({
+  pathParams: { chatId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...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) }] };
+}
+async function chatsSendMessage({
+  pathParams: { chatId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...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) }] };
+}
+async function chatsGetMetadata({
+  pathParams: { chatId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...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) }] };
+}
+async function chatsResume({
+  pathParams: { chatId, messageId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...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) }] };
+}
+async function deploymentsFindLogs({
+  pathParams: { deploymentId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...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) }] };
+}
+async function deploymentsFindErrors({
+  pathParams: { deploymentId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...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) }] };
+}
+async function integrationsVercelProjectsFind({
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "GET", url: `/integrations/vercel/projects`, ...requestConfig });
+  return { content: [{ type: "text", text: JSON.stringify(data) }] };
+}
+async function integrationsVercelProjectsCreate({
+  config = {}
+}) {
+  const { client: request = schemas.client, ...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) }] };
+}
+async function projectsFind({
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "GET", url: `/projects`, ...requestConfig });
+  return { content: [{ type: "text", text: JSON.stringify(data) }] };
+}
+async function projectsCreate({
+  config = {}
+}) {
+  const { client: request = schemas.client, ...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) }] };
+}
+async function projectsAssign({
+  pathParams: { projectId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...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) }] };
+}
+async function rateLimitsFind({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "GET", url: `/rate-limits`, queryParams, ...requestConfig });
+  return { content: [{ type: "text", text: JSON.stringify(data) }] };
+}
+async function userGet({
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "GET", url: `/user`, ...requestConfig });
+  return { content: [{ type: "text", text: JSON.stringify(data) }] };
+}
+async function userGetBilling({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "GET", url: `/user/billing`, queryParams, ...requestConfig });
+  return { content: [{ type: "text", text: JSON.stringify(data) }] };
+}
+async function userGetPlan({
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "GET", url: `/user/plan`, ...requestConfig });
+  return { content: [{ type: "text", text: JSON.stringify(data) }] };
+}
+async function userGetScopes({
+  config = {}
+}) {
+  const { client: request = schemas.client, ...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.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.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.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.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.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.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.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.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.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.chatsResumePathParamsSchema.shape.chatId, messageId: schemas.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.deploymentsFindLogsPathParamsSchema.shape.deploymentId,
+      queryParams: schemas.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.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.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.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.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) }] };
+    }
+  });
+}
+
+exports.initMcpTools = initMcpTools;

package/dist/mcp.d.cts

@@ -0,0 +1,5 @@
+import { F as FetcherConfig } from './shared/v0-api.B8nEbJhM.cjs';
+
+declare function initMcpTools<Server>(serverLike: Server, config: FetcherConfig): void;
+
+export { initMcpTools };

package/dist/mcp.d.mts

@@ -0,0 +1,5 @@
+import { F as FetcherConfig } from './shared/v0-api.B8nEbJhM.mjs';
+
+declare function initMcpTools<Server>(serverLike: Server, config: FetcherConfig): void;
+
+export { initMcpTools };

package/dist/mcp.d.ts

@@ -0,0 +1,5 @@
+import { F as FetcherConfig } from './shared/v0-api.B8nEbJhM.js';
+
+declare function initMcpTools<Server>(serverLike: Server, config: FetcherConfig): void;
+
+export { initMcpTools };