@alisaitteke/temporal-mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,2254 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+
+// src/client.ts
+var TemporalError = class extends Error {
+  constructor(status, message, details) {
+    super(message);
+    this.status = status;
+    this.details = details;
+    this.name = "TemporalError";
+  }
+};
+var TemporalClient = class {
+  baseUrl;
+  defaultNamespace;
+  headers;
+  constructor(config) {
+    this.baseUrl = config.address.replace(/\/$/, "");
+    this.defaultNamespace = config.defaultNamespace;
+    this.headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      ...config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {}
+    };
+  }
+  /** Resolves namespace: uses provided value or falls back to the configured default. */
+  ns(namespace) {
+    return namespace ?? this.defaultNamespace;
+  }
+  // ─── Core HTTP helpers ────────────────────────────────────────────────────
+  async get(path, params) {
+    const url = this.buildUrl(path, params);
+    const res = await fetch(url, { headers: this.headers });
+    return this.parseResponse(res);
+  }
+  async post(path, body) {
+    const url = this.buildUrl(path);
+    const res = await fetch(url, {
+      method: "POST",
+      headers: this.headers,
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+    return this.parseResponse(res);
+  }
+  async delete(path, body) {
+    const url = this.buildUrl(path);
+    const res = await fetch(url, {
+      method: "DELETE",
+      headers: this.headers,
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+    return this.parseResponse(res);
+  }
+  // ─── Private helpers ──────────────────────────────────────────────────────
+  buildUrl(path, params) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0 && value !== null && value !== "") {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+  async parseResponse(res) {
+    const text = await res.text();
+    if (!res.ok) {
+      let message = `HTTP ${res.status}: ${res.statusText}`;
+      let details;
+      try {
+        const err = JSON.parse(text);
+        message = err.message ?? message;
+        details = err.details;
+      } catch {
+        if (text) message = text;
+      }
+      throw new TemporalError(res.status, message, details);
+    }
+    if (!text) return {};
+    try {
+      return JSON.parse(text);
+    } catch {
+      throw new TemporalError(200, `Failed to parse response body: ${text}`);
+    }
+  }
+};
+function createClientFromEnv() {
+  const address = process.env.TEMPORAL_ADDRESS;
+  if (!address) {
+    throw new Error(
+      "TEMPORAL_ADDRESS environment variable is required (e.g. http://localhost:8080)"
+    );
+  }
+  return new TemporalClient({
+    address,
+    defaultNamespace: process.env.TEMPORAL_NAMESPACE ?? "default",
+    apiKey: process.env.TEMPORAL_API_KEY
+  });
+}
+var clusterToolDefinitions = [
+  {
+    name: "get_cluster_info",
+    description: "Get Temporal cluster information including server version, supported features, and system info. Use this first to verify connectivity and check what capabilities are available.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  }
+];
+var getClusterInfoSchema = z.object({});
+async function handleGetClusterInfo(_args, client) {
+  const [clusterInfo, systemInfo] = await Promise.all([
+    client.get("/api/v1/cluster-info"),
+    client.get("/api/v1/system-info")
+  ]);
+  const lines = [
+    "# Temporal Cluster Info",
+    "",
+    "## Cluster"
+  ];
+  if (clusterInfo.clusterId) lines.push(`- Cluster ID: ${clusterInfo.clusterId}`);
+  if (clusterInfo.serverVersion) lines.push(`- Server Version: ${clusterInfo.serverVersion}`);
+  if (clusterInfo.clusterName) lines.push(`- Cluster Name: ${clusterInfo.clusterName}`);
+  if (clusterInfo.historyShardCount) lines.push(`- History Shard Count: ${clusterInfo.historyShardCount}`);
+  lines.push("", "## System");
+  const caps = systemInfo.capabilities;
+  if (caps) {
+    const enabledCaps = Object.entries(caps).filter(([, v]) => v === true).map(([k]) => k);
+    if (enabledCaps.length > 0) {
+      lines.push("Enabled capabilities:");
+      enabledCaps.forEach((c) => lines.push(`  - ${c}`));
+    }
+  }
+  if (systemInfo.serverVersion) lines.push(`- Server Version: ${systemInfo.serverVersion}`);
+  return {
+    content: [{ type: "text", text: lines.join("\n") }],
+    structuredContent: {
+      clusterId: clusterInfo.clusterId,
+      clusterName: clusterInfo.clusterName,
+      serverVersion: clusterInfo.serverVersion ?? systemInfo.serverVersion,
+      historyShardCount: clusterInfo.historyShardCount,
+      capabilities: caps ? Object.keys(caps).filter((k) => caps[k] === true) : []
+    }
+  };
+}
+var namespaceToolDefinitions = [
+  {
+    name: "list_namespaces",
+    description: "List all Temporal namespaces in the cluster.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        page_size: {
+          type: "number",
+          description: "Maximum number of namespaces to return (default 100)."
+        },
+        next_page_token: {
+          type: "string",
+          description: "Pagination token from a previous list_namespaces call."
+        }
+      },
+      required: []
+    }
+  },
+  {
+    name: "describe_namespace",
+    description: "Get detailed configuration and status for a specific namespace.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: {
+          type: "string",
+          description: 'Namespace name (e.g. "default", "my-team").'
+        }
+      },
+      required: ["namespace"]
+    }
+  }
+];
+var listNamespacesSchema = z.object({
+  page_size: z.number().optional().describe("Maximum number of namespaces to return"),
+  next_page_token: z.string().optional().describe("Pagination cursor from previous call")
+});
+var describeNamespaceSchema = z.object({
+  namespace: z.string().describe("Namespace name")
+});
+async function handleListNamespaces(args, client) {
+  const data = await client.get("/api/v1/namespaces", {
+    pageSize: args.page_size,
+    nextPageToken: args.next_page_token
+  });
+  const namespaces = data.namespaces ?? [];
+  const lines = [`# Namespaces (${namespaces.length})`, ""];
+  for (const ns of namespaces) {
+    const info = ns.namespaceInfo;
+    const config = ns.config;
+    lines.push(`## ${info?.name ?? "unknown"}`);
+    if (info?.state) lines.push(`- State: ${info.state}`);
+    if (info?.description) lines.push(`- Description: ${info.description}`);
+    if (info?.ownerEmail) lines.push(`- Owner: ${info.ownerEmail}`);
+    if (config?.workflowExecutionRetentionPeriod)
+      lines.push(`- Retention: ${config.workflowExecutionRetentionPeriod}`);
+    lines.push("");
+  }
+  if (data.nextPageToken) {
+    lines.push(`*Next page token: ${data.nextPageToken}*`);
+  }
+  return {
+    content: [{ type: "text", text: lines.join("\n") }],
+    structuredContent: {
+      namespaces: namespaces.map((ns) => {
+        const info = ns.namespaceInfo;
+        const config = ns.config;
+        return {
+          name: info?.name,
+          state: info?.state,
+          description: info?.description,
+          ownerEmail: info?.ownerEmail,
+          retention: config?.workflowExecutionRetentionPeriod
+        };
+      }),
+      nextPageToken: data.nextPageToken
+    }
+  };
+}
+async function handleDescribeNamespace(args, client) {
+  const ns = args.namespace ?? client.ns();
+  const data = await client.get(`/api/v1/namespaces/${encodeURIComponent(ns)}`);
+  const info = data.namespaceInfo;
+  const config = data.config;
+  const repConfig = data.replicationConfig;
+  const lines = [`# Namespace: ${info?.name ?? ns}`, ""];
+  if (info?.state) lines.push(`- State: ${info.state}`);
+  if (info?.description) lines.push(`- Description: ${info.description}`);
+  if (info?.ownerEmail) lines.push(`- Owner Email: ${info.ownerEmail}`);
+  if (config?.workflowExecutionRetentionPeriod)
+    lines.push(`- Workflow Retention: ${config.workflowExecutionRetentionPeriod}`);
+  if (repConfig?.activeClusterName)
+    lines.push(`- Active Cluster: ${repConfig.activeClusterName}`);
+  const clusters = repConfig?.clusters;
+  if (clusters?.length) {
+    lines.push(`- Clusters: ${clusters.map((c) => c.clusterName).join(", ")}`);
+  }
+  return { content: [{ type: "text", text: lines.join("\n") }] };
+}
+var workflowToolDefinitions = [
+  {
+    name: "count_workflows",
+    description: "Count workflow executions matching an optional visibility query. Useful for dashboards and health checks.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: { type: "string", description: "Target namespace." },
+        query: {
+          type: "string",
+          description: `Visibility query filter (e.g. "ExecutionStatus='Running'"). Leave empty to count all.`
+        }
+      },
+      required: []
+    }
+  },
+  {
+    name: "pause_workflow",
+    description: "Pause a running workflow execution. The workflow will stop scheduling new tasks until unpaused.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: { type: "string", description: "Namespace containing the workflow." },
+        workflow_id: { type: "string", description: "Workflow ID to pause." },
+        run_id: { type: "string", description: "Specific run ID (optional)." },
+        reason: { type: "string", description: "Human-readable reason for pausing." }
+      },
+      required: ["workflow_id"]
+    }
+  },
+  {
+    name: "unpause_workflow",
+    description: "Resume a previously paused workflow execution.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: { type: "string", description: "Namespace containing the workflow." },
+        workflow_id: { type: "string", description: "Workflow ID to unpause." },
+        run_id: { type: "string", description: "Specific run ID (optional)." }
+      },
+      required: ["workflow_id"]
+    }
+  },
+  {
+    name: "signal_with_start_workflow",
+    description: "Start a workflow and send a signal atomically. If the workflow is already running, only the signal is sent. Ideal for event-driven patterns.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: { type: "string", description: "Target namespace." },
+        workflow_id: { type: "string", description: "Workflow ID to start or signal." },
+        workflow_type: { type: "string", description: "Workflow type to start if not already running." },
+        task_queue: { type: "string", description: "Task queue for the workflow." },
+        signal_name: { type: "string", description: "Signal name to send." },
+        signal_input: { description: "Signal payload. Will be JSON-encoded." },
+        workflow_input: { description: "Workflow start input (used only if starting fresh)." }
+      },
+      required: ["workflow_id", "workflow_type", "task_queue", "signal_name"]
+    }
+  },
+  {
+    name: "list_workflows",
+    description: "List or search workflow executions in a namespace. Supports Temporal's query syntax (e.g. `WorkflowType='OrderWorkflow' AND ExecutionStatus='Running'`). Returns status, type, start time, and IDs.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: {
+          type: "string",
+          description: "Namespace to query. Defaults to the configured TEMPORAL_NAMESPACE."
+        },
+        query: {
+          type: "string",
+          description: "Temporal visibility query (SQL-like filter). Leave empty to list all workflows."
+        },
+        page_size: {
+          type: "number",
+          description: "Maximum number of results (default 20, max 1000)."
+        },
+        next_page_token: {
+          type: "string",
+          description: "Pagination cursor from a previous list_workflows call."
+        }
+      },
+      required: []
+    }
+  },
+  {
+    name: "describe_workflow",
+    description: "Get full details for a specific workflow execution: status, workflow type, task queue, start/close time, memo, and search attributes.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: { type: "string", description: "Namespace containing the workflow." },
+        workflow_id: { type: "string", description: "Workflow ID to describe." },
+        run_id: {
+          type: "string",
+          description: "Specific run ID. Omit to get the latest run."
+        }
+      },
+      required: ["workflow_id"]
+    }
+  },
+  {
+    name: "start_workflow",
+    description: "Start a new workflow execution. Returns the run ID of the newly started workflow.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: { type: "string", description: "Target namespace." },
+        workflow_id: {
+          type: "string",
+          description: "Unique workflow ID. If a workflow with this ID already exists, behavior depends on the ID reuse policy."
+        },
+        workflow_type: {
+          type: "string",
+          description: "Registered workflow type / function name."
+        },
+        task_queue: {
+          type: "string",
+          description: "Task queue name where workers are polling."
+        },
+        input: {
+          description: "Workflow input payload. Will be JSON-encoded."
+        }
+      },
+      required: ["workflow_id", "workflow_type", "task_queue"]
+    }
+  },
+  {
+    name: "signal_workflow",
+    description: "Send a signal to a running workflow execution.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: { type: "string", description: "Namespace containing the workflow." },
+        workflow_id: { type: "string", description: "Target workflow ID." },
+        run_id: { type: "string", description: "Specific run ID (optional, targets latest if omitted)." },
+        signal_name: { type: "string", description: "Signal name as registered in the workflow." },
+        input: { description: "Signal payload. Will be JSON-encoded." }
+      },
+      required: ["workflow_id", "signal_name"]
+    }
+  },
+  {
+    name: "query_workflow",
+    description: "Query a workflow's current state using a registered query handler.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: { type: "string", description: "Namespace containing the workflow." },
+        workflow_id: { type: "string", description: "Target workflow ID." },
+        run_id: { type: "string", description: "Specific run ID (optional)." },
+        query_type: {
+          type: "string",
+          description: 'Query type name as registered in the workflow (e.g. "getStatus", "__stack_trace").'
+        },
+        query_args: { description: "Optional query arguments. Will be JSON-encoded." }
+      },
+      required: ["workflow_id", "query_type"]
+    }
+  },
+  {
+    name: "cancel_workflow",
+    description: "Request graceful cancellation of a workflow execution. The workflow will receive a CancellationRequested event and can clean up before stopping.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: { type: "string", description: "Namespace containing the workflow." },
+        workflow_id: { type: "string", description: "Workflow ID to cancel." },
+        run_id: { type: "string", description: "Specific run ID (optional)." },
+        reason: { type: "string", description: "Human-readable reason for cancellation." }
+      },
+      required: ["workflow_id"]
+    }
+  },
+  {
+    name: "terminate_workflow",
+    description: "Force-terminate a workflow execution immediately without cleanup. Prefer cancel_workflow when possible.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: { type: "string", description: "Namespace containing the workflow." },
+        workflow_id: { type: "string", description: "Workflow ID to terminate." },
+        run_id: { type: "string", description: "Specific run ID (optional)." },
+        reason: {
+          type: "string",
+          description: "Reason for termination (stored in workflow history)."
+        }
+      },
+      required: ["workflow_id"]
+    }
+  }
+];
+var countWorkflowsSchema = z.object({
+  namespace: z.string().optional(),
+  query: z.string().optional()
+});
+var pauseWorkflowSchema = z.object({
+  namespace: z.string().optional(),
+  workflow_id: z.string(),
+  run_id: z.string().optional(),
+  reason: z.string().optional()
+});
+var unpauseWorkflowSchema = z.object({
+  namespace: z.string().optional(),
+  workflow_id: z.string(),
+  run_id: z.string().optional()
+});
+var signalWithStartWorkflowSchema = z.object({
+  namespace: z.string().optional(),
+  workflow_id: z.string(),
+  workflow_type: z.string(),
+  task_queue: z.string(),
+  signal_name: z.string(),
+  signal_input: z.unknown().optional(),
+  workflow_input: z.unknown().optional()
+});
+var listWorkflowsSchema = z.object({
+  namespace: z.string().optional(),
+  query: z.string().optional(),
+  page_size: z.number().optional(),
+  next_page_token: z.string().optional()
+});
+var describeWorkflowSchema = z.object({
+  namespace: z.string().optional(),
+  workflow_id: z.string(),
+  run_id: z.string().optional()
+});
+var startWorkflowSchema = z.object({
+  namespace: z.string().optional(),
+  workflow_id: z.string(),
+  workflow_type: z.string(),
+  task_queue: z.string(),
+  input: z.unknown().optional()
+});
+var signalWorkflowSchema = z.object({
+  namespace: z.string().optional(),
+  workflow_id: z.string(),
+  run_id: z.string().optional(),
+  signal_name: z.string(),
+  input: z.unknown().optional()
+});
+var queryWorkflowSchema = z.object({
+  namespace: z.string().optional(),
+  workflow_id: z.string(),
+  run_id: z.string().optional(),
+  query_type: z.string(),
+  query_args: z.unknown().optional()
+});
+var cancelWorkflowSchema = z.object({
+  namespace: z.string().optional(),
+  workflow_id: z.string(),
+  run_id: z.string().optional(),
+  reason: z.string().optional()
+});
+var terminateWorkflowSchema = z.object({
+  namespace: z.string().optional(),
+  workflow_id: z.string(),
+  run_id: z.string().optional(),
+  reason: z.string().optional()
+});
+function fmtTime(t) {
+  if (!t) return "N/A";
+  if (typeof t === "string") return new Date(t).toISOString();
+  if (typeof t === "object") {
+    const obj = t;
+    if (obj.seconds) return new Date(Number(obj.seconds) * 1e3).toISOString();
+  }
+  return String(t);
+}
+function extractStatus(exec) {
+  const statusCode = exec.status;
+  if (!statusCode) return "Unknown";
+  const statusMap = {
+    "1": "Running",
+    "2": "Completed",
+    "3": "Failed",
+    "4": "Cancelled",
+    "5": "Terminated",
+    "6": "ContinuedAsNew",
+    "7": "TimedOut",
+    WORKFLOW_EXECUTION_STATUS_RUNNING: "Running",
+    WORKFLOW_EXECUTION_STATUS_COMPLETED: "Completed",
+    WORKFLOW_EXECUTION_STATUS_FAILED: "Failed",
+    WORKFLOW_EXECUTION_STATUS_CANCELED: "Cancelled",
+    WORKFLOW_EXECUTION_STATUS_TERMINATED: "Terminated",
+    WORKFLOW_EXECUTION_STATUS_CONTINUED_AS_NEW: "ContinuedAsNew",
+    WORKFLOW_EXECUTION_STATUS_TIMED_OUT: "TimedOut"
+  };
+  return statusMap[String(statusCode)] ?? String(statusCode);
+}
+async function handleListWorkflows(args, client) {
+  const ns = client.ns(args.namespace);
+  const data = await client.get(
+    `/api/v1/namespaces/${encodeURIComponent(ns)}/workflows`,
+    {
+      query: args.query,
+      pageSize: args.page_size ?? 20,
+      nextPageToken: args.next_page_token
+    }
+  );
+  const executions = data.executions ?? [];
+  const lines = [
+    `# Workflows in "${ns}" (${executions.length} returned)`,
+    ""
+  ];
+  for (const exec of executions) {
+    const execution = exec.execution;
+    const type = exec.type;
+    lines.push(`## ${execution?.workflowId ?? "unknown"}`);
+    lines.push(`- Run ID: ${execution?.runId ?? "N/A"}`);
+    lines.push(`- Type: ${type?.name ?? "N/A"}`);
+    lines.push(`- Status: ${extractStatus(exec)}`);
+    lines.push(`- Started: ${fmtTime(exec.startTime)}`);
+    if (exec.closeTime) lines.push(`- Closed: ${fmtTime(exec.closeTime)}`);
+    if (exec.taskQueue) {
+      const tq = exec.taskQueue;
+      lines.push(`- Task Queue: ${tq.name ?? exec.taskQueue}`);
+    }
+    lines.push("");
+  }
+  if (data.nextPageToken) {
+    lines.push(`*Next page token: ${data.nextPageToken}*`);
+  }
+  return {
+    content: [{ type: "text", text: lines.join("\n") }],
+    structuredContent: {
+      namespace: ns,
+      count: executions.length,
+      workflows: executions.map((exec) => {
+        const execution = exec.execution;
+        const type = exec.type;
+        return {
+          workflowId: execution?.workflowId,
+          runId: execution?.runId,
+          type: type?.name,
+          status: extractStatus(exec),
+          startTime: exec.startTime,
+          closeTime: exec.closeTime
+        };
+      }),
+      nextPageToken: data.nextPageToken
+    }
+  };
+}
+async function handleDescribeWorkflow(args, client) {
+  const ns = client.ns(args.namespace);
+  const params = {};
+  if (args.run_id) params["execution.runId"] = args.run_id;
+  const data = await client.get(
+    `/api/v1/namespaces/${encodeURIComponent(ns)}/workflows/${encodeURIComponent(args.workflow_id)}`,
+    params
+  );
+  const execInfo = data.workflowExecutionInfo;
+  const execution = execInfo?.execution;
+  const type = execInfo?.type;
+  const pendingActs = data.pendingActivities;
+  const pendingChildren = data.pendingChildren;
+  const lines = [
+    `# Workflow: ${execution?.workflowId ?? args.workflow_id}`,
+    ""
+  ];
+  if (execution?.runId) lines.push(`- Run ID: ${execution.runId}`);
+  if (type?.name) lines.push(`- Type: ${type.name}`);
+  if (execInfo) lines.push(`- Status: ${extractStatus(execInfo)}`);
+  if (execInfo?.startTime) lines.push(`- Started: ${fmtTime(execInfo.startTime)}`);
+  if (execInfo?.closeTime) lines.push(`- Closed: ${fmtTime(execInfo.closeTime)}`);
+  if (execInfo?.taskQueue) {
+    const tq = execInfo.taskQueue;
+    lines.push(`- Task Queue: ${tq.name ?? execInfo.taskQueue}`);
+  }
+  if (execInfo?.historyLength) lines.push(`- History Events: ${execInfo.historyLength}`);
+  if (pendingActs?.length) {
+    lines.push("", `## Pending Activities (${pendingActs.length})`);
+    for (const act of pendingActs) {
+      const a = act;
+      lines.push(`- ${a.activityId}: ${a.activityType?.name ?? "unknown"} [${a.state ?? ""}]`);
+    }
+  }
+  if (pendingChildren?.length) {
+    lines.push("", `## Pending Child Workflows (${pendingChildren.length})`);
+    for (const child of pendingChildren) {
+      const c = child;
+      lines.push(`- ${c.workflowId}: ${c.workflowTypeName ?? "unknown"}`);
+    }
+  }
+  return {
+    content: [{ type: "text", text: lines.join("\n") }],
+    structuredContent: {
+      workflowId: execution?.workflowId,
+      runId: execution?.runId,
+      type: type?.name,
+      status: execInfo ? extractStatus(execInfo) : void 0,
+      startTime: execInfo?.startTime,
+      closeTime: execInfo?.closeTime,
+      taskQueue: (() => {
+        const tq = execInfo?.taskQueue;
+        return tq?.name ?? execInfo?.taskQueue;
+      })(),
+      historyLength: execInfo?.historyLength,
+      pendingActivities: pendingActs?.length ?? 0,
+      pendingChildren: pendingChildren?.length ?? 0
+    }
+  };
+}
+function encodePayload(value) {
+  const json = JSON.stringify(value);
+  const b64 = Buffer.from(json).toString("base64");
+  return {
+    metadata: { encoding: Buffer.from("json/plain").toString("base64") },
+    data: b64
+  };
+}
+async function handleStartWorkflow(args, client) {
+  const ns = client.ns(args.namespace);
+  const body = {
+    workflowType: { name: args.workflow_type },
+    taskQueue: { name: args.task_queue }
+  };
+  if (args.input !== void 0) {
+    body.input = { payloads: [encodePayload(args.input)] };
+  }
+  const data = await client.post(
+    `/api/v1/namespaces/${encodeURIComponent(ns)}/workflows/${encodeURIComponent(args.workflow_id)}`,
+    body
+  );
+  const lines = [
+    `# Workflow Started`,
+    `- Workflow ID: ${args.workflow_id}`,
+    `- Run ID: ${data.runId ?? "N/A"}`,
+    `- Started: ${data.started !== void 0 ? data.started : "yes"}`
+  ];
+  return { content: [{ type: "text", text: lines.join("\n") }] };
+}
+async function handleSignalWorkflow(args, client) {
+  const ns = client.ns(args.namespace);
+  const body = {};
+  if (args.run_id) body["workflowExecution"] = { workflowId: args.workflow_id, runId: args.run_id };
+  if (args.input !== void 0) body.input = { payloads: [encodePayload(args.input)] };
+  await client.post(
+    `/api/v1/namespaces/${encodeURIComponent(ns)}/workflows/${encodeURIComponent(args.workflow_id)}/signal/${encodeURIComponent(args.signal_name)}`,
+    body
+  );
+  return {
+    content: [{
+      type: "text",
+      text: `Signal "${args.signal_name}" sent to workflow "${args.workflow_id}" successfully.`
+    }]
+  };
+}
+async function handleQueryWorkflow(args, client) {
+  const ns = client.ns(args.namespace);
+  const body = {};
+  if (args.run_id) body.execution = { workflowId: args.workflow_id, runId: args.run_id };
+  if (args.query_args !== void 0) body.query = { queryArgs: { payloads: [encodePayload(args.query_args)] } };
+  const data = await client.post(
+    `/api/v1/namespaces/${encodeURIComponent(ns)}/workflows/${encodeURIComponent(args.workflow_id)}/query/${encodeURIComponent(args.query_type)}`,
+    body
+  );
+  const result = data.queryResult;
+  const payloads = result?.payloads;
+  let resultText = JSON.stringify(data, null, 2);
+  if (payloads?.length) {
+    try {
+      const payload = payloads[0];
+      if (payload.data) {
+        const decoded = Buffer.from(payload.data, "base64").toString("utf-8");
+        resultText = decoded;
+      }
+    } catch {
+    }
+  }
+  const lines = [
+    `# Query Result: ${args.query_type}`,
+    `Workflow: ${args.workflow_id}`,
+    "",
+    "```json",
+    resultText,
+    "```"
+  ];
+  return { content: [{ type: "text", text: lines.join("\n") }] };
+}
+async function handleCancelWorkflow(args, client) {
+  const ns = client.ns(args.namespace);
+  const body = {};
+  if (args.run_id) body.workflowExecution = { workflowId: args.workflow_id, runId: args.run_id };
+  if (args.reason) body.reason = args.reason;
+  await client.post(
+    `/api/v1/namespaces/${encodeURIComponent(ns)}/workflows/${encodeURIComponent(args.workflow_id)}/cancel`,
+    body
+  );
+  return {
+    content: [{
+      type: "text",
+      text: `Cancellation requested for workflow "${args.workflow_id}"${args.reason ? ` (reason: ${args.reason})` : ""}.`
+    }]
+  };
+}
+async function handleTerminateWorkflow(args, client) {
+  const ns = client.ns(args.namespace);
+  const body = {};
+  if (args.run_id) body.workflowExecution = { workflowId: args.workflow_id, runId: args.run_id };
+  if (args.reason) body.reason = args.reason;
+  await client.post(
+    `/api/v1/namespaces/${encodeURIComponent(ns)}/workflows/${encodeURIComponent(args.workflow_id)}/terminate`,
+    body
+  );
+  return {
+    content: [{
+      type: "text",
+      text: `Workflow "${args.workflow_id}" terminated${args.reason ? ` (reason: ${args.reason})` : ""}.`
+    }]
+  };
+}
+async function handleCountWorkflows(args, client) {
+  const ns = client.ns(args.namespace);
+  const data = await client.get(
+    `/api/v1/namespaces/${encodeURIComponent(ns)}/workflow-count`,
+    { query: args.query }
+  );
+  const count = data.count ?? 0;
+  const groups = data.groups;
+  const lines = [
+    `# Workflow Count in "${ns}"`,
+    "",
+    `Total: **${count}**`
+  ];
+  if (groups?.length) {
+    lines.push("", "## Breakdown");
+    for (const g of groups) {
+      const groupValues = g.groupValues;
+      const label = groupValues?.map((v) => v.data ?? v).join(", ") ?? JSON.stringify(g);
+      lines.push(`- ${label}: ${g.count}`);
+    }
+  }
+  return {
+    content: [{ type: "text", text: lines.join("\n") }],
+    structuredContent: {
+      namespace: ns,
+      count: Number(count),
+      query: args.query ?? null,
+      groups: groups?.map((g) => ({
+        count: g.count,
+        groupValues: g.groupValues
+      })) ?? []
+    }
+  };
+}
+async function handlePauseWorkflow(args, client) {
+  const ns = client.ns(args.namespace);
+  const body = {};
+  if (args.run_id) body.workflowExecution = { workflowId: args.workflow_id, runId: args.run_id };
+  if (args.reason) body.reason = args.reason;
+  await client.post(
+    `/api/v1/namespaces/${encodeURIComponent(ns)}/workflows/${encodeURIComponent(args.workflow_id)}/pause`,
+    body
+  );
+  return {
+    content: [{
+      type: "text",
+      text: `Workflow "${args.workflow_id}" paused${args.reason ? ` (reason: ${args.reason})` : ""}.`
+    }]
+  };
+}
+async function handleUnpauseWorkflow(args, client) {
+  const ns = client.ns(args.namespace);
+  const body = {};
+  if (args.run_id) body.workflowExecution = { workflowId: args.workflow_id, runId: args.run_id };
+  await client.post(
+    `/api/v1/namespaces/${encodeURIComponent(ns)}/workflows/${encodeURIComponent(args.workflow_id)}/unpause`,
+    body
+  );
+  return {
+    content: [{ type: "text", text: `Workflow "${args.workflow_id}" unpaused.` }]
+  };
+}
+async function handleSignalWithStartWorkflow(args, client) {
+  const ns = client.ns(args.namespace);
+  const body = {
+    workflowType: { name: args.workflow_type },
+    taskQueue: { name: args.task_queue },
+    signalName: args.signal_name
+  };
+  if (args.signal_input !== void 0) body.signalInput = { payloads: [encodePayload(args.signal_input)] };
+  if (args.workflow_input !== void 0) body.input = { payloads: [encodePayload(args.workflow_input)] };
+  const data = await client.post(
+    `/api/v1/namespaces/${encodeURIComponent(ns)}/workflows/${encodeURIComponent(args.workflow_id)}/signal-with-start/${encodeURIComponent(args.signal_name)}`,
+    body
+  );
+  return {
+    content: [{
+      type: "text",
+      text: [
+        `# signal_with_start: "${args.workflow_id}"`,
+        `- Signal: ${args.signal_name}`,
+        `- Run ID: ${data.runId ?? "N/A"}`,
+        `- Started: ${data.started !== void 0 ? data.started : "yes (or already running)"}`
+      ].join("\n")
+    }]
+  };
+}
+var historyToolDefinitions = [
+  {
+    name: "get_workflow_history",
+    description: "Get the event history of a workflow execution. Useful for debugging failures, understanding execution flow, and auditing. Returns a human-readable summary of history events.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: { type: "string", description: "Namespace containing the workflow." },
+        workflow_id: { type: "string", description: "Workflow ID." },
+        run_id: { type: "string", description: "Specific run ID (optional, uses latest run if omitted)." },
+        reverse: {
+          type: "boolean",
+          description: "If true, return history in reverse chronological order (most recent first). Useful for checking the latest events of a long-running workflow."
+        },
+        page_size: {
+          type: "number",
+          description: "Maximum number of history events to return (default 50)."
+        },
+        next_page_token: {
+          type: "string",
+          description: "Pagination cursor from a previous get_workflow_history call."
+        }
+      },
+      required: ["workflow_id"]
+    }
+  }
+];
+var getWorkflowHistorySchema = z.object({
+  namespace: z.string().optional(),
+  workflow_id: z.string(),
+  run_id: z.string().optional(),
+  reverse: z.boolean().optional(),
+  page_size: z.number().optional(),
+  next_page_token: z.string().optional()
+});
+var EVENT_TYPE_LABELS = {
+  EVENT_TYPE_WORKFLOW_EXECUTION_STARTED: "WorkflowExecutionStarted",
+  EVENT_TYPE_WORKFLOW_EXECUTION_COMPLETED: "WorkflowExecutionCompleted",
+  EVENT_TYPE_WORKFLOW_EXECUTION_FAILED: "WorkflowExecutionFailed",
+  EVENT_TYPE_WORKFLOW_EXECUTION_TIMED_OUT: "WorkflowExecutionTimedOut",
+  EVENT_TYPE_WORKFLOW_EXECUTION_CANCELED: "WorkflowExecutionCanceled",
+  EVENT_TYPE_WORKFLOW_EXECUTION_TERMINATED: "WorkflowExecutionTerminated",
+  EVENT_TYPE_WORKFLOW_EXECUTION_CONTINUED_AS_NEW: "WorkflowExecutionContinuedAsNew",
+  EVENT_TYPE_WORKFLOW_TASK_SCHEDULED: "WorkflowTaskScheduled",
+  EVENT_TYPE_WORKFLOW_TASK_STARTED: "WorkflowTaskStarted",
+  EVENT_TYPE_WORKFLOW_TASK_COMPLETED: "WorkflowTaskCompleted",
+  EVENT_TYPE_WORKFLOW_TASK_FAILED: "WorkflowTaskFailed",
+  EVENT_TYPE_WORKFLOW_TASK_TIMED_OUT: "WorkflowTaskTimedOut",
+  EVENT_TYPE_ACTIVITY_TASK_SCHEDULED: "ActivityTaskScheduled",
+  EVENT_TYPE_ACTIVITY_TASK_STARTED: "ActivityTaskStarted",
+  EVENT_TYPE_ACTIVITY_TASK_COMPLETED: "ActivityTaskCompleted",
+  EVENT_TYPE_ACTIVITY_TASK_FAILED: "ActivityTaskFailed",
+  EVENT_TYPE_ACTIVITY_TASK_TIMED_OUT: "ActivityTaskTimedOut",
+  EVENT_TYPE_ACTIVITY_TASK_CANCEL_REQUESTED: "ActivityTaskCancelRequested",
+  EVENT_TYPE_ACTIVITY_TASK_CANCELED: "ActivityTaskCanceled",
+  EVENT_TYPE_TIMER_STARTED: "TimerStarted",
+  EVENT_TYPE_TIMER_FIRED: "TimerFired",
+  EVENT_TYPE_TIMER_CANCELED: "TimerCanceled",
+  EVENT_TYPE_SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_INITIATED: "SignalExternalWorkflowInitiated",
+  EVENT_TYPE_WORKFLOW_EXECUTION_SIGNALED: "WorkflowExecutionSignaled",
+  EVENT_TYPE_START_CHILD_WORKFLOW_EXECUTION_INITIATED: "StartChildWorkflowInitiated",
+  EVENT_TYPE_CHILD_WORKFLOW_EXECUTION_STARTED: "ChildWorkflowStarted",
+  EVENT_TYPE_CHILD_WORKFLOW_EXECUTION_COMPLETED: "ChildWorkflowCompleted",
+  EVENT_TYPE_CHILD_WORKFLOW_EXECUTION_FAILED: "ChildWorkflowFailed",
+  EVENT_TYPE_CHILD_WORKFLOW_EXECUTION_CANCELED: "ChildWorkflowCanceled",
+  EVENT_TYPE_CHILD_WORKFLOW_EXECUTION_TERMINATED: "ChildWorkflowTerminated",
+  EVENT_TYPE_CHILD_WORKFLOW_EXECUTION_TIMED_OUT: "ChildWorkflowTimedOut"
+};
+function labelEvent(eventType) {
+  return EVENT_TYPE_LABELS[eventType] ?? eventType.replace(/^EVENT_TYPE_/, "");
+}
+function eventDetail(event) {
+  const type = event.eventType;
+  if (!type) return "";
+  if (type === "EVENT_TYPE_ACTIVITY_TASK_SCHEDULED") {
+    const attr = event.activityTaskScheduledEventAttributes;
+    const actType = attr?.activityType;
+    if (actType?.name) return ` \u2192 ${actType.name}`;
+    if (attr?.activityId) return ` id=${attr.activityId}`;
+  }
+  if (type === "EVENT_TYPE_ACTIVITY_TASK_FAILED") {
+    const attr = event.activityTaskFailedEventAttributes;
+    const failure = attr?.failure;
+    if (failure?.message) return ` \u2717 ${failure.message}`;
+  }
+  if (type === "EVENT_TYPE_WORKFLOW_EXECUTION_FAILED") {
+    const attr = event.workflowExecutionFailedEventAttributes;
+    const failure = attr?.failure;
+    if (failure?.message) return ` \u2717 ${failure.message}`;
+  }
+  if (type === "EVENT_TYPE_WORKFLOW_EXECUTION_SIGNALED") {
+    const attr = event.workflowExecutionSignaledEventAttributes;
+    if (attr?.signalName) return ` "${attr.signalName}"`;
+  }
+  if (type === "EVENT_TYPE_TIMER_STARTED") {
+    const attr = event.timerStartedEventAttributes;
+    if (attr?.startToFireTimeout) return ` timeout=${attr.startToFireTimeout}`;
+  }
+  return "";
+}
+function fmtTime2(t) {
+  if (!t) return "";
+  if (typeof t === "string") return new Date(t).toISOString();
+  if (typeof t === "object") {
+    const obj = t;
+    if (obj.seconds) return new Date(Number(obj.seconds) * 1e3).toISOString();
+  }
+  return String(t);
+}
+async function handleGetWorkflowHistory(args, client) {
+  const ns = client.ns(args.namespace);
+  const endpoint = args.reverse ? `/api/v1/namespaces/${encodeURIComponent(ns)}/workflows/${encodeURIComponent(args.workflow_id)}/history-reverse` : `/api/v1/namespaces/${encodeURIComponent(ns)}/workflows/${encodeURIComponent(args.workflow_id)}/history`;
+  const params = {
+    pageSize: args.page_size ?? 50,
+    nextPageToken: args.next_page_token
+  };
+  if (args.run_id) params["execution.runId"] = args.run_id;
+  const data = await client.get(endpoint, params);
+  const history = data.history;
+  const events = history?.events ?? data.events ?? [];
+  const lines = [
+    `# Workflow History: ${args.workflow_id}`,
+    `${args.reverse ? "(reversed)" : ""} ${events.length} events returned`,
+    ""
+  ];
+  for (const event of events) {
+    const eventId = event.eventId ?? "?";
+    const eventType = String(event.eventType ?? "");
+    const time = fmtTime2(event.eventTime);
+    const detail = eventDetail(event);
+    lines.push(`${String(eventId).padStart(4)}  ${labelEvent(eventType)}${detail}  [${time}]`);
+  }
+  if (data.nextPageToken) {
+    lines.push("", `*Next page token: ${data.nextPageToken}*`);
+  }
+  return { content: [{ type: "text", text: lines.join("\n") }] };
+}
+var scheduleToolDefinitions = [
+  {
+    name: "list_schedules",
+    description: "List all schedules in a namespace.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: { type: "string", description: "Target namespace." },
+        page_size: { type: "number", description: "Max results (default 20)." },
+        next_page_token: { type: "string", description: "Pagination cursor." }
+      },
+      required: []
+    }
+  },
+  {
+    name: "describe_schedule",
+    description: "Get full details of a specific schedule including spec, actions, state, and upcoming run times.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: { type: "string", description: "Namespace containing the schedule." },
+        schedule_id: { type: "string", description: "Schedule ID." }
+      },
+      required: ["schedule_id"]
+    }
+  },
+  {
+    name: "create_schedule",
+    description: "Create a new schedule that starts a workflow on a recurring basis. The schedule_spec uses cron-style spec or interval.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: { type: "string", description: "Target namespace." },
+        schedule_id: { type: "string", description: "Unique schedule ID." },
+        cron_expression: {
+          type: "string",
+          description: 'Cron expression (e.g. "0 * * * *" for every hour). Use this OR interval_seconds.'
+        },
+        interval_seconds: {
+          type: "number",
+          description: "Run interval in seconds (e.g. 3600 for every hour). Use this OR cron_expression."
+        },
+        workflow_type: { type: "string", description: "Workflow type to start on each trigger." },
+        workflow_id_prefix: {
+          type: "string",
+          description: "Prefix for workflow IDs (schedule ID used if omitted)."
+        },
+        task_queue: { type: "string", description: "Task queue for the triggered workflows." },
+        input: { description: "Input payload for triggered workflows." },
+        paused: { type: "boolean", description: "Create the schedule in a paused state (default false)." },
+        notes: { type: "string", description: "Human-readable notes." }
+      },
+      required: ["schedule_id", "workflow_type", "task_queue"]
+    }
+  },
+  {
+    name: "delete_schedule",
+    description: "Delete a schedule. This does not affect any workflow executions already started by the schedule.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: { type: "string", description: "Namespace containing the schedule." },
+        schedule_id: { type: "string", description: "Schedule ID to delete." }
+      },
+      required: ["schedule_id"]
+    }
+  }
+];
+var listSchedulesSchema = z.object({
+  namespace: z.string().optional(),
+  page_size: z.number().optional(),
+  next_page_token: z.string().optional()
+});
+var describeScheduleSchema = z.object({
+  namespace: z.string().optional(),
+  schedule_id: z.string()
+});
+var createScheduleSchema = z.object({
+  namespace: z.string().optional(),
+  schedule_id: z.string(),
+  cron_expression: z.string().optional(),
+  interval_seconds: z.number().optional(),
+  workflow_type: z.string(),
+  workflow_id_prefix: z.string().optional(),
+  task_queue: z.string(),
+  input: z.unknown().optional(),
+  paused: z.boolean().optional(),
+  notes: z.string().optional()
+});
+var deleteScheduleSchema = z.object({
+  namespace: z.string().optional(),
+  schedule_id: z.string()
+});
+async function handleListSchedules(args, client) {
+  const ns = client.ns(args.namespace);
+  const data = await client.get(
+    `/api/v1/namespaces/${encodeURIComponent(ns)}/schedules`,
+    { pageSize: args.page_size ?? 20, nextPageToken: args.next_page_token }
+  );
+  const schedules = data.schedules ?? [];
+  const lines = [`# Schedules in "${ns}" (${schedules.length} returned)`, ""];
+  for (const s of schedules) {
+    const info = s.info;
+    lines.push(`## ${s.scheduleId ?? "unknown"}`);
+    if (info?.workflowType) {
+      const wt = info.workflowType;
+      lines.push(`- Workflow Type: ${wt.name ?? info.workflowType}`);
+    }
+    const state = s.state;
+    if (state?.paused !== void 0) lines.push(`- Paused: ${state.paused}`);
+    if (info?.recentActions) {
+      const recent = info.recentActions;
+      lines.push(`- Recent Actions: ${recent.length}`);
+    }
+    if (info?.futureActionTimes) {
+      const times = info.futureActionTimes;
+      if (times.length > 0) lines.push(`- Next Run: ${times[0]}`);
+    }
+    lines.push("");
+  }
+  if (data.nextPageToken) lines.push(`*Next page token: ${data.nextPageToken}*`);
+  return {
+    content: [{ type: "text", text: lines.join("\n") }],
+    structuredContent: {
+      namespace: ns,
+      schedules: schedules.map((s) => {
+        const info = s.info;
+        const state = s.state;
+        const wt = info?.workflowType;
+        const future = info?.futureActionTimes;
+        return {
+          scheduleId: s.scheduleId,
+          workflowType: wt?.name ?? info?.workflowType,
+          paused: state?.paused,
+          nextRun: future?.[0] ?? null
+        };
+      }),
+      nextPageToken: data.nextPageToken
+    }
+  };
+}
+async function handleDescribeSchedule(args, client) {
+  const ns = client.ns(args.namespace);
+  const data = await client.get(
+    `/api/v1/namespaces/${encodeURIComponent(ns)}/schedules/${encodeURIComponent(args.schedule_id)}`
+  );
+  const schedule = data.schedule;
+  const spec = schedule?.spec;
+  const action = schedule?.action;
+  const state = schedule?.state;
+  const info = data.info;
+  const lines = [`# Schedule: ${args.schedule_id}`, ""];
+  if (state?.paused !== void 0) lines.push(`- Paused: ${state.paused}`);
+  if (state?.notes) lines.push(`- Notes: ${state.notes}`);
+  if (spec) {
+    lines.push("", "## Spec");
+    const cronStrings = spec.cronString;
+    if (cronStrings?.length) lines.push(`- Cron: ${cronStrings.join(", ")}`);
+    const intervals = spec.interval;
+    if (intervals?.length) {
+      intervals.forEach((iv) => {
+        const i = iv;
+        lines.push(`- Interval: ${i.interval ?? JSON.stringify(i)}`);
+      });
+    }
+  }
+  if (action) {
+    lines.push("", "## Action");
+    const startWorkflow = action.startWorkflow;
+    if (startWorkflow) {
+      const wt = startWorkflow.workflowType;
+      if (wt?.name) lines.push(`- Workflow Type: ${wt.name}`);
+      const tq = startWorkflow.taskQueue;
+      if (tq?.name) lines.push(`- Task Queue: ${tq.name}`);
+    }
+  }
+  if (info) {
+    const future = info.futureActionTimes;
+    if (future?.length) {
+      lines.push("", "## Upcoming Runs");
+      future.slice(0, 5).forEach((t) => lines.push(`- ${t}`));
+    }
+    const recent = info.recentActions;
+    if (recent?.length) {
+      lines.push("", `## Recent Actions (${recent.length})`);
+      recent.slice(0, 5).forEach((a) => {
+        lines.push(`- ${a.scheduleTime ?? JSON.stringify(a)}`);
+      });
+    }
+  }
+  return { content: [{ type: "text", text: lines.join("\n") }] };
+}
+function encodePayload2(value) {
+  return {
+    metadata: { encoding: Buffer.from("json/plain").toString("base64") },
+    data: Buffer.from(JSON.stringify(value)).toString("base64")
+  };
+}
+async function handleCreateSchedule(args, client) {
+  const ns = client.ns(args.namespace);
+  const spec = {};
+  if (args.cron_expression) spec.cronString = [args.cron_expression];
+  if (args.interval_seconds) spec.interval = [{ interval: `${args.interval_seconds}s` }];
+  const startWorkflow = {
+    workflowType: { name: args.workflow_type },
+    taskQueue: { name: args.task_queue },
+    workflowId: `${args.workflow_id_prefix ?? args.schedule_id}-${Date.now()}`
+  };
+  if (args.input !== void 0) {
+    startWorkflow.input = { payloads: [encodePayload2(args.input)] };
+  }
+  const body = {
+    schedule: {
+      spec,
+      action: { startWorkflow },
+      state: {
+        paused: args.paused ?? false,
+        notes: args.notes ?? ""
+      }
+    }
+  };
+  await client.post(
+    `/api/v1/namespaces/${encodeURIComponent(ns)}/schedules/${encodeURIComponent(args.schedule_id)}`,
+    body
+  );
+  return {
+    content: [{
+      type: "text",
+      text: `Schedule "${args.schedule_id}" created in namespace "${ns}". Workflow type: ${args.workflow_type}, Task queue: ${args.task_queue}.`
+    }]
+  };
+}
+async function handleDeleteSchedule(args, client) {
+  const ns = client.ns(args.namespace);
+  await client.delete(
+    `/api/v1/namespaces/${encodeURIComponent(ns)}/schedules/${encodeURIComponent(args.schedule_id)}`
+  );
+  return {
+    content: [{
+      type: "text",
+      text: `Schedule "${args.schedule_id}" deleted from namespace "${ns}".`
+    }]
+  };
+}
+var taskQueueToolDefinitions = [
+  {
+    name: "describe_task_queue",
+    description: "Get task queue information: active pollers, backlog, and task queue type. Useful for diagnosing worker connectivity issues.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: { type: "string", description: "Target namespace." },
+        task_queue: { type: "string", description: "Task queue name." },
+        task_queue_type: {
+          type: "string",
+          enum: ["WORKFLOW", "ACTIVITY"],
+          description: "Task queue type. Defaults to WORKFLOW."
+        }
+      },
+      required: ["task_queue"]
+    }
+  }
+];
+var describeTaskQueueSchema = z.object({
+  namespace: z.string().optional(),
+  task_queue: z.string(),
+  task_queue_type: z.enum(["WORKFLOW", "ACTIVITY"]).optional()
+});
+async function handleDescribeTaskQueue(args, client) {
+  const ns = client.ns(args.namespace);
+  const data = await client.get(
+    `/api/v1/namespaces/${encodeURIComponent(ns)}/task-queues/${encodeURIComponent(args.task_queue)}`,
+    { taskQueueType: args.task_queue_type ?? "WORKFLOW" }
+  );
+  const lines = [`# Task Queue: ${args.task_queue}`, ""];
+  const pollers = data.pollers ?? [];
+  lines.push(`- Active Pollers: ${pollers.length}`);
+  if (pollers.length > 0) {
+    lines.push("", "## Pollers");
+    for (const poller of pollers) {
+      lines.push(`- Identity: ${poller.identity ?? "unknown"}`);
+      if (poller.lastAccessTime) lines.push(`  Last Access: ${poller.lastAccessTime}`);
+      if (poller.ratePerSecond !== void 0) lines.push(`  Rate: ${poller.ratePerSecond} tasks/s`);
+    }
+  }
+  const taskIdBlock = data.taskIdBlock;
+  if (taskIdBlock) {
+    lines.push("", "## Task ID Block");
+    if (taskIdBlock.startId !== void 0) lines.push(`- Start ID: ${taskIdBlock.startId}`);
+    if (taskIdBlock.endId !== void 0) lines.push(`- End ID: ${taskIdBlock.endId}`);
+  }
+  return { content: [{ type: "text", text: lines.join("\n") }] };
+}
+var searchAttributeToolDefinitions = [
+  {
+    name: "list_search_attributes",
+    description: "List all custom and system search attributes for a namespace. Search attributes are used in workflow visibility queries.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: {
+          type: "string",
+          description: "Target namespace. Defaults to TEMPORAL_NAMESPACE."
+        }
+      },
+      required: []
+    }
+  }
+];
+var listSearchAttributesSchema = z.object({
+  namespace: z.string().optional()
+});
+var VALUE_TYPE_LABELS = {
+  INDEXED_VALUE_TYPE_TEXT: "Text",
+  INDEXED_VALUE_TYPE_KEYWORD: "Keyword",
+  INDEXED_VALUE_TYPE_INT: "Int",
+  INDEXED_VALUE_TYPE_DOUBLE: "Double",
+  INDEXED_VALUE_TYPE_BOOL: "Bool",
+  INDEXED_VALUE_TYPE_DATETIME: "Datetime",
+  INDEXED_VALUE_TYPE_KEYWORD_LIST: "KeywordList",
+  "1": "Text",
+  "2": "Keyword",
+  "3": "Int",
+  "4": "Double",
+  "5": "Bool",
+  "6": "Datetime",
+  "7": "KeywordList"
+};
+function labelType(t) {
+  return VALUE_TYPE_LABELS[t] ?? t;
+}
+async function handleListSearchAttributes(args, client) {
+  const ns = client.ns(args.namespace);
+  const data = await client.get(
+    `/api/v1/namespaces/${encodeURIComponent(ns)}/search-attributes`
+  );
+  const custom = data.customAttributes;
+  const system = data.systemAttributes;
+  const lines = [`# Search Attributes in "${ns}"`, ""];
+  if (custom && Object.keys(custom).length > 0) {
+    lines.push("## Custom Attributes");
+    for (const [name, type] of Object.entries(custom)) {
+      lines.push(`- ${name}: ${labelType(type)}`);
+    }
+    lines.push("");
+  }
+  if (system && Object.keys(system).length > 0) {
+    lines.push("## System Attributes");
+    for (const [name, type] of Object.entries(system)) {
+      lines.push(`- ${name}: ${labelType(type)}`);
+    }
+  }
+  if ((!custom || Object.keys(custom).length === 0) && (!system || Object.keys(system).length === 0)) {
+    lines.push("No search attributes found.");
+  }
+  return { content: [{ type: "text", text: lines.join("\n") }] };
+}
+var activityToolDefinitions = [
+  {
+    name: "list_activities",
+    description: "List activity executions in a namespace. Use the query parameter to filter by workflow ID, activity type, status, etc.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: { type: "string", description: "Target namespace." },
+        query: {
+          type: "string",
+          description: `Visibility query filter (e.g. "WorkflowId='my-workflow' AND ActivityType='SendEmail'").`
+        },
+        page_size: { type: "number", description: "Max results (default 20)." },
+        next_page_token: { type: "string", description: "Pagination cursor." }
+      },
+      required: []
+    }
+  },
+  {
+    name: "describe_activity",
+    description: "Get details of a specific activity execution: type, status, schedule/start time, heartbeat, and failure info.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: { type: "string", description: "Namespace containing the activity." },
+        activity_id: { type: "string", description: "Activity ID." }
+      },
+      required: ["activity_id"]
+    }
+  }
+];
+var listActivitiesSchema = z.object({
+  namespace: z.string().optional(),
+  query: z.string().optional(),
+  page_size: z.number().optional(),
+  next_page_token: z.string().optional()
+});
+var describeActivitySchema = z.object({
+  namespace: z.string().optional(),
+  activity_id: z.string()
+});
+function fmtTime3(t) {
+  if (!t) return "N/A";
+  if (typeof t === "string") return new Date(t).toISOString();
+  if (typeof t === "object") {
+    const o = t;
+    if (o.seconds) return new Date(Number(o.seconds) * 1e3).toISOString();
+  }
+  return String(t);
+}
+async function handleListActivities(args, client) {
+  const ns = client.ns(args.namespace);
+  const data = await client.get(
+    `/api/v1/namespaces/${encodeURIComponent(ns)}/activities`,
+    { query: args.query, pageSize: args.page_size ?? 20, nextPageToken: args.next_page_token }
+  );
+  const activities = data.activityExecutions ?? [];
+  const lines = [`# Activities in "${ns}" (${activities.length} returned)`, ""];
+  for (const act of activities) {
+    const actType = act.activityType;
+    const exec = act.execution;
+    lines.push(`## ${act.activityId ?? "unknown"}`);
+    if (actType?.name) lines.push(`- Type: ${actType.name}`);
+    if (exec?.workflowId) lines.push(`- Workflow: ${exec.workflowId}`);
+    if (act.state) lines.push(`- State: ${act.state}`);
+    if (act.scheduleTime) lines.push(`- Scheduled: ${fmtTime3(act.scheduleTime)}`);
+    if (act.startTime) lines.push(`- Started: ${fmtTime3(act.startTime)}`);
+    lines.push("");
+  }
+  if (data.nextPageToken) lines.push(`*Next page token: ${data.nextPageToken}*`);
+  return {
+    content: [{ type: "text", text: lines.join("\n") }],
+    structuredContent: {
+      namespace: ns,
+      activities: activities.map((act) => {
+        const actType = act.activityType;
+        const exec = act.execution;
+        return {
+          activityId: act.activityId,
+          type: actType?.name,
+          workflowId: exec?.workflowId,
+          state: act.state,
+          scheduleTime: act.scheduleTime,
+          startTime: act.startTime
+        };
+      }),
+      nextPageToken: data.nextPageToken
+    }
+  };
+}
+async function handleDescribeActivity(args, client) {
+  const ns = client.ns(args.namespace);
+  const data = await client.get(
+    `/api/v1/namespaces/${encodeURIComponent(ns)}/activities/${encodeURIComponent(args.activity_id)}`
+  );
+  const actType = data.activityType;
+  const exec = data.execution;
+  const failure = data.failure;
+  const heartbeat = data.lastHeartbeatDetails;
+  const lines = [`# Activity: ${args.activity_id}`, ""];
+  if (actType?.name) lines.push(`- Type: ${actType.name}`);
+  if (exec?.workflowId) lines.push(`- Workflow: ${exec.workflowId}`);
+  if (exec?.runId) lines.push(`- Run ID: ${exec.runId}`);
+  if (data.state) lines.push(`- State: ${data.state}`);
+  if (data.scheduleTime) lines.push(`- Scheduled: ${fmtTime3(data.scheduleTime)}`);
+  if (data.startTime) lines.push(`- Started: ${fmtTime3(data.startTime)}`);
+  if (data.attempt !== void 0) lines.push(`- Attempt: ${data.attempt}`);
+  if (data.maxAttempts !== void 0) lines.push(`- Max Attempts: ${data.maxAttempts}`);
+  if (heartbeat) lines.push(`- Last Heartbeat: ${JSON.stringify(heartbeat)}`);
+  if (failure?.message) {
+    lines.push("", "## Failure");
+    lines.push(`- Message: ${failure.message}`);
+    if (failure.applicationFailureInfo) {
+      const info = failure.applicationFailureInfo;
+      if (info.type) lines.push(`- Failure Type: ${info.type}`);
+    }
+  }
+  return { content: [{ type: "text", text: lines.join("\n") }] };
+}
+var batchOperationToolDefinitions = [
+  {
+    name: "list_batch_operations",
+    description: "List batch operations (bulk workflow signal/cancel/terminate/delete jobs) in a namespace.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: { type: "string", description: "Target namespace." },
+        page_size: { type: "number", description: "Max results (default 20)." },
+        next_page_token: { type: "string", description: "Pagination cursor." }
+      },
+      required: []
+    }
+  },
+  {
+    name: "describe_batch_operation",
+    description: "Get details of a batch operation: type, state, progress, and error info.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: { type: "string", description: "Namespace containing the batch operation." },
+        job_id: { type: "string", description: "Batch operation job ID." }
+      },
+      required: ["job_id"]
+    }
+  },
+  {
+    name: "stop_batch_operation",
+    description: "Stop a running batch operation. The operation will not be rolled back.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: { type: "string", description: "Namespace containing the batch operation." },
+        job_id: { type: "string", description: "Batch operation job ID to stop." },
+        reason: { type: "string", description: "Reason for stopping the operation." }
+      },
+      required: ["job_id"]
+    }
+  }
+];
+var listBatchOperationsSchema = z.object({
+  namespace: z.string().optional(),
+  page_size: z.number().optional(),
+  next_page_token: z.string().optional()
+});
+var describeBatchOperationSchema = z.object({
+  namespace: z.string().optional(),
+  job_id: z.string()
+});
+var stopBatchOperationSchema = z.object({
+  namespace: z.string().optional(),
+  job_id: z.string(),
+  reason: z.string().optional()
+});
+async function handleListBatchOperations(args, client) {
+  const ns = client.ns(args.namespace);
+  const data = await client.get(
+    `/api/v1/namespaces/${encodeURIComponent(ns)}/batch-operations`,
+    { pageSize: args.page_size ?? 20, nextPageToken: args.next_page_token }
+  );
+  const ops = data.operationInfo ?? [];
+  const lines = [`# Batch Operations in "${ns}" (${ops.length} returned)`, ""];
+  for (const op of ops) {
+    lines.push(`## ${op.jobId ?? "unknown"}`);
+    if (op.operationType) lines.push(`- Type: ${op.operationType}`);
+    if (op.state) lines.push(`- State: ${op.state}`);
+    if (op.startTime) lines.push(`- Started: ${op.startTime}`);
+    if (op.closeTime) lines.push(`- Closed: ${op.closeTime}`);
+    lines.push("");
+  }
+  if (data.nextPageToken) lines.push(`*Next page token: ${data.nextPageToken}*`);
+  return { content: [{ type: "text", text: lines.join("\n") }] };
+}
+async function handleDescribeBatchOperation(args, client) {
+  const ns = client.ns(args.namespace);
+  const data = await client.get(
+    `/api/v1/namespaces/${encodeURIComponent(ns)}/batch-operations/${encodeURIComponent(args.job_id)}`
+  );
+  const lines = [`# Batch Operation: ${args.job_id}`, ""];
+  if (data.operationType) lines.push(`- Type: ${data.operationType}`);
+  if (data.state) lines.push(`- State: ${data.state}`);
+  if (data.startTime) lines.push(`- Started: ${data.startTime}`);
+  if (data.closeTime) lines.push(`- Closed: ${data.closeTime}`);
+  if (data.totalOperationCount !== void 0) lines.push(`- Total: ${data.totalOperationCount}`);
+  if (data.completeOperationCount !== void 0) lines.push(`- Completed: ${data.completeOperationCount}`);
+  if (data.failureOperationCount !== void 0) lines.push(`- Failed: ${data.failureOperationCount}`);
+  const reason = data.reason;
+  if (reason) lines.push(`- Reason: ${reason}`);
+  return { content: [{ type: "text", text: lines.join("\n") }] };
+}
+async function handleStopBatchOperation(args, client) {
+  const ns = client.ns(args.namespace);
+  await client.post(
+    `/api/v1/namespaces/${encodeURIComponent(ns)}/batch-operations/${encodeURIComponent(args.job_id)}/stop`,
+    { reason: args.reason ?? "" }
+  );
+  return {
+    content: [{
+      type: "text",
+      text: `Batch operation "${args.job_id}" stopped${args.reason ? ` (reason: ${args.reason})` : ""}.`
+    }]
+  };
+}
+var workerDeploymentToolDefinitions = [
+  {
+    name: "list_worker_deployments",
+    description: "List worker deployments in a namespace. Worker deployments track versioned worker releases.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: { type: "string", description: "Target namespace." },
+        page_size: { type: "number", description: "Max results (default 20)." },
+        next_page_token: { type: "string", description: "Pagination cursor." }
+      },
+      required: []
+    }
+  },
+  {
+    name: "describe_worker_deployment",
+    description: "Get details of a worker deployment: current version, ramping version, routing config, and version summaries.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: { type: "string", description: "Namespace containing the deployment." },
+        deployment_name: { type: "string", description: "Deployment name." }
+      },
+      required: ["deployment_name"]
+    }
+  }
+];
+var listWorkerDeploymentsSchema = z.object({
+  namespace: z.string().optional(),
+  page_size: z.number().optional(),
+  next_page_token: z.string().optional()
+});
+var describeWorkerDeploymentSchema = z.object({
+  namespace: z.string().optional(),
+  deployment_name: z.string()
+});
+async function handleListWorkerDeployments(args, client) {
+  const ns = client.ns(args.namespace);
+  const data = await client.get(
+    `/api/v1/namespaces/${encodeURIComponent(ns)}/worker-deployments`,
+    { pageSize: args.page_size ?? 20, nextPageToken: args.next_page_token }
+  );
+  const deployments = data.deployments ?? [];
+  const lines = [`# Worker Deployments in "${ns}" (${deployments.length} returned)`, ""];
+  for (const dep of deployments) {
+    const info = dep.deploymentInfo;
+    const name = info?.name ?? dep.name;
+    lines.push(`## ${name ?? "unknown"}`);
+    if (info?.createTime) lines.push(`- Created: ${info.createTime}`);
+    const currentVersion = info?.currentVersion;
+    if (currentVersion?.version) lines.push(`- Current Version: ${currentVersion.version}`);
+    const rampingVersion = info?.rampingVersion;
+    if (rampingVersion?.version) lines.push(`- Ramping Version: ${rampingVersion.version}`);
+    lines.push("");
+  }
+  if (data.nextPageToken) lines.push(`*Next page token: ${data.nextPageToken}*`);
+  return { content: [{ type: "text", text: lines.join("\n") }] };
+}
+async function handleDescribeWorkerDeployment(args, client) {
+  const ns = client.ns(args.namespace);
+  const data = await client.get(
+    `/api/v1/namespaces/${encodeURIComponent(ns)}/worker-deployments/${encodeURIComponent(args.deployment_name)}`
+  );
+  const dep = data.deploymentInfo;
+  const lines = [`# Worker Deployment: ${args.deployment_name}`, ""];
+  if (dep?.createTime) lines.push(`- Created: ${dep.createTime}`);
+  if (dep?.lastModifierIdentity) lines.push(`- Last Modified By: ${dep.lastModifierIdentity}`);
+  const currentVersion = dep?.currentVersion;
+  if (currentVersion) {
+    lines.push("", "## Current Version");
+    if (currentVersion.version) lines.push(`- Version: ${currentVersion.version}`);
+    if (currentVersion.becameCurrentTime) lines.push(`- Became Current: ${currentVersion.becameCurrentTime}`);
+  }
+  const rampingVersion = dep?.rampingVersion;
+  if (rampingVersion) {
+    lines.push("", "## Ramping Version");
+    if (rampingVersion.version) lines.push(`- Version: ${rampingVersion.version}`);
+    if (rampingVersion.rampPercentage !== void 0) lines.push(`- Ramp: ${rampingVersion.rampPercentage}%`);
+  }
+  const versionSummaries = dep?.versionSummaries;
+  if (versionSummaries?.length) {
+    lines.push("", `## Version History (${versionSummaries.length})`);
+    for (const v of versionSummaries) {
+      lines.push(`- ${v.version}: drained=${v.drainageStatus ?? "N/A"}`);
+    }
+  }
+  return { content: [{ type: "text", text: lines.join("\n") }] };
+}
+var nexusEndpointToolDefinitions = [
+  {
+    name: "list_nexus_endpoints",
+    description: "List all Nexus endpoints registered in the cluster. Nexus endpoints connect Temporal namespaces to external services.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        page_size: { type: "number", description: "Max results (default 20)." },
+        next_page_token: { type: "string", description: "Pagination cursor." }
+      },
+      required: []
+    }
+  },
+  {
+    name: "get_nexus_endpoint",
+    description: "Get details of a specific Nexus endpoint by ID.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Nexus endpoint ID." }
+      },
+      required: ["id"]
+    }
+  },
+  {
+    name: "create_nexus_endpoint",
+    description: "Create a new Nexus endpoint that routes to a target namespace and task queue.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Unique endpoint name." },
+        target_namespace: { type: "string", description: "Target Temporal namespace." },
+        target_task_queue: { type: "string", description: "Target task queue in the target namespace." },
+        description: { type: "string", description: "Human-readable description." }
+      },
+      required: ["name", "target_namespace", "target_task_queue"]
+    }
+  },
+  {
+    name: "delete_nexus_endpoint",
+    description: "Delete a Nexus endpoint by ID.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Nexus endpoint ID to delete." },
+        version: { type: "string", description: "Current version for optimistic concurrency (required)." }
+      },
+      required: ["id", "version"]
+    }
+  }
+];
+var listNexusEndpointsSchema = z.object({
+  page_size: z.number().optional(),
+  next_page_token: z.string().optional()
+});
+var getNexusEndpointSchema = z.object({
+  id: z.string()
+});
+var createNexusEndpointSchema = z.object({
+  name: z.string(),
+  target_namespace: z.string(),
+  target_task_queue: z.string(),
+  description: z.string().optional()
+});
+var deleteNexusEndpointSchema = z.object({
+  id: z.string(),
+  version: z.string()
+});
+function formatEndpoint(ep) {
+  const lines = [];
+  const spec = ep.spec;
+  const target = spec?.target;
+  const worker = target?.worker;
+  lines.push(`- ID: ${ep.id}`);
+  if (spec?.name) lines.push(`- Name: ${spec.name}`);
+  if (ep.createdTime) lines.push(`- Created: ${ep.createdTime}`);
+  if (ep.lastModifiedTime) lines.push(`- Last Modified: ${ep.lastModifiedTime}`);
+  if (worker?.namespace) lines.push(`- Target Namespace: ${worker.namespace}`);
+  if (worker?.taskQueue) lines.push(`- Target Task Queue: ${worker.taskQueue}`);
+  return lines;
+}
+async function handleListNexusEndpoints(args, client) {
+  const data = await client.get(
+    "/api/v1/nexus/endpoints",
+    { pageSize: args.page_size ?? 20, nextPageToken: args.next_page_token }
+  );
+  const endpoints = data.endpoints ?? [];
+  const lines = [`# Nexus Endpoints (${endpoints.length} returned)`, ""];
+  for (const ep of endpoints) {
+    const spec = ep.spec;
+    lines.push(`## ${spec?.name ?? ep.id ?? "unknown"}`);
+    lines.push(...formatEndpoint(ep));
+    lines.push("");
+  }
+  if (data.nextPageToken) lines.push(`*Next page token: ${data.nextPageToken}*`);
+  return { content: [{ type: "text", text: lines.join("\n") }] };
+}
+async function handleGetNexusEndpoint(args, client) {
+  const data = await client.get(
+    `/api/v1/nexus/endpoints/${encodeURIComponent(args.id)}`
+  );
+  const ep = data.endpoint ?? data;
+  const spec = ep.spec;
+  const lines = [`# Nexus Endpoint: ${spec?.name ?? args.id}`, ""];
+  lines.push(...formatEndpoint(ep));
+  return { content: [{ type: "text", text: lines.join("\n") }] };
+}
+async function handleCreateNexusEndpoint(args, client) {
+  const body = {
+    spec: {
+      name: args.name,
+      description: args.description ? { value: args.description } : void 0,
+      target: {
+        worker: {
+          namespace: args.target_namespace,
+          taskQueue: args.target_task_queue
+        }
+      }
+    }
+  };
+  const data = await client.post("/api/v1/nexus/endpoints", body);
+  const ep = data.endpoint ?? data;
+  return {
+    content: [{
+      type: "text",
+      text: `Nexus endpoint "${args.name}" created. ID: ${ep.id ?? "N/A"}, Target: ${args.target_namespace}/${args.target_task_queue}`
+    }]
+  };
+}
+async function handleDeleteNexusEndpoint(args, client) {
+  await client.delete(
+    `/api/v1/nexus/endpoints/${encodeURIComponent(args.id)}`,
+    { version: args.version }
+  );
+  return {
+    content: [{ type: "text", text: `Nexus endpoint "${args.id}" deleted.` }]
+  };
+}
+var workflowRuleToolDefinitions = [
+  {
+    name: "list_workflow_rules",
+    description: "List workflow rules in a namespace. Workflow rules automatically perform actions (terminate, pause, etc.) on matching workflows.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: { type: "string", description: "Target namespace." }
+      },
+      required: []
+    }
+  },
+  {
+    name: "describe_workflow_rule",
+    description: "Get details of a specific workflow rule: spec, action, and status.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: { type: "string", description: "Namespace containing the rule." },
+        rule_id: { type: "string", description: "Workflow rule ID." }
+      },
+      required: ["rule_id"]
+    }
+  },
+  {
+    name: "create_workflow_rule",
+    description: "Create a workflow rule that automatically acts on workflows matching a visibility query. Supported actions: TERMINATE, PAUSE.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: { type: "string", description: "Target namespace." },
+        rule_id: { type: "string", description: "Unique rule ID." },
+        query: {
+          type: "string",
+          description: `Visibility query to match workflows (e.g. "WorkflowType='OldJob' AND ExecutionStatus='Running'").`
+        },
+        action: {
+          type: "string",
+          enum: ["TERMINATE", "PAUSE"],
+          description: "Action to perform on matching workflows."
+        },
+        description: { type: "string", description: "Human-readable description of the rule." }
+      },
+      required: ["rule_id", "query", "action"]
+    }
+  },
+  {
+    name: "delete_workflow_rule",
+    description: "Delete a workflow rule. Workflows already acted on are not affected.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: { type: "string", description: "Namespace containing the rule." },
+        rule_id: { type: "string", description: "Rule ID to delete." }
+      },
+      required: ["rule_id"]
+    }
+  }
+];
+var listWorkflowRulesSchema = z.object({
+  namespace: z.string().optional()
+});
+var describeWorkflowRuleSchema = z.object({
+  namespace: z.string().optional(),
+  rule_id: z.string()
+});
+var createWorkflowRuleSchema = z.object({
+  namespace: z.string().optional(),
+  rule_id: z.string(),
+  query: z.string(),
+  action: z.enum(["TERMINATE", "PAUSE"]),
+  description: z.string().optional()
+});
+var deleteWorkflowRuleSchema = z.object({
+  namespace: z.string().optional(),
+  rule_id: z.string()
+});
+function formatRule(rule) {
+  const lines = [];
+  const spec = rule.spec;
+  if (rule.id) lines.push(`- ID: ${rule.id}`);
+  if (spec?.visibilityQuery) lines.push(`- Query: ${spec.visibilityQuery}`);
+  const action = spec?.action;
+  if (action) {
+    if (action.terminateWorkflow !== void 0) lines.push("- Action: TERMINATE");
+    else if (action.pauseWorkflow !== void 0) lines.push("- Action: PAUSE");
+    else lines.push(`- Action: ${JSON.stringify(action)}`);
+  }
+  if (spec?.description) lines.push(`- Description: ${spec.description}`);
+  if (rule.createTime) lines.push(`- Created: ${rule.createTime}`);
+  return lines;
+}
+async function handleListWorkflowRules(args, client) {
+  const ns = client.ns(args.namespace);
+  const data = await client.get(
+    `/api/v1/namespaces/${encodeURIComponent(ns)}/workflow-rules`
+  );
+  const rules = data.workflowRules ?? [];
+  const lines = [`# Workflow Rules in "${ns}" (${rules.length} found)`, ""];
+  for (const rule of rules) {
+    const spec = rule.spec;
+    lines.push(`## ${rule.id ?? "unknown"}${spec?.description ? ` \u2014 ${spec.description}` : ""}`);
+    lines.push(...formatRule(rule));
+    lines.push("");
+  }
+  if (rules.length === 0) lines.push("No workflow rules found.");
+  return { content: [{ type: "text", text: lines.join("\n") }] };
+}
+async function handleDescribeWorkflowRule(args, client) {
+  const ns = client.ns(args.namespace);
+  const data = await client.get(
+    `/api/v1/namespaces/${encodeURIComponent(ns)}/workflow-rules/${encodeURIComponent(args.rule_id)}`
+  );
+  const rule = data.workflowRule ?? data;
+  const spec = rule.spec;
+  const lines = [`# Workflow Rule: ${rule.id ?? args.rule_id}${spec?.description ? ` \u2014 ${spec.description}` : ""}`, ""];
+  lines.push(...formatRule(rule));
+  return { content: [{ type: "text", text: lines.join("\n") }] };
+}
+async function handleCreateWorkflowRule(args, client) {
+  const ns = client.ns(args.namespace);
+  const action = args.action === "TERMINATE" ? { terminateWorkflow: {} } : { pauseWorkflow: {} };
+  const body = {
+    workflowRule: {
+      id: args.rule_id,
+      spec: {
+        visibilityQuery: args.query,
+        action,
+        description: args.description ?? ""
+      }
+    }
+  };
+  await client.post(
+    `/api/v1/namespaces/${encodeURIComponent(ns)}/workflow-rules`,
+    body
+  );
+  return {
+    content: [{
+      type: "text",
+      text: `Workflow rule "${args.rule_id}" created in "${ns}". Action: ${args.action}, Query: ${args.query}`
+    }]
+  };
+}
+async function handleDeleteWorkflowRule(args, client) {
+  const ns = client.ns(args.namespace);
+  await client.delete(
+    `/api/v1/namespaces/${encodeURIComponent(ns)}/workflow-rules/${encodeURIComponent(args.rule_id)}`
+  );
+  return {
+    content: [{ type: "text", text: `Workflow rule "${args.rule_id}" deleted from namespace "${ns}".` }]
+  };
+}
+
+// src/index.ts
+var ESSENTIAL_TOOLS = /* @__PURE__ */ new Set([
+  "get_cluster_info",
+  "list_namespaces",
+  "describe_namespace",
+  "list_workflows",
+  "describe_workflow",
+  "start_workflow",
+  "signal_workflow",
+  "query_workflow",
+  "cancel_workflow",
+  "terminate_workflow",
+  "get_workflow_history"
+]);
+var STANDARD_TOOLS = /* @__PURE__ */ new Set([
+  ...ESSENTIAL_TOOLS,
+  "count_workflows",
+  "pause_workflow",
+  "unpause_workflow",
+  "signal_with_start_workflow",
+  "list_schedules",
+  "describe_schedule",
+  "create_schedule",
+  "delete_schedule",
+  "list_activities",
+  "describe_activity",
+  "describe_task_queue",
+  "list_search_attributes"
+]);
+function resolveToolTier() {
+  const val = (process.env.TEMPORAL_TOOLS ?? "essential").toLowerCase();
+  if (val === "all") return "all";
+  if (val === "standard") return "standard";
+  return "essential";
+}
+async function runTool(fn) {
+  try {
+    return await fn();
+  } catch (err) {
+    let message;
+    if (err instanceof TemporalError) {
+      message = `Temporal API error ${err.status}: ${err.message}`;
+    } else if (err instanceof Error) {
+      message = err.message;
+    } else {
+      message = String(err);
+    }
+    return {
+      content: [{ type: "text", text: `Error: ${message}` }],
+      isError: true
+    };
+  }
+}
+function parseArgs(schema, args) {
+  const result = schema.safeParse(args);
+  if (!result.success) {
+    return {
+      ok: false,
+      error: {
+        content: [{ type: "text", text: `Invalid arguments: ${result.error.message}` }],
+        isError: true
+      }
+    };
+  }
+  return { ok: true, data: result.data };
+}
+async function main() {
+  const client = createClientFromEnv();
+  const server = new Server(
+    { name: "temporal-mcp", version: "0.1.0" },
+    { capabilities: { tools: {} } }
+  );
+  const tier = resolveToolTier();
+  const allToolDefs = [
+    // Phase 1
+    ...clusterToolDefinitions,
+    ...namespaceToolDefinitions,
+    ...workflowToolDefinitions,
+    ...historyToolDefinitions,
+    ...scheduleToolDefinitions,
+    ...taskQueueToolDefinitions,
+    ...searchAttributeToolDefinitions,
+    // Phase 2
+    ...activityToolDefinitions,
+    ...batchOperationToolDefinitions,
+    ...workerDeploymentToolDefinitions,
+    ...nexusEndpointToolDefinitions,
+    ...workflowRuleToolDefinitions
+  ];
+  const tools = tier === "all" ? allToolDefs : allToolDefs.filter(
+    (t) => tier === "standard" ? STANDARD_TOOLS.has(t.name) : ESSENTIAL_TOOLS.has(t.name)
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    switch (name) {
+      // ── Cluster ──────────────────────────────────────────────────────────
+      case "get_cluster_info": {
+        const parsed = parseArgs(getClusterInfoSchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handleGetClusterInfo(parsed.data, client));
+      }
+      // ── Namespaces ───────────────────────────────────────────────────────
+      case "list_namespaces": {
+        const parsed = parseArgs(listNamespacesSchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handleListNamespaces(parsed.data, client));
+      }
+      case "describe_namespace": {
+        const parsed = parseArgs(describeNamespaceSchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handleDescribeNamespace(parsed.data, client));
+      }
+      // ── Workflows ────────────────────────────────────────────────────────
+      case "list_workflows": {
+        const parsed = parseArgs(listWorkflowsSchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handleListWorkflows(parsed.data, client));
+      }
+      case "describe_workflow": {
+        const parsed = parseArgs(describeWorkflowSchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handleDescribeWorkflow(parsed.data, client));
+      }
+      case "start_workflow": {
+        const parsed = parseArgs(startWorkflowSchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handleStartWorkflow(parsed.data, client));
+      }
+      case "signal_workflow": {
+        const parsed = parseArgs(signalWorkflowSchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handleSignalWorkflow(parsed.data, client));
+      }
+      case "query_workflow": {
+        const parsed = parseArgs(queryWorkflowSchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handleQueryWorkflow(parsed.data, client));
+      }
+      case "cancel_workflow": {
+        const parsed = parseArgs(cancelWorkflowSchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handleCancelWorkflow(parsed.data, client));
+      }
+      case "terminate_workflow": {
+        const parsed = parseArgs(terminateWorkflowSchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handleTerminateWorkflow(parsed.data, client));
+      }
+      // ── Workflow control (pause / unpause / count / signal-with-start) ───
+      case "count_workflows": {
+        const parsed = parseArgs(countWorkflowsSchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handleCountWorkflows(parsed.data, client));
+      }
+      case "pause_workflow": {
+        const parsed = parseArgs(pauseWorkflowSchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handlePauseWorkflow(parsed.data, client));
+      }
+      case "unpause_workflow": {
+        const parsed = parseArgs(unpauseWorkflowSchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handleUnpauseWorkflow(parsed.data, client));
+      }
+      case "signal_with_start_workflow": {
+        const parsed = parseArgs(signalWithStartWorkflowSchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handleSignalWithStartWorkflow(parsed.data, client));
+      }
+      // ── Workflow History ─────────────────────────────────────────────────
+      case "get_workflow_history": {
+        const parsed = parseArgs(getWorkflowHistorySchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handleGetWorkflowHistory(parsed.data, client));
+      }
+      // ── Schedules ────────────────────────────────────────────────────────
+      case "list_schedules": {
+        const parsed = parseArgs(listSchedulesSchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handleListSchedules(parsed.data, client));
+      }
+      case "describe_schedule": {
+        const parsed = parseArgs(describeScheduleSchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handleDescribeSchedule(parsed.data, client));
+      }
+      case "create_schedule": {
+        const parsed = parseArgs(createScheduleSchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handleCreateSchedule(parsed.data, client));
+      }
+      case "delete_schedule": {
+        const parsed = parseArgs(deleteScheduleSchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handleDeleteSchedule(parsed.data, client));
+      }
+      // ── Task Queues ──────────────────────────────────────────────────────
+      case "describe_task_queue": {
+        const parsed = parseArgs(describeTaskQueueSchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handleDescribeTaskQueue(parsed.data, client));
+      }
+      // ── Search Attributes ────────────────────────────────────────────────
+      case "list_search_attributes": {
+        const parsed = parseArgs(listSearchAttributesSchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handleListSearchAttributes(parsed.data, client));
+      }
+      // ── Activities ───────────────────────────────────────────────────────
+      case "list_activities": {
+        const parsed = parseArgs(listActivitiesSchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handleListActivities(parsed.data, client));
+      }
+      case "describe_activity": {
+        const parsed = parseArgs(describeActivitySchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handleDescribeActivity(parsed.data, client));
+      }
+      // ── Batch Operations ─────────────────────────────────────────────────
+      case "list_batch_operations": {
+        const parsed = parseArgs(listBatchOperationsSchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handleListBatchOperations(parsed.data, client));
+      }
+      case "describe_batch_operation": {
+        const parsed = parseArgs(describeBatchOperationSchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handleDescribeBatchOperation(parsed.data, client));
+      }
+      case "stop_batch_operation": {
+        const parsed = parseArgs(stopBatchOperationSchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handleStopBatchOperation(parsed.data, client));
+      }
+      // ── Worker Deployments ───────────────────────────────────────────────
+      case "list_worker_deployments": {
+        const parsed = parseArgs(listWorkerDeploymentsSchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handleListWorkerDeployments(parsed.data, client));
+      }
+      case "describe_worker_deployment": {
+        const parsed = parseArgs(describeWorkerDeploymentSchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handleDescribeWorkerDeployment(parsed.data, client));
+      }
+      // ── Nexus Endpoints ──────────────────────────────────────────────────
+      case "list_nexus_endpoints": {
+        const parsed = parseArgs(listNexusEndpointsSchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handleListNexusEndpoints(parsed.data, client));
+      }
+      case "get_nexus_endpoint": {
+        const parsed = parseArgs(getNexusEndpointSchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handleGetNexusEndpoint(parsed.data, client));
+      }
+      case "create_nexus_endpoint": {
+        const parsed = parseArgs(createNexusEndpointSchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handleCreateNexusEndpoint(parsed.data, client));
+      }
+      case "delete_nexus_endpoint": {
+        const parsed = parseArgs(deleteNexusEndpointSchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handleDeleteNexusEndpoint(parsed.data, client));
+      }
+      // ── Workflow Rules ───────────────────────────────────────────────────
+      case "list_workflow_rules": {
+        const parsed = parseArgs(listWorkflowRulesSchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handleListWorkflowRules(parsed.data, client));
+      }
+      case "describe_workflow_rule": {
+        const parsed = parseArgs(describeWorkflowRuleSchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handleDescribeWorkflowRule(parsed.data, client));
+      }
+      case "create_workflow_rule": {
+        const parsed = parseArgs(createWorkflowRuleSchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handleCreateWorkflowRule(parsed.data, client));
+      }
+      case "delete_workflow_rule": {
+        const parsed = parseArgs(deleteWorkflowRuleSchema, args);
+        if (!parsed.ok) return parsed.error;
+        return runTool(() => handleDeleteWorkflowRule(parsed.data, client));
+      }
+      default:
+        return {
+          content: [{ type: "text", text: `Unknown tool: ${name}` }],
+          isError: true
+        };
+    }
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  process.stderr.write(`Temporal MCP server started (tools: ${tier}, ${tools.length} loaded)
+`);
+}
+main().catch((err) => {
+  process.stderr.write(`Fatal error: ${err instanceof Error ? err.message : String(err)}
+`);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map