@upstash/mcp-server 0.2.1 → 0.2.2

package/dist/index.js

@@ -10,6 +10,12 @@ import { createServer } from "http";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 
 // src/log.ts
+import { appendFileSync } from "fs";
+import path from "path";
+var debugLogPath = null;
+function initDebugLog(projectRoot) {
+  debugLogPath = path.resolve(projectRoot, "upstash-debug.log");
+}
 function log(...args) {
   const msg = `[DEBUG ${(/* @__PURE__ */ new Date()).toISOString()}] ${args.map((arg) => typeof arg === "string" ? arg : JSON.stringify(arg)).join(" ")}
 `;
@@ -17,11 +23,25 @@ function log(...args) {
     logs.push(msg);
   }
   process.stderr.write(msg);
+  if (debugLogPath) {
+    try {
+      appendFileSync(debugLogPath, msg);
+    } catch {
+    }
+  }
 }
 var logsStore = /* @__PURE__ */ new Map();
 
 // src/tools/utils.ts
 import { z } from "zod";
+
+// src/tools/helpers.ts
+var json = (value) => typeof value === "string" ? value : JSON.stringify(value, null, 2);
+function tool(t) {
+  return t;
+}
+
+// src/tools/utils.ts
 var utilTools = {
   util_timestamps_to_date: tool({
     description: `Use this tool to convert a timestamp to a human-readable date`,
@@ -49,7 +69,8 @@ import { z as z2 } from "zod";
 // src/config.ts
 var config = {
   apiKey: "",
-  email: ""
+  email: "",
+  disableTelemetry: false
 };
 
 // src/middlewares.ts
@@ -91,27 +112,56 @@ var applyMiddlewares = async (req, func) => {
   return next();
 };
 
+// src/version.ts
+var VERSION = "v0.2.2";
+
+// src/telemetry.ts
+function getRuntime() {
+  var _a, _b, _c;
+  if (globalThis.Bun !== void 0) {
+    return `bun@${globalThis.Bun.version}`;
+  }
+  if (globalThis.Deno !== void 0) {
+    const denoVersion = (_b = (_a = globalThis.Deno) == null ? void 0 : _a.version) == null ? void 0 : _b.deno;
+    return denoVersion ? `deno@${denoVersion}` : "deno";
+  }
+  if (typeof process !== "undefined" && ((_c = process.versions) == null ? void 0 : _c.node)) {
+    return `node@${process.versions.node}`;
+  }
+  return "unknown";
+}
+function getPlatform() {
+  if (typeof process !== "undefined" && process.platform) {
+    return process.platform;
+  }
+  return "unknown";
+}
+var telemetry = {
+  runtime: getRuntime(),
+  platform: getPlatform(),
+  sdk: `@upstash/mcp-server@${VERSION}`
+};
+
 // src/http.ts
-import fetch from "node-fetch";
 var HttpClient = class {
   constructor(config2) {
     this.baseUrl = config2.baseUrl.replace(/\/$/, "");
     this.qstashToken = config2.qstashToken;
   }
-  async get(path, query) {
-    return this.requestWithMiddleware({ method: "GET", path, query });
+  async get(path2, query) {
+    return this.requestWithMiddleware({ method: "GET", path: path2, query });
   }
-  async post(path, body, headers) {
-    return this.requestWithMiddleware({ method: "POST", path, body, headers });
+  async post(path2, body, headers) {
+    return this.requestWithMiddleware({ method: "POST", path: path2, body, headers });
   }
-  async put(path, body, headers) {
-    return this.requestWithMiddleware({ method: "PUT", path, body, headers });
+  async put(path2, body, headers) {
+    return this.requestWithMiddleware({ method: "PUT", path: path2, body, headers });
   }
-  async patch(path, body) {
-    return this.requestWithMiddleware({ method: "PATCH", path, body });
+  async patch(path2, body) {
+    return this.requestWithMiddleware({ method: "PATCH", path: path2, body });
   }
-  async delete(path, body) {
-    return this.requestWithMiddleware({ method: "DELETE", path, body });
+  async delete(path2, body) {
+    return this.requestWithMiddleware({ method: "DELETE", path: path2, body });
   }
   async requestWithMiddleware(req) {
     const res = await applyMiddlewares(req, async (req2) => {
@@ -145,11 +195,17 @@ var HttpClient = class {
       const token = [config.email, config.apiKey].join(":");
       authHeader = `Basic ${Buffer.from(token).toString("base64")}`;
     }
+    const telemetryHeaders = config.disableTelemetry ? {} : {
+      "Upstash-Telemetry-Runtime": telemetry.runtime,
+      "Upstash-Telemetry-Platform": telemetry.platform,
+      "Upstash-Telemetry-Sdk": telemetry.sdk
+    };
     const init = {
       method: req.method,
       headers: {
         "Content-Type": "application/json",
         Authorization: authHeader,
+        ...telemetryHeaders,
         ...req.headers
       }
     };
@@ -269,7 +325,6 @@ var redisBackupTools = {
 
 // src/tools/redis/command.ts
 import { z as z3 } from "zod";
-import fetch2 from "node-fetch";
 var redisCommandTools = {
   redis_database_run_redis_commands: tool({
     description: `Run one or more Redis commands on a specific Upstash redis database. Either provide database_id OR both database_rest_url and database_rest_token.
@@ -308,7 +363,7 @@ NOTE: Multiple commands will be executed as a pipeline for better performance.`,
       const isSingleCommand = commands.length === 1;
       const url = isSingleCommand ? restUrl : restUrl + "/pipeline";
       const body = isSingleCommand ? JSON.stringify(commands[0]) : JSON.stringify(commands);
-      const req = await fetch2(url, {
+      const req = await fetch(url, {
         method: "POST",
         body,
         headers: {
@@ -525,6 +580,7 @@ var parseUsageData = (data) => {
   if (!Array.isArray(data)) return "INVALID DATA";
   if (data.length === 0 || data.length === 1) return "NO DATA";
   const filteredData = data.filter((d) => d.x && d.y);
+  if (filteredData.length === 0) return "NO DATA";
   return {
     start: filteredData[0].x,
     // last one can be null, so use the second last
@@ -543,57 +599,76 @@ var redisTools = {
 };
 
 // src/tools/qstash/qstash.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 
 // src/tools/qstash/utils.ts
-var cachedToken = null;
-var tokenExpiry = 0;
-async function getQStashToken() {
+var LOCAL_QSTASH_TOKEN = "eyJVc2VySUQiOiJkZWZhdWx0VXNlciIsIlBhc3N3b3JkIjoiZGVmYXVsdFBhc3N3b3JkIn0=";
+var REGION_URLS = {
+  eu: "https://qstash-eu-central-1.upstash.io",
+  us: "https://qstash-us-east-1.upstash.io"
+};
+var REGION_API_NAMES = {
+  eu: "eu-central-1",
+  us: "us-east-1"
+};
+var cachedUsers = null;
+var cacheExpiry = 0;
+async function getQStashCredentials(region) {
   const now = Date.now();
-  if (cachedToken && now < tokenExpiry) {
-    return cachedToken;
+  if (!cachedUsers || now >= cacheExpiry) {
+    try {
+      cachedUsers = await http.get("v2/qstash/users");
+      cacheExpiry = now + 60 * 1e3;
+    } catch (error) {
+      throw new Error(
+        `Failed to get QStash credentials: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
   }
-  try {
-    const user = await http.get("qstash/user");
-    cachedToken = user.token;
-    tokenExpiry = now + 60 * 60 * 1e3;
-    return user.token;
-  } catch (error) {
-    throw new Error(
-      `Failed to get QStash token: ${error instanceof Error ? error.message : String(error)}`
-    );
+  const apiRegion = REGION_API_NAMES[region] ?? REGION_API_NAMES["eu"];
+  const match = cachedUsers.find((u) => u.region === apiRegion);
+  if (!match) {
+    throw new Error(`No QStash user found for region '${region}' (${apiRegion})`);
   }
+  return { token: match.token };
 }
-async function createQStashClientWithToken(creds = {}) {
-  if (!(creds == null ? void 0 : creds.token)) {
-    creds.token = await getQStashToken();
+async function createQStashClientWithToken(options) {
+  const { qstash_creds, region, local_mode_port } = options;
+  if (qstash_creds) {
+    return createQStashClient({ url: qstash_creds.url, token: qstash_creds.token });
   }
-  return createQStashClient({
-    url: creds == null ? void 0 : creds.url,
-    token: creds == null ? void 0 : creds.token
-  });
+  if (region === "local") {
+    return createQStashClient({
+      url: `http://localhost:${local_mode_port}`,
+      token: LOCAL_QSTASH_TOKEN
+    });
+  }
+  const effectiveRegion = region && REGION_URLS[region] ? region : "eu";
+  const fetched = await getQStashCredentials(effectiveRegion);
+  return createQStashClient({ url: REGION_URLS[effectiveRegion], token: fetched.token });
 }
 
-// src/tools/qstash/qstash.ts
-var qstashCreds = {
-  qstash_creds: z5.undefined()
-  // qstash_creds: z
-  //   .object({
-  //     url: z.string(),
-  //     token: z.string(),
-  //   })
-  //   .optional()
-  //   .describe(
-  //     "Optional qstash credentials. Use for local qstash connections and external qstash deployments"
-  //   ),
+// src/tools/qstash/common.ts
+import { z as z5 } from "zod";
+var qstashCommon = {
+  region: z5.enum(["eu", "us", "local"]).default("eu").describe("QStash region to use. To use local mode, pick `local`"),
+  local_mode_port: z5.number().default(8080).describe(
+    "Only provide when using local mode and if default does not work, the port is usually in the .env file"
+  ),
+  qstash_creds: z5.object({
+    url: z5.string(),
+    token: z5.string()
+  }).optional().describe("Custom qstash credentials, overrides `region`")
 };
+
+// src/tools/qstash/qstash.ts
 var qstashTools = {
   qstash_get_user_token: tool({
     description: `Get the QSTASH_TOKEN and QSTASH_URL of the current user. This
     is not needed for the mcp tools since the token is automatically fetched from
     the Upstash API for them.`,
     handler: async () => {
-      const user = await http.get("qstash/user");
+      const user = await http.get("v2/qstash/user");
       return [json(user)];
     }
   }),
@@ -601,42 +676,42 @@ var qstashTools = {
     description: `Publish a message to a destination URL using QStash. This
     sends an HTTP request to the specified destination via QStash's message
     queue. This can also be used to trigger a upstash workflow run.`,
-    inputSchema: z5.object({
-      destination: z5.string().describe("The destination URL to send the message to (e.g., 'https://example.com')"),
-      body: z5.string().optional().describe("Request body (JSON string or plain text)"),
-      method: z5.enum(["GET", "POST", "PUT", "DELETE", "PATCH"]).optional().describe("HTTP method (optional, defaults to POST)").default("POST"),
-      delay: z5.string().optional().describe("Delay before message delivery (e.g., '10s', '5m', '1h')"),
-      retries: z5.number().optional().describe("Number of retries on failure, default is 3"),
-      callback: z5.string().optional().describe("Callback URL that will be called when the message is successfully delivered"),
-      failureCallback: z5.string().optional().describe("Callback URL that will be called when the message is failed to deliver"),
-      timeout: z5.string().optional().describe("Request timeout (e.g., '30s', '1h')"),
-      queueName: z5.string().optional().describe(
+    inputSchema: z6.object({
+      destination: z6.string().describe("The destination URL to send the message to (e.g., 'https://example.com')"),
+      body: z6.string().optional().describe("Request body (JSON string or plain text)"),
+      method: z6.enum(["GET", "POST", "PUT", "DELETE", "PATCH"]).optional().describe("HTTP method (optional, defaults to POST)").default("POST"),
+      delay: z6.string().optional().describe("Delay before message delivery (e.g., '10s', '5m', '1h')"),
+      retries: z6.number().optional().describe("Number of retries on failure, default is 3"),
+      callback: z6.string().optional().describe("Callback URL that will be called when the message is successfully delivered"),
+      failureCallback: z6.string().optional().describe("Callback URL that will be called when the message is failed to deliver"),
+      timeout: z6.string().optional().describe("Request timeout (e.g., '30s', '1h')"),
+      queueName: z6.string().optional().describe(
         "Queue name to use, you have to first create the queue in upstash. Prefer the flow control key instead"
       ),
-      flow_control: z5.object({
-        key: z5.string().describe("Unique identifier for grouping messages under same flow control rules"),
-        parallelism: z5.number().optional().describe("Max concurrent active calls (default: unlimited)"),
-        rate: z5.number().optional().describe("Max calls per period (default: unlimited)"),
-        period: z5.string().optional().describe("Time window for rate limit (e.g., '1s', '1m', '1h', default: '1s')")
+      flow_control: z6.object({
+        key: z6.string().describe("Unique identifier for grouping messages under same flow control rules"),
+        parallelism: z6.number().optional().describe("Max concurrent active calls (default: unlimited)"),
+        rate: z6.number().optional().describe("Max calls per period (default: unlimited)"),
+        period: z6.string().optional().describe("Time window for rate limit (e.g., '1s', '1m', '1h', default: '1s')")
       }).optional().describe("Flow control for rate limiting and parallelism management"),
-      extraHeaders: z5.record(z5.string()).optional().describe("Extra headers to add to the request"),
-      ...qstashCreds
+      extraHeaders: z6.record(z6.string()).optional().describe("Extra headers to add to the request"),
+      ...qstashCommon
     }),
-    handler: async ({
-      destination,
-      body,
-      method,
-      extraHeaders,
-      delay,
-      retries,
-      callback,
-      failureCallback,
-      timeout,
-      queueName,
-      flow_control,
-      qstash_creds
-    }) => {
-      const client = await createQStashClientWithToken(qstash_creds);
+    handler: async (params) => {
+      const {
+        destination,
+        body,
+        method,
+        extraHeaders,
+        delay,
+        retries,
+        callback,
+        failureCallback,
+        timeout,
+        queueName,
+        flow_control
+      } = params;
+      const client = await createQStashClientWithToken(params);
       const requestHeaders = {};
       if (method) {
         requestHeaders["Upstash-Method"] = method;
@@ -687,10 +762,10 @@ var qstashTools = {
   }),
   qstash_logs_list: tool({
     description: `List QStash logs with optional filtering. Returns a paginated list of message logs without their bodies.`,
-    inputSchema: z5.object({
-      cursor: z5.string().optional().describe("Cursor for pagination"),
-      messageId: z5.string().optional().describe("Filter logs by message ID"),
-      state: z5.enum([
+    inputSchema: z6.object({
+      cursor: z6.string().optional().describe("Cursor for pagination"),
+      messageId: z6.string().optional().describe("Filter logs by message ID"),
+      state: z6.enum([
         "CREATED",
         "ACTIVE",
         "RETRY",
@@ -701,21 +776,27 @@ var qstashTools = {
         "CANCEL_REQUESTED",
         "CANCELLED"
       ]).optional().describe("Filter logs by state"),
-      url: z5.string().optional().describe("Filter logs by URL"),
-      topicName: z5.string().optional().describe("Filter logs by topic name"),
-      scheduleId: z5.string().optional().describe("Filter logs by schedule ID"),
-      queueName: z5.string().optional().describe("Filter logs by queue name"),
-      fromDate: z5.number().optional().describe("Filter logs from date (Unix timestamp in milliseconds)"),
-      toDate: z5.number().optional().describe("Filter logs to date (Unix timestamp in milliseconds)"),
-      count: z5.number().max(1e3).optional().describe("Number of logs to return (max 1000)"),
-      ...qstashCreds
+      url: z6.string().optional().describe("Filter logs by URL"),
+      topicName: z6.string().optional().describe("Filter logs by topic name"),
+      scheduleId: z6.string().optional().describe("Filter logs by schedule ID"),
+      queueName: z6.string().optional().describe("Filter logs by queue name"),
+      fromDate: z6.number().optional().describe("Filter logs from date (Unix timestamp in milliseconds)"),
+      toDate: z6.number().optional().describe("Filter logs to date (Unix timestamp in milliseconds)"),
+      count: z6.number().max(1e3).optional().describe("Number of logs to return (max 1000)"),
+      ...qstashCommon
     }),
     handler: async (params) => {
-      const client = await createQStashClientWithToken(params.qstash_creds);
+      const {
+        region: _region,
+        local_mode_port: _local_mode_port,
+        qstash_creds: _qstash_creds,
+        ...query
+      } = params;
+      const client = await createQStashClientWithToken(params);
       const response = await client.get("v2/logs", {
         trimBody: 0,
         groupBy: "messageId",
-        ...params
+        ...query
       });
       const firstMessageFields = Object.fromEntries(
         Object.entries(response.messages[0] ?? {}).filter(
@@ -738,12 +819,13 @@ var qstashTools = {
   }),
   qstash_logs_get: tool({
     description: `Get details of a single QStash log item by message ID without trimming the body.`,
-    inputSchema: z5.object({
-      messageId: z5.string().describe("The message ID to get details for"),
-      ...qstashCreds
+    inputSchema: z6.object({
+      messageId: z6.string().describe("The message ID to get details for"),
+      ...qstashCommon
     }),
-    handler: async ({ messageId, qstash_creds }) => {
-      const client = await createQStashClientWithToken(qstash_creds);
+    handler: async (params) => {
+      const { messageId } = params;
+      const client = await createQStashClientWithToken(params);
       const response = await client.get("v2/logs", { messageId });
       if (response.messages.length === 0) {
         return "No log entry found for the specified message ID";
@@ -754,25 +836,31 @@ var qstashTools = {
   }),
   qstash_dlq_list: tool({
     description: `List messages in the QStash Dead Letter Queue (DLQ) with optional filtering.`,
-    inputSchema: z5.object({
-      cursor: z5.string().optional().describe("Cursor for pagination"),
-      messageId: z5.string().optional().describe("Filter DLQ messages by message ID"),
-      url: z5.string().optional().describe("Filter DLQ messages by URL"),
-      topicName: z5.string().optional().describe("Filter DLQ messages by topic name"),
-      scheduleId: z5.string().optional().describe("Filter DLQ messages by schedule ID"),
-      queueName: z5.string().optional().describe("Filter DLQ messages by queue name"),
-      fromDate: z5.number().optional().describe("Filter from date (Unix timestamp in milliseconds)"),
-      toDate: z5.number().optional().describe("Filter to date (Unix timestamp in milliseconds)"),
-      responseStatus: z5.number().optional().describe("Filter by HTTP response status code"),
-      callerIp: z5.string().optional().describe("Filter by IP address of the publisher"),
-      count: z5.number().max(100).optional().describe("Number of messages to return (max 100)"),
-      ...qstashCreds
+    inputSchema: z6.object({
+      cursor: z6.string().optional().describe("Cursor for pagination"),
+      messageId: z6.string().optional().describe("Filter DLQ messages by message ID"),
+      url: z6.string().optional().describe("Filter DLQ messages by URL"),
+      topicName: z6.string().optional().describe("Filter DLQ messages by topic name"),
+      scheduleId: z6.string().optional().describe("Filter DLQ messages by schedule ID"),
+      queueName: z6.string().optional().describe("Filter DLQ messages by queue name"),
+      fromDate: z6.number().optional().describe("Filter from date (Unix timestamp in milliseconds)"),
+      toDate: z6.number().optional().describe("Filter to date (Unix timestamp in milliseconds)"),
+      responseStatus: z6.number().optional().describe("Filter by HTTP response status code"),
+      callerIp: z6.string().optional().describe("Filter by IP address of the publisher"),
+      count: z6.number().max(100).optional().describe("Number of messages to return (max 100)"),
+      ...qstashCommon
     }),
     handler: async (params) => {
-      const client = await createQStashClientWithToken(params.qstash_creds);
+      const {
+        region: _region,
+        local_mode_port: _local_mode_port,
+        qstash_creds: _qstash_creds,
+        ...query
+      } = params;
+      const client = await createQStashClientWithToken(params);
       const response = await client.get("v2/dlq", {
         trimBody: 0,
-        ...params
+        ...query
       });
       return [
         `Found ${response.messages.length} DLQ messages`,
@@ -783,59 +871,63 @@ var qstashTools = {
   }),
   qstash_dlq_get: tool({
     description: `Get details of a single DLQ message by DLQ ID.`,
-    inputSchema: z5.object({
-      dlqId: z5.string().describe("The DLQ ID of the message to retrieve"),
-      ...qstashCreds
+    inputSchema: z6.object({
+      dlqId: z6.string().describe("The DLQ ID of the message to retrieve"),
+      ...qstashCommon
     }),
-    handler: async ({ dlqId, qstash_creds }) => {
-      const client = await createQStashClientWithToken(qstash_creds);
+    handler: async (params) => {
+      const { dlqId } = params;
+      const client = await createQStashClientWithToken(params);
       const message = await client.get(`v2/dlq/${dlqId}`);
       return [`DLQ message details for ID: ${dlqId}`, json(message)];
     }
   }),
   qstash_schedules_list: tool({
     description: `List all QStash schedules.`,
-    handler: async ({ qstash_creds }) => {
-      const client = await createQStashClientWithToken(qstash_creds);
+    inputSchema: z6.object({
+      ...qstashCommon
+    }),
+    handler: async (params) => {
+      const client = await createQStashClientWithToken(params);
       const schedules = await client.get("v2/schedules");
       return [`Found ${schedules.length} schedules`, json(schedules)];
     }
   }),
   qstash_schedules_manage: tool({
     description: `Create, update, or manage QStash schedules. This tool handles create, update (by providing scheduleId), pause, resume, and delete operations in one unified interface.`,
-    inputSchema: z5.object({
-      operation: z5.enum(["create", "update", "pause", "resume", "delete"]).describe("The operation to perform"),
-      scheduleId: z5.string().optional().describe("Schedule ID (required for update, pause, resume, delete operations)"),
-      destination: z5.string().optional().describe("Destination URL or topic name (required for create/update)"),
-      cron: z5.string().optional().describe("Cron expression (required for create/update)"),
-      method: z5.enum(["GET", "POST", "PUT", "DELETE", "PATCH"]).optional().describe("HTTP method (optional, defaults to POST)"),
-      headers: z5.record(z5.string()).optional().describe("Request headers as key-value pairs"),
-      body: z5.string().optional().describe("Request body"),
-      delay: z5.string().optional().describe("Delay before message delivery (e.g., '10s', '5m', '1h')"),
-      retries: z5.number().optional().describe("Number of retries on failure"),
-      callback: z5.string().optional().describe("Callback URL for successful delivery"),
-      failureCallback: z5.string().optional().describe("Callback URL for failed delivery"),
-      timeout: z5.string().optional().describe("Request timeout (e.g., '30s')"),
-      queueName: z5.string().optional().describe("Queue name to use"),
-      ...qstashCreds
+    inputSchema: z6.object({
+      operation: z6.enum(["create", "update", "pause", "resume", "delete"]).describe("The operation to perform"),
+      scheduleId: z6.string().optional().describe("Schedule ID (required for update, pause, resume, delete operations)"),
+      destination: z6.string().optional().describe("Destination URL or topic name (required for create/update)"),
+      cron: z6.string().optional().describe("Cron expression (required for create/update)"),
+      method: z6.enum(["GET", "POST", "PUT", "DELETE", "PATCH"]).optional().describe("HTTP method (optional, defaults to POST)"),
+      headers: z6.record(z6.string()).optional().describe("Request headers as key-value pairs"),
+      body: z6.string().optional().describe("Request body"),
+      delay: z6.string().optional().describe("Delay before message delivery (e.g., '10s', '5m', '1h')"),
+      retries: z6.number().optional().describe("Number of retries on failure"),
+      callback: z6.string().optional().describe("Callback URL for successful delivery"),
+      failureCallback: z6.string().optional().describe("Callback URL for failed delivery"),
+      timeout: z6.string().optional().describe("Request timeout (e.g., '30s')"),
+      queueName: z6.string().optional().describe("Queue name to use"),
+      ...qstashCommon
     }),
-    handler: async ({
-      operation,
-      scheduleId,
-      destination,
-      cron,
-      method = "POST",
-      headers,
-      body,
-      delay,
-      retries,
-      callback,
-      failureCallback,
-      timeout,
-      queueName,
-      qstash_creds
-    }) => {
-      const client = await createQStashClientWithToken(qstash_creds);
+    handler: async (params) => {
+      const {
+        operation,
+        scheduleId,
+        destination,
+        cron,
+        method = "POST",
+        headers,
+        body,
+        delay,
+        retries,
+        callback,
+        failureCallback,
+        timeout,
+        queueName
+      } = params;
+      const client = await createQStashClientWithToken(params);
       switch (operation) {
         case "create":
         case "update": {
@@ -915,25 +1007,31 @@ var qstashTools = {
 };
 
 // src/tools/qstash/workflow.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var workflowTools = {
   workflow_logs_list: tool({
     description: `List Upstash Workflow logs with optional filtering. Returns grouped workflow runs with their execution details.`,
-    inputSchema: z6.object({
-      cursor: z6.string().optional().describe("Cursor for pagination"),
-      workflowRunId: z6.string().optional().describe("Filter by specific workflow run ID"),
-      count: z6.number().optional().describe("Number of workflow runs to return"),
-      state: z6.enum(["RUN_STARTED", "RUN_SUCCESS", "RUN_FAILED", "RUN_CANCELED"]).optional().describe("Filter by workflow state"),
-      workflowUrl: z6.string().optional().describe("Filter by workflow URL (exact match)"),
-      workflowCreatedAt: z6.number().optional().describe("Filter by workflow creation timestamp (Unix timestamp)"),
-      ...qstashCreds
+    inputSchema: z7.object({
+      cursor: z7.string().optional().describe("Cursor for pagination"),
+      workflowRunId: z7.string().optional().describe("Filter by specific workflow run ID"),
+      count: z7.number().optional().describe("Number of workflow runs to return"),
+      state: z7.enum(["RUN_STARTED", "RUN_SUCCESS", "RUN_FAILED", "RUN_CANCELED"]).optional().describe("Filter by workflow state"),
+      workflowUrl: z7.string().optional().describe("Filter by workflow URL (exact match)"),
+      workflowCreatedAt: z7.number().optional().describe("Filter by workflow creation timestamp (Unix timestamp)"),
+      ...qstashCommon
     }),
     handler: async (params) => {
-      const client = await createQStashClientWithToken(params.qstash_creds);
+      const {
+        region: _region,
+        local_mode_port: _local_mode_port,
+        qstash_creds: _qstash_creds,
+        ...query
+      } = params;
+      const client = await createQStashClientWithToken(params);
       const response = await client.get("v2/workflows/events", {
         trimBody: 0,
         groupBy: "workflowRunId",
-        ...params
+        ...query
       });
       const cleaned = response.runs.map(
         (run) => Object.fromEntries(Object.entries(run).filter(([key, _value]) => key !== "steps"))
@@ -952,16 +1050,20 @@ var workflowTools = {
     description: `Get details of a single workflow run by workflow run ID. There
     could be multiple workflow runs with the same workflow run ID, so you can
     use the workflowCreatedAt to get the details of the specific workflow run.`,
-    inputSchema: z6.object({
-      workflowRunId: z6.string().describe("The workflow run ID to get details for"),
-      workflowCreatedAt: z6.number().optional().describe("The workflow creation timestamp (Unix timestamp)"),
-      ...qstashCreds
+    inputSchema: z7.object({
+      workflowRunId: z7.string().describe("The workflow run ID to get details for"),
+      workflowCreatedAt: z7.number().optional().describe("The workflow creation timestamp (Unix timestamp)"),
+      ...qstashCommon
     }),
     handler: async (params) => {
-      const client = await createQStashClientWithToken(params.qstash_creds);
-      const response = await client.get("v2/workflows/logs", {
-        ...params
-      });
+      const {
+        region: _region,
+        local_mode_port: _local_mode_port,
+        qstash_creds: _qstash_creds,
+        ...query
+      } = params;
+      const client = await createQStashClientWithToken(params);
+      const response = await client.get("v2/workflows/logs", query);
       if (response.runs.length === 0) {
         return "No workflow run found";
       }
@@ -974,22 +1076,28 @@ var workflowTools = {
   }),
   workflow_dlq_list: tool({
     description: `List failed workflow runs in the Dead Letter Queue (DLQ) with optional filtering.`,
-    inputSchema: z6.object({
-      cursor: z6.string().optional().describe("Cursor for pagination"),
-      workflowRunId: z6.string().optional().describe("Filter by workflow run ID"),
-      workflowUrl: z6.string().optional().describe("Filter by workflow URL"),
-      fromDate: z6.number().optional().describe("Filter from date (Unix timestamp in milliseconds)"),
-      toDate: z6.number().optional().describe("Filter to date (Unix timestamp in milliseconds)"),
-      responseStatus: z6.number().optional().describe("Filter by HTTP response status code"),
-      callerIP: z6.string().optional().describe("Filter by IP address of the caller"),
-      failureCallbackState: z6.string().optional().describe("Filter by failure callback state"),
-      count: z6.number().optional().describe("Number of DLQ messages to return"),
-      ...qstashCreds
+    inputSchema: z7.object({
+      cursor: z7.string().optional().describe("Cursor for pagination"),
+      workflowRunId: z7.string().optional().describe("Filter by workflow run ID"),
+      workflowUrl: z7.string().optional().describe("Filter by workflow URL"),
+      fromDate: z7.number().optional().describe("Filter from date (Unix timestamp in milliseconds)"),
+      toDate: z7.number().optional().describe("Filter to date (Unix timestamp in milliseconds)"),
+      responseStatus: z7.number().optional().describe("Filter by HTTP response status code"),
+      callerIP: z7.string().optional().describe("Filter by IP address of the caller"),
+      failureCallbackState: z7.string().optional().describe("Filter by failure callback state"),
+      count: z7.number().optional().describe("Number of DLQ messages to return"),
+      ...qstashCommon
     }),
     handler: async (params) => {
-      const client = await createQStashClientWithToken(params.qstash_creds);
+      const {
+        region: _region,
+        local_mode_port: _local_mode_port,
+        qstash_creds: _qstash_creds,
+        ...query
+      } = params;
+      const client = await createQStashClientWithToken(params);
       const response = await client.get("v2/workflows/dlq", {
-        ...params,
+        ...query,
         trimBody: 0
       });
       const cleaned = response.messages.map(
@@ -1007,27 +1115,28 @@ var workflowTools = {
   }),
   workflow_dlq_get: tool({
     description: `Get details of a single failed workflow run from the DLQ by DLQ ID.`,
-    inputSchema: z6.object({
-      dlqId: z6.string().describe("The DLQ ID of the failed workflow run to retrieve"),
-      ...qstashCreds
+    inputSchema: z7.object({
+      dlqId: z7.string().describe("The DLQ ID of the failed workflow run to retrieve"),
+      ...qstashCommon
     }),
     handler: async (params) => {
-      const client = await createQStashClientWithToken(params.qstash_creds);
+      const client = await createQStashClientWithToken(params);
       const message = await client.get(`v2/workflows/dlq/${params.dlqId}`);
       return [`Failed workflow run details for DLQ ID: ${params.dlqId}`, json(message)];
     }
   }),
   workflow_dlq_manage: tool({
     description: `Delete, restart, and resume failed workflow runs in the DLQ using only the DLQ ID.`,
-    inputSchema: z6.object({
-      dlqId: z6.string().describe("The DLQ ID of the failed workflow run"),
-      action: z6.enum(["delete", "restart", "resume"]).describe(
+    inputSchema: z7.object({
+      dlqId: z7.string().describe("The DLQ ID of the failed workflow run"),
+      action: z7.enum(["delete", "restart", "resume"]).describe(
         "The action to perform: delete (remove from DLQ), restart (from beginning), or resume (from the failed step)"
       ),
-      ...qstashCreds
+      ...qstashCommon
     }),
-    handler: async ({ dlqId, action, qstash_creds }) => {
-      const client = await createQStashClientWithToken(qstash_creds);
+    handler: async (params) => {
+      const { dlqId, action } = params;
+      const client = await createQStashClientWithToken(params);
       switch (action) {
         case "delete": {
           await client.delete(`v2/workflows/dlq/delete/${dlqId}`);
@@ -1061,14 +1170,10 @@ var qstashAllTools = {
 };
 
 // src/tools/index.ts
-var json = (json2) => typeof json2 === "string" ? json2 : JSON.stringify(json2, null, 2);
 var tools = {
   ...redisTools,
   ...qstashAllTools
 };
-function tool(tool2) {
-  return tool2;
-}
 
 // src/settings.ts
 var MAX_MESSAGE_LENGTH = 3e4;
@@ -1087,7 +1192,7 @@ function handlerResponseToCallResult(response) {
 }
 
 // src/server.ts
-import z7 from "zod";
+import z8 from "zod";
 function createServerInstance() {
   const server = new McpServer(
     { name: "upstash", version: "0.1.0" },
@@ -1111,7 +1216,7 @@ function createServerInstance() {
       toolName,
       {
         description: tool2.description,
-        inputSchema: (tool2.inputSchema ?? z7.object({})).shape
+        inputSchema: (tool2.inputSchema ?? z8.object({})).shape
       },
       // @ts-expect-error - Just ignore the types here
       async (args) => {
@@ -1171,10 +1276,13 @@ var argv = process.argv.slice(2);
 if (argv.length >= 3 && argv[0] === "run") {
   argv = ["--email", argv[1], "--api-key", argv[2], ...argv.slice(3)];
 }
-var program = new Command().option("--transport <stdio|http>", "transport type", "stdio").option("--port <number>", "port for HTTP transport", "3000").option("--email <email>", "Upstash email").option("--api-key <key>", "Upstash API key").option("--debug", "Enable debug mode").allowUnknownOption();
+var program = new Command().option("--transport <stdio|http>", "transport type", "stdio").option("--port <number>", "port for HTTP transport", "3000").option("--email <email>", "Upstash email").option("--api-key <key>", "Upstash API key").option("--debug", "Enable debug mode").option("--disable-telemetry", "Disable telemetry headers sent to Upstash APIs").allowUnknownOption();
 program.parse(argv, { from: "user" });
 var cliOptions = program.opts();
 var DEBUG = cliOptions.debug ?? false;
+if (DEBUG) {
+  initDebugLog(new URL("../", import.meta.url).pathname);
+}
 var allowedTransports = ["stdio", "http"];
 if (!allowedTransports.includes(cliOptions.transport)) {
   console.error(
@@ -1203,6 +1311,7 @@ async function main() {
   }
   config.email = email;
   config.apiKey = apiKey;
+  config.disableTelemetry = cliOptions.disableTelemetry ?? false;
   await testConnection();
   const transportType = TRANSPORT_TYPE;
   if (transportType === "http") {