@burdenoff/mcp-libs 2026.1009.1 → 2026.1009.2

package/dist/modules/scheduler/index.cjs

@@ -1,12 +1,12 @@
 'use strict';
 
-var zod = require('zod');
 require('graphql-request');
 require('cross-fetch');
 require('@modelcontextprotocol/sdk/server/mcp.js');
 require('@modelcontextprotocol/sdk/types.js');
+require('zod');
 
-// src/modules/scheduler/tools.ts
+// src/core/auth/store.ts
 
 // src/core/errors.ts
 var McpInternalError = class extends Error {
@@ -37,12 +37,6 @@ function mcpToolName(productName, ...parts) {
 }
 
 // src/core/result.ts
-function jsonResult(data, structured) {
-  const result = {
-    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
-  };
-  return result;
-}
 function errorResult(message, hint) {
   const text = hint ? `${message}
 
@@ -50,1057 +44,89 @@ Hint: ${hint}` : message;
   return { content: [{ type: "text", text }], isError: true };
 }
 
-// src/modules/scheduler/operations.ts
-var LIST_SCHEDULED_JOBS = `
-  query ListScheduledJobs($workspaceId: ID!, $filter: JobFilterInput, $pagination: SchedulerPaginationInput) {
-    scheduledJobs(workspaceId: $workspaceId, filter: $filter, pagination: $pagination) {
-      jobs { id name status scheduleType nextExecutionAt createdAt }
-      total nextCursor
-    }
-  }
-`;
-var GET_SCHEDULED_JOB = `
-  query GetScheduledJob($id: ID!) {
-    scheduledJob(id: $id) {
-      id name status scheduleType cronExpression executorType
-      nextExecutionAt lastExecutionAt
-    }
-  }
-`;
-var CREATE_SCHEDULED_JOB = `
-  mutation CreateScheduledJob($workspaceId: ID!, $input: CreateScheduledJobInput!) {
-    createScheduledJob(workspaceId: $workspaceId, input: $input) {
-      id name status scheduleType
-    }
-  }
-`;
-var DELETE_SCHEDULED_JOB = `
-  mutation DeleteScheduledJob($id: ID!) {
-    deleteScheduledJob(id: $id)
-  }
-`;
-var JOB_EXECUTIONS = `
-  query JobExecutions($jobId: ID!, $pagination: SchedulerPaginationInput) {
-    jobExecutions(jobId: $jobId, pagination: $pagination) {
-      executions { id status startedAt completedAt duration errorMessage success }
-      total nextCursor
-    }
-  }
-`;
-var UPDATE_SCHEDULED_JOB = `
-  mutation UpdateScheduledJob($id: ID!, $input: UpdateScheduledJobInput!) {
-    updateScheduledJob(id: $id, input: $input) {
-      id name status scheduleType cronExpression nextExecutionAt
-    }
-  }
-`;
-var GET_JOB_EXECUTION = `
-  query JobExecution($id: ID!) {
-    jobExecution(id: $id) {
-      id scheduleId status attemptNumber startedAt completedAt
-      errorMessage result success
-    }
-  }
-`;
-var RETRY_JOB_EXECUTION = `
-  mutation RetryJobExecution($executionId: ID!) {
-    retryJobExecution(executionId: $executionId) {
-      id status attemptNumber startedAt
-    }
-  }
-`;
-var PAUSE_JOB = `
-  mutation PauseScheduledJob($id: ID!) {
-    pauseScheduledJob(id: $id) { id name status }
-  }
-`;
-var RESUME_JOB = `
-  mutation ResumeScheduledJob($id: ID!) {
-    resumeScheduledJob(id: $id) { id name status }
-  }
-`;
-var ACTIVATE_SCHEDULE = `
-  mutation ActivateSchedule($id: ID!) {
-    activateSchedule(id: $id) { id name status }
-  }
-`;
-var ARCHIVE_SCHEDULE = `
-  mutation ArchiveSchedule($id: ID!) {
-    archiveSchedule(id: $id) { id name status }
-  }
-`;
-var DISABLE_SCHEDULE = `
-  mutation DisableSchedule($id: ID!, $reason: String) {
-    disableSchedule(id: $id, reason: $reason) { id name status }
-  }
-`;
-var CLONE_SCHEDULE = `
-  mutation CloneSchedule($sourceId: ID!, $newWorkspaceId: ID, $overrides: CreateScheduledJobInput) {
-    cloneSchedule(sourceId: $sourceId, newWorkspaceId: $newWorkspaceId, overrides: $overrides) {
-      id name status
-    }
-  }
-`;
-var EXECUTE_JOB_NOW = `
-  mutation ExecuteJobNow($id: ID!) {
-    executeJobNow(id: $id) { id scheduledJobId status }
-  }
-`;
-var PREVIEW_SCHEDULE = `
-  query PreviewSchedule(
-    $scheduleType: ScheduleType!
-    $cronExpression: String
-    $rrule: String
-    $interval: Int
-    $intervalUnit: String
-    $count: Int
-    $startDate: DateTime
-    $endDate: DateTime
-    $timezone: String
-  ) {
-    previewSchedule(
-      scheduleType: $scheduleType
-      cronExpression: $cronExpression
-      rrule: $rrule
-      interval: $interval
-      intervalUnit: $intervalUnit
-      count: $count
-      startDate: $startDate
-      endDate: $endDate
-      timezone: $timezone
-    ) {
-      count startDate endDate nextExecutions
-    }
-  }
-`;
-var LIST_SCHEDULE_TEMPLATES = `
-  query ScheduleTemplates(
-    $workspaceId: ID!
-    $filter: ScheduleTemplateFilterInput
-    $pagination: SchedulerPaginationInput
-  ) {
-    scheduleTemplates(workspaceId: $workspaceId, filter: $filter, pagination: $pagination) {
-      templates { id name category isPublic scheduleType executorType usageCount }
-      total nextCursor
-    }
-  }
-`;
-var LIST_PUBLIC_SCHEDULE_TEMPLATES = `
-  query PublicScheduleTemplates(
-    $filter: ScheduleTemplateFilterInput
-    $pagination: SchedulerPaginationInput
-  ) {
-    publicScheduleTemplates(filter: $filter, pagination: $pagination) {
-      templates { id name category isPublic scheduleType executorType usageCount }
-      total nextCursor
-    }
-  }
-`;
-var GET_SCHEDULE_TEMPLATE = `
-  query ScheduleTemplate($id: ID!) {
-    scheduleTemplate(id: $id) {
-      id name description category isPublic scheduleType executorType
-      scheduleConfig executorConfig usageCount
-    }
-  }
-`;
-var CREATE_SCHEDULE_TEMPLATE = `
-  mutation CreateScheduleTemplate($input: CreateScheduleTemplateInput!, $workspaceId: ID!) {
-    createScheduleTemplate(input: $input, workspaceId: $workspaceId) { id name scheduleType }
-  }
-`;
-var UPDATE_SCHEDULE_TEMPLATE = `
-  mutation UpdateScheduleTemplate($id: ID!, $input: UpdateScheduleTemplateInput!) {
-    updateScheduleTemplate(id: $id, input: $input) { id name }
-  }
-`;
-var DELETE_SCHEDULE_TEMPLATE = `
-  mutation DeleteScheduleTemplate($id: ID!) { deleteScheduleTemplate(id: $id) }
-`;
-var CREATE_SCHEDULE_FROM_TEMPLATE = `
-  mutation CreateScheduleFromTemplate(
-    $templateId: ID!
-    $workspaceId: ID!
-    $overrides: CreateScheduledJobInput
-  ) {
-    createScheduleFromTemplate(templateId: $templateId, workspaceId: $workspaceId, overrides: $overrides) {
-      id name status
-    }
-  }
-`;
-var SCHEDULE_VERSION_HISTORY = `
-  query ScheduleVersionHistory($scheduleId: ID!) {
-    scheduleVersionHistory(scheduleId: $scheduleId) {
-      id scheduleId version changedBy changedFields changeReason createdAt
-    }
-  }
-`;
-var RESTORE_SCHEDULE_VERSION = `
-  mutation RestoreScheduleVersion($scheduleId: ID!, $versionId: ID!) {
-    restoreScheduleVersion(scheduleId: $scheduleId, versionId: $versionId) { id name version }
-  }
-`;
-var TAG_SCHEDULED_JOB = `
-  mutation TagScheduledJob($input: TagScheduledJobInput!) {
-    tagScheduledJob(input: $input) { id entityId tagId source }
-  }
-`;
-var UNTAG_SCHEDULED_JOB = `
-  mutation UntagScheduledJob($input: UntagScheduledJobInput!) {
-    untagScheduledJob(input: $input)
-  }
-`;
-var REPLACE_SCHEDULED_JOB_TAGS = `
-  mutation ReplaceScheduledJobTags($input: ReplaceScheduledJobTagsInput!) {
-    replaceScheduledJobTags(input: $input) { id entityId tagId source }
-  }
-`;
-var GET_SCHEDULED_JOB_TAGS = `
-  query GetScheduledJobTags($input: GetScheduledJobTagsInput!) {
-    getScheduledJobTags(input: $input) { id entityId tagId source }
-  }
-`;
-var EXECUTION_UPDATED_POLL = `
-  query ExecutionUpdatedPoll($id: ID!) {
-    jobExecution(id: $id) {
-      id scheduleId status attemptNumber startedAt completedAt errorMessage success
-    }
-  }
-`;
-var JOB_STATUS_UPDATED_POLL = `
-  query JobStatusUpdatedPoll($id: ID!) {
-    scheduledJob(id: $id) {
-      id name status nextExecutionAt lastExecutionAt updatedAt
-    }
-  }
-`;
-
 // src/modules/scheduler/tools.ts
-function readWorkspaceId(ctx) {
-  const auth = ctx.auth.read();
-  return auth?.workspaceId ?? null;
-}
-var ScheduleTypeEnum = zod.z.enum(["CRON", "INTERVAL", "ONCE"]);
-var ExecutorTypeEnum = zod.z.enum(["WORKFLOW", "FUNCTION", "WEBHOOK"]);
-function registerSchedulerTools(server, ctx, track) {
-  server.registerTool(
-    track(mcpToolName(ctx.productName, "scheduler_jobs_list")),
-    {
-      title: "List Scheduled Jobs",
-      description: "List scheduled jobs in the active workspace.",
-      inputSchema: {
-        status: zod.z.string().optional().describe("Filter by status (will be uppercased)"),
-        type: ScheduleTypeEnum.optional().describe("Filter by scheduleType"),
-        limit: zod.z.number().optional().describe("Page size (default 50)")
-      }
-    },
-    async ({ status, type, limit }) => {
-      try {
-        const workspaceId = readWorkspaceId(ctx);
-        if (!workspaceId) {
-          return errorResult("No workspace set. Run the auth workspace_set tool first.");
-        }
-        const filter = {};
-        if (status !== void 0) filter.status = status.toUpperCase();
-        if (type !== void 0) filter.scheduleType = type;
-        const data = await ctx.gql.workspace.request(LIST_SCHEDULED_JOBS, {
-          workspaceId,
-          filter: Object.keys(filter).length > 0 ? filter : void 0,
-          pagination: { limit: limit ?? 50, offset: 0 }
-        });
-        return jsonResult(data.scheduledJobs);
-      } catch (error) {
-        ctx.logger.error("scheduler_jobs_list failed", { error: String(error) });
-        return errorResult(
-          `Failed to list scheduled jobs: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-  );
-  server.registerTool(
-    track(mcpToolName(ctx.productName, "scheduler_jobs_get")),
-    {
-      title: "Get Scheduled Job",
-      description: "Get a scheduled job by ID.",
-      inputSchema: { id: zod.z.string().describe("Job ID") }
-    },
-    async ({ id }) => {
-      try {
-        const data = await ctx.gql.workspace.request(
-          GET_SCHEDULED_JOB,
-          { id }
-        );
-        if (!data.scheduledJob) return errorResult(`Job ${id} not found`);
-        return jsonResult(data.scheduledJob);
-      } catch (error) {
-        ctx.logger.error("scheduler_jobs_get failed", { error: String(error) });
-        return errorResult(
-          `Failed to get scheduled job: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-  );
-  server.registerTool(
-    track(mcpToolName(ctx.productName, "scheduler_jobs_create")),
-    {
-      title: "Create Scheduled Job",
-      description: "Create a scheduled job.",
-      inputSchema: {
-        name: zod.z.string().describe("Job name"),
-        type: ScheduleTypeEnum.describe("Schedule type"),
-        cron: zod.z.string().optional().describe("Cron expression (for CRON type)"),
-        intervalSeconds: zod.z.number().optional().describe("Interval seconds (for INTERVAL type)"),
-        executor: ExecutorTypeEnum.optional().describe("Executor type (default WORKFLOW)"),
-        executorConfig: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("Executor configuration object")
-      }
-    },
-    async ({ name, type, cron, intervalSeconds, executor, executorConfig }) => {
-      try {
-        const workspaceId = readWorkspaceId(ctx);
-        if (!workspaceId) {
-          return errorResult("No workspace set. Run the auth workspace_set tool first.");
-        }
-        const input = {
-          name,
-          scheduleType: type,
-          executorType: executor ?? "WORKFLOW",
-          executorConfig: executorConfig ?? {}
-        };
-        if (cron !== void 0) input.cronExpression = cron;
-        if (intervalSeconds !== void 0) input.intervalSeconds = intervalSeconds;
-        const data = await ctx.gql.workspace.request(
-          CREATE_SCHEDULED_JOB,
-          { workspaceId, input }
-        );
-        return jsonResult(data.createScheduledJob);
-      } catch (error) {
-        ctx.logger.error("scheduler_jobs_create failed", { error: String(error) });
-        return errorResult(
-          `Failed to create scheduled job: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-  );
-  server.registerTool(
-    track(mcpToolName(ctx.productName, "scheduler_jobs_update")),
-    {
-      title: "Update Scheduled Job",
-      description: "Update a scheduled job (cron expression, executor config, retry policy, etc.). At least one field must be provided. Returns the updated ScheduledJob.",
-      inputSchema: {
-        id: zod.z.string().describe("Job ID"),
-        name: zod.z.string().optional().describe("Updated job name"),
-        description: zod.z.string().optional().describe("Updated description"),
-        cronExpression: zod.z.string().optional().describe("Updated cron expression (CRON jobs only)"),
-        interval: zod.z.number().int().optional().describe("Updated interval (INTERVAL jobs only)"),
-        intervalUnit: zod.z.string().optional().describe("Interval unit (SECONDS|MINUTES|HOURS|DAYS, will be uppercased)"),
-        endDate: zod.z.string().optional().describe("Updated end date (ISO-8601)"),
-        executorConfig: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("Updated executor configuration"),
-        maxRetries: zod.z.number().int().optional().describe("Max retry attempts on failure"),
-        changeReason: zod.z.string().optional().describe("Audit-trail reason for the change")
-      }
-    },
-    async ({
-      id,
-      name,
-      description,
-      cronExpression,
-      interval,
-      intervalUnit,
-      endDate,
-      executorConfig,
-      maxRetries,
-      changeReason
-    }) => {
-      try {
-        const input = {};
-        if (name !== void 0) input.name = name;
-        if (description !== void 0) input.description = description;
-        if (cronExpression !== void 0) input.cronExpression = cronExpression;
-        if (interval !== void 0) input.interval = interval;
-        if (intervalUnit !== void 0) input.intervalUnit = intervalUnit.toUpperCase();
-        if (endDate !== void 0) input.endDate = endDate;
-        if (executorConfig !== void 0) input.executorConfig = executorConfig;
-        if (maxRetries !== void 0) input.maxRetries = maxRetries;
-        if (changeReason !== void 0) input.changeReason = changeReason;
-        if (Object.keys(input).length === 0) {
-          return errorResult("No updates specified \u2014 provide at least one field to update");
-        }
-        const data = await ctx.gql.workspace.request(
-          UPDATE_SCHEDULED_JOB,
-          { id, input }
-        );
-        return jsonResult(data.updateScheduledJob);
-      } catch (error) {
-        ctx.logger.error("scheduler_jobs_update failed", { error: String(error) });
-        return errorResult(
-          `Failed to update scheduled job: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-  );
-  server.registerTool(
-    track(mcpToolName(ctx.productName, "scheduler_jobs_delete")),
-    {
-      title: "Delete Scheduled Job",
-      description: "Delete a scheduled job.",
-      inputSchema: { id: zod.z.string().describe("Job ID") }
-    },
-    async ({ id }) => {
-      try {
-        const data = await ctx.gql.workspace.request(
-          DELETE_SCHEDULED_JOB,
-          { id }
-        );
-        return jsonResult({ deleted: data.deleteScheduledJob, jobId: id });
-      } catch (error) {
-        ctx.logger.error("scheduler_jobs_delete failed", { error: String(error) });
-        return errorResult(
-          `Failed to delete scheduled job: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-  );
-  server.registerTool(
-    track(mcpToolName(ctx.productName, "scheduler_executions_list")),
-    {
-      title: "List Job Executions",
-      description: "List execution history for a scheduled job.",
-      inputSchema: {
-        jobId: zod.z.string().describe("Job ID"),
-        limit: zod.z.number().optional().describe("Page size (default 100)")
-      }
-    },
-    async ({ jobId, limit }) => {
-      try {
-        const data = await ctx.gql.workspace.request(JOB_EXECUTIONS, {
-          jobId,
-          pagination: { limit: limit ?? 100, offset: 0 }
-        });
-        return jsonResult(data.jobExecutions);
-      } catch (error) {
-        ctx.logger.error("scheduler_executions_list failed", { error: String(error) });
-        return errorResult(
-          `Failed to list executions: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-  );
+function stubbedTool(server, toolName, title, description, featureNote, inputSchema, altSuggestions) {
   server.registerTool(
-    track(mcpToolName(ctx.productName, "scheduler_executions_get")),
+    toolName,
     {
-      title: "Get Job Execution",
-      description: "Fetch a single job execution by ID, including status, attempt number, timings, error message and result payload. Returns the JobExecution or an error if not found.",
-      inputSchema: { id: zod.z.string().describe("Execution ID") }
+      title,
+      description: `${description} [STUB]`,
+      inputSchema
     },
-    async ({ id }) => {
-      try {
-        const data = await ctx.gql.workspace.request(
-          GET_JOB_EXECUTION,
-          { id }
-        );
-        if (!data.jobExecution) return errorResult(`Execution ${id} not found`);
-        return jsonResult(data.jobExecution);
-      } catch (error) {
-        ctx.logger.error("scheduler_executions_get failed", { error: String(error) });
-        return errorResult(
-          `Failed to get job execution: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
+    async () => errorResult(
+      `[stubbed] ${featureNote} Use ${altSuggestions.join(", ")} instead. The tool remains registered so callers receive a meaningful response instead of a schema-validation error.`
+    )
   );
-  for (const [tool, op, title, desc, mutationField] of [
+}
+function registerSchedulerTools(server, ctx, track) {
+  const featureNote = "Live alpha removed the legacy `(workspaceId, first, after)` arguments on `Query.scheduledJobs` and renamed `ExecutorType` / `ScheduleType` enum values. The connection shape changed from edges/nodes to a flat `jobs` array.";
+  const alts = [
+    "the next alpha release that re-exposes `scheduledJobs` with the legacy shape",
+    "the SDK scheduler API (which the MCP will mirror once it lands)"
+  ];
+  const tools = [
+    ["scheduled_jobs_list", "List Scheduled Jobs", "List scheduled jobs."],
+    ["scheduled_jobs_get", "Get Scheduled Job", "Get a scheduled job by ID."],
+    ["scheduled_jobs_create", "Create Scheduled Job", "Create a new scheduled job."],
+    ["scheduled_jobs_update", "Update Scheduled Job", "Update a scheduled job."],
+    ["scheduled_jobs_delete", "Delete Scheduled Job", "Delete a scheduled job."],
+    ["scheduled_jobs_activate", "Activate Schedule", "Activate a paused schedule."],
+    ["scheduled_jobs_pause", "Pause Schedule", "Pause an active schedule."],
+    ["scheduled_jobs_archive", "Archive Schedule", "Archive a schedule."],
+    ["scheduled_jobs_disable", "Disable Schedule", "Disable a schedule."],
+    ["scheduled_jobs_clone", "Clone Schedule", "Clone a schedule with overrides."],
+    ["scheduled_jobs_execute_now", "Execute Job Now", "Trigger an immediate run."],
+    ["scheduled_jobs_preview", "Preview Schedule", "Preview upcoming executions of a schedule."],
+    ["scheduled_jobs_check", "Check Schedule", "Run a one-shot dry-run of a schedule."],
+    ["scheduler_executions_list", "List Executions", "List executions of a job."],
+    ["scheduler_executions_get", "Get Execution", "Get a single execution by ID."],
+    ["scheduler_executions_check", "Check Execution", "Poll an execution for status."],
+    ["scheduler_executions_retry", "Retry Execution", "Retry a failed execution."],
+    [
+      "scheduler_versions_history",
+      "Schedule Version History",
+      "Get the version history of a schedule."
+    ],
     [
-      "scheduler_jobs_pause",
-      PAUSE_JOB,
-      "Pause Scheduled Job",
-      "Pause a scheduled job.",
-      "pauseScheduledJob"
+      "scheduler_versions_restore",
+      "Restore Schedule Version",
+      "Restore a previous schedule version."
     ],
     [
-      "scheduler_jobs_resume",
-      RESUME_JOB,
-      "Resume Scheduled Job",
-      "Resume a paused scheduled job.",
-      "resumeScheduledJob"
+      "scheduler_templates_list",
+      "List Schedule Templates",
+      "List schedule templates in a workspace."
     ],
     [
-      "scheduler_jobs_activate",
-      ACTIVATE_SCHEDULE,
-      "Activate Schedule",
-      "Activate a draft or disabled schedule.",
-      "activateSchedule"
+      "scheduler_templates_list_public",
+      "List Public Schedule Templates",
+      "List public schedule templates."
     ],
+    ["scheduler_templates_get", "Get Schedule Template", "Get a schedule template by ID."],
+    ["scheduler_templates_create", "Create Schedule Template", "Create a new schedule template."],
     [
-      "scheduler_jobs_archive",
-      ARCHIVE_SCHEDULE,
-      "Archive Schedule",
-      "Archive a scheduled job (soft delete).",
-      "archiveSchedule"
-    ]
-  ]) {
-    server.registerTool(
+      "scheduler_templates_create_from_template",
+      "Create Schedule From Template",
+      "Materialize a schedule from a template."
+    ],
+    ["scheduler_templates_update", "Update Schedule Template", "Update a schedule template."],
+    ["scheduler_templates_delete", "Delete Schedule Template", "Delete a schedule template."],
+    ["scheduler_tags_add", "Add Tag to Job", "Tag a scheduled job."],
+    ["scheduler_tags_list", "List Job Tags", "List tags on a job."],
+    ["scheduler_tags_remove", "Remove Tag from Job", "Remove a tag from a job."],
+    ["scheduler_tags_replace", "Replace Job Tags", "Replace the tag set on a job."]
+  ];
+  for (const [tool, title, desc] of tools) {
+    stubbedTool(
+      server,
       track(mcpToolName(ctx.productName, tool)),
-      {
-        title,
-        description: desc,
-        inputSchema: { id: zod.z.string().describe("Schedule ID") }
-      },
-      async ({ id }) => {
-        try {
-          const data = await ctx.gql.workspace.request(op, { id });
-          return jsonResult(data[mutationField]);
-        } catch (error) {
-          ctx.logger.error(`${tool} failed`, { error: String(error) });
-          return errorResult(
-            `${title} failed: ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
-      }
+      title,
+      desc,
+      featureNote,
+      {},
+      alts
     );
   }
-  server.registerTool(
-    track(mcpToolName(ctx.productName, "scheduler_jobs_disable")),
-    {
-      title: "Disable Schedule",
-      description: "Disable a schedule with an optional reason.",
-      inputSchema: {
-        id: zod.z.string().describe("Schedule ID"),
-        reason: zod.z.string().optional().describe("Disable reason (audit trail)")
-      }
-    },
-    async ({ id, reason }) => {
-      try {
-        const data = await ctx.gql.workspace.request(
-          DISABLE_SCHEDULE,
-          { id, reason: reason ?? null }
-        );
-        return jsonResult(data.disableSchedule);
-      } catch (error) {
-        ctx.logger.error("scheduler_jobs_disable failed", { error: String(error) });
-        return errorResult(
-          `Failed to disable: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-  );
-  server.registerTool(
-    track(mcpToolName(ctx.productName, "scheduler_jobs_clone")),
-    {
-      title: "Clone Schedule",
-      description: "Clone an existing schedule. Optionally move to another workspace and supply override fields.",
-      inputSchema: {
-        sourceId: zod.z.string().describe("Source schedule ID"),
-        newWorkspaceId: zod.z.string().optional().describe("Target workspace (defaults to source)"),
-        overrides: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("CreateScheduledJobInput overrides")
-      }
-    },
-    async ({ sourceId, newWorkspaceId, overrides }) => {
-      try {
-        const data = await ctx.gql.workspace.request(
-          CLONE_SCHEDULE,
-          { sourceId, newWorkspaceId: newWorkspaceId ?? null, overrides: overrides ?? null }
-        );
-        return jsonResult(data.cloneSchedule);
-      } catch (error) {
-        ctx.logger.error("scheduler_jobs_clone failed", { error: String(error) });
-        return errorResult(
-          `Failed to clone: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-  );
-  server.registerTool(
-    track(mcpToolName(ctx.productName, "scheduler_jobs_execute_now")),
-    {
-      title: "Execute Job Now",
-      description: "Trigger a scheduled job to execute immediately (out-of-band).",
-      inputSchema: { id: zod.z.string().describe("Schedule ID") }
-    },
-    async ({ id }) => {
-      try {
-        const data = await ctx.gql.workspace.request(
-          EXECUTE_JOB_NOW,
-          { id }
-        );
-        return jsonResult(data.executeJobNow);
-      } catch (error) {
-        ctx.logger.error("scheduler_jobs_execute_now failed", { error: String(error) });
-        return errorResult(
-          `Failed to execute: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-  );
-  server.registerTool(
-    track(mcpToolName(ctx.productName, "scheduler_jobs_preview")),
-    {
-      title: "Preview Schedule",
-      description: "Compute upcoming execution times for a schedule definition without creating it.",
-      inputSchema: {
-        scheduleType: zod.z.string().describe("CRON | FIXED_INTERVAL | ONE_TIME | RRULE | WINDOWED"),
-        cronExpression: zod.z.string().optional(),
-        rrule: zod.z.string().optional(),
-        interval: zod.z.number().int().optional(),
-        intervalUnit: zod.z.string().optional(),
-        count: zod.z.number().int().optional().describe("How many upcoming executions to return"),
-        startDate: zod.z.string().optional(),
-        endDate: zod.z.string().optional(),
-        timezone: zod.z.string().optional()
-      }
-    },
-    async ({
-      scheduleType,
-      cronExpression,
-      rrule,
-      interval,
-      intervalUnit,
-      count,
-      startDate,
-      endDate,
-      timezone
-    }) => {
-      try {
-        const data = await ctx.gql.workspace.request(PREVIEW_SCHEDULE, {
-          scheduleType: scheduleType.toUpperCase(),
-          cronExpression: cronExpression ?? null,
-          rrule: rrule ?? null,
-          interval: interval ?? null,
-          intervalUnit: intervalUnit ?? null,
-          count: count ?? null,
-          startDate: startDate ?? null,
-          endDate: endDate ?? null,
-          timezone: timezone ?? null
-        });
-        return jsonResult(data.previewSchedule);
-      } catch (error) {
-        ctx.logger.error("scheduler_jobs_preview failed", { error: String(error) });
-        return errorResult(
-          `Failed to preview: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-  );
-  server.registerTool(
-    track(mcpToolName(ctx.productName, "scheduler_templates_list")),
-    {
-      title: "List Schedule Templates",
-      description: "List schedule templates in the active workspace.",
-      inputSchema: {
-        category: zod.z.string().optional(),
-        isPublic: zod.z.boolean().optional(),
-        limit: zod.z.number().optional()
-      }
-    },
-    async ({ category, isPublic, limit }) => {
-      try {
-        const workspaceId = readWorkspaceId(ctx);
-        if (!workspaceId) return errorResult("No workspace set.");
-        const filter = {};
-        if (category !== void 0) filter.category = category;
-        if (isPublic !== void 0) filter.isPublic = isPublic;
-        const data = await ctx.gql.workspace.request(LIST_SCHEDULE_TEMPLATES, {
-          workspaceId,
-          filter: Object.keys(filter).length > 0 ? filter : void 0,
-          pagination: { first: limit ?? 100 }
-        });
-        return jsonResult(data.scheduleTemplates);
-      } catch (error) {
-        ctx.logger.error("scheduler_templates_list failed", { error: String(error) });
-        return errorResult(
-          `Failed to list templates: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-  );
-  server.registerTool(
-    track(mcpToolName(ctx.productName, "scheduler_templates_list_public")),
-    {
-      title: "List Public Schedule Templates",
-      description: "List public (cross-workspace) schedule templates.",
-      inputSchema: {
-        category: zod.z.string().optional(),
-        limit: zod.z.number().optional()
-      }
-    },
-    async ({ category, limit }) => {
-      try {
-        const filter = {};
-        if (category !== void 0) filter.category = category;
-        const data = await ctx.gql.workspace.request(LIST_PUBLIC_SCHEDULE_TEMPLATES, {
-          filter: Object.keys(filter).length > 0 ? filter : void 0,
-          pagination: { first: limit ?? 100 }
-        });
-        return jsonResult(data.publicScheduleTemplates);
-      } catch (error) {
-        ctx.logger.error("scheduler_templates_list_public failed", { error: String(error) });
-        return errorResult(
-          `Failed to list: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-  );
-  server.registerTool(
-    track(mcpToolName(ctx.productName, "scheduler_templates_get")),
-    {
-      title: "Get Schedule Template",
-      description: "Get a schedule template by ID.",
-      inputSchema: { id: zod.z.string() }
-    },
-    async ({ id }) => {
-      try {
-        const data = await ctx.gql.workspace.request(
-          GET_SCHEDULE_TEMPLATE,
-          { id }
-        );
-        if (!data.scheduleTemplate) return errorResult(`Template ${id} not found`);
-        return jsonResult(data.scheduleTemplate);
-      } catch (error) {
-        ctx.logger.error("scheduler_templates_get failed", { error: String(error) });
-        return errorResult(
-          `Failed to get template: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-  );
-  server.registerTool(
-    track(mcpToolName(ctx.productName, "scheduler_templates_create")),
-    {
-      title: "Create Schedule Template",
-      description: "Create a reusable schedule template in the active workspace.",
-      inputSchema: {
-        name: zod.z.string(),
-        scheduleType: zod.z.string().describe("CRON | FIXED_INTERVAL | ONE_TIME | RRULE | WINDOWED"),
-        executorType: zod.z.string().describe("WEBHOOK | INTERNAL_API | NATS_TOPIC | GRAPHQL"),
-        scheduleConfig: zod.z.record(zod.z.string(), zod.z.unknown()),
-        executorConfig: zod.z.record(zod.z.string(), zod.z.unknown()),
-        description: zod.z.string().optional(),
-        category: zod.z.string().optional(),
-        isPublic: zod.z.boolean().optional()
-      }
-    },
-    async ({
-      name,
-      scheduleType,
-      executorType,
-      scheduleConfig,
-      executorConfig,
-      description,
-      category,
-      isPublic
-    }) => {
-      try {
-        const workspaceId = readWorkspaceId(ctx);
-        if (!workspaceId) return errorResult("No workspace set.");
-        const input = {
-          name,
-          scheduleType: scheduleType.toUpperCase(),
-          executorType: executorType.toUpperCase(),
-          scheduleConfig,
-          executorConfig
-        };
-        if (description !== void 0) input.description = description;
-        if (category !== void 0) input.category = category;
-        if (isPublic !== void 0) input.isPublic = isPublic;
-        const data = await ctx.gql.workspace.request(
-          CREATE_SCHEDULE_TEMPLATE,
-          { workspaceId, input }
-        );
-        return jsonResult(data.createScheduleTemplate);
-      } catch (error) {
-        ctx.logger.error("scheduler_templates_create failed", { error: String(error) });
-        return errorResult(
-          `Failed to create template: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-  );
-  server.registerTool(
-    track(mcpToolName(ctx.productName, "scheduler_templates_update")),
-    {
-      title: "Update Schedule Template",
-      description: "Update a schedule template.",
-      inputSchema: {
-        id: zod.z.string(),
-        name: zod.z.string().optional(),
-        description: zod.z.string().optional(),
-        category: zod.z.string().optional(),
-        isPublic: zod.z.boolean().optional()
-      }
-    },
-    async ({ id, name, description, category, isPublic }) => {
-      try {
-        const input = {};
-        if (name !== void 0) input.name = name;
-        if (description !== void 0) input.description = description;
-        if (category !== void 0) input.category = category;
-        if (isPublic !== void 0) input.isPublic = isPublic;
-        if (Object.keys(input).length === 0) {
-          return errorResult("Provide at least one field to update");
-        }
-        const data = await ctx.gql.workspace.request(
-          UPDATE_SCHEDULE_TEMPLATE,
-          { id, input }
-        );
-        return jsonResult(data.updateScheduleTemplate);
-      } catch (error) {
-        ctx.logger.error("scheduler_templates_update failed", { error: String(error) });
-        return errorResult(
-          `Failed to update template: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-  );
-  server.registerTool(
-    track(mcpToolName(ctx.productName, "scheduler_templates_delete")),
-    {
-      title: "Delete Schedule Template",
-      description: "Delete a schedule template.",
-      inputSchema: { id: zod.z.string() }
-    },
-    async ({ id }) => {
-      try {
-        const data = await ctx.gql.workspace.request(
-          DELETE_SCHEDULE_TEMPLATE,
-          { id }
-        );
-        return jsonResult({ deleted: data.deleteScheduleTemplate, id });
-      } catch (error) {
-        ctx.logger.error("scheduler_templates_delete failed", { error: String(error) });
-        return errorResult(
-          `Failed to delete: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-  );
-  server.registerTool(
-    track(mcpToolName(ctx.productName, "scheduler_templates_create_from_template")),
-    {
-      title: "Create Schedule From Template",
-      description: "Instantiate a schedule from a template; optional overrides.",
-      inputSchema: {
-        templateId: zod.z.string(),
-        overrides: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
-      }
-    },
-    async ({ templateId, overrides }) => {
-      try {
-        const workspaceId = readWorkspaceId(ctx);
-        if (!workspaceId) return errorResult("No workspace set.");
-        const data = await ctx.gql.workspace.request(
-          CREATE_SCHEDULE_FROM_TEMPLATE,
-          { templateId, workspaceId, overrides: overrides ?? null }
-        );
-        return jsonResult(data.createScheduleFromTemplate);
-      } catch (error) {
-        ctx.logger.error("scheduler_templates_create_from failed", { error: String(error) });
-        return errorResult(
-          `Failed to create: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-  );
-  server.registerTool(
-    track(mcpToolName(ctx.productName, "scheduler_versions_history")),
-    {
-      title: "Schedule Version History",
-      description: "List version history for a schedule.",
-      inputSchema: { scheduleId: zod.z.string() }
-    },
-    async ({ scheduleId }) => {
-      try {
-        const data = await ctx.gql.workspace.request(
-          SCHEDULE_VERSION_HISTORY,
-          { scheduleId }
-        );
-        return jsonResult(data.scheduleVersionHistory);
-      } catch (error) {
-        ctx.logger.error("scheduler_versions_history failed", { error: String(error) });
-        return errorResult(
-          `Failed to get history: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-  );
-  server.registerTool(
-    track(mcpToolName(ctx.productName, "scheduler_versions_restore")),
-    {
-      title: "Restore Schedule Version",
-      description: "Restore a schedule to a prior version.",
-      inputSchema: { scheduleId: zod.z.string(), versionId: zod.z.string() }
-    },
-    async ({ scheduleId, versionId }) => {
-      try {
-        const data = await ctx.gql.workspace.request(
-          RESTORE_SCHEDULE_VERSION,
-          { scheduleId, versionId }
-        );
-        return jsonResult(data.restoreScheduleVersion);
-      } catch (error) {
-        ctx.logger.error("scheduler_versions_restore failed", { error: String(error) });
-        return errorResult(
-          `Failed to restore: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-  );
-  server.registerTool(
-    track(mcpToolName(ctx.productName, "scheduler_tags_add")),
-    {
-      title: "Tag Scheduled Job",
-      description: "Add a tag assignment to a scheduled job.",
-      inputSchema: {
-        entityId: zod.z.string(),
-        tagId: zod.z.string(),
-        source: zod.z.string().optional()
-      }
-    },
-    async ({ entityId, tagId, source }) => {
-      try {
-        const input = { entityId, tagId };
-        if (source !== void 0) input.source = source;
-        const data = await ctx.gql.workspace.request(
-          TAG_SCHEDULED_JOB,
-          { input }
-        );
-        return jsonResult(data.tagScheduledJob);
-      } catch (error) {
-        ctx.logger.error("scheduler_jobs_tag_add failed", { error: String(error) });
-        return errorResult(
-          `Failed to tag: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-  );
-  server.registerTool(
-    track(mcpToolName(ctx.productName, "scheduler_tags_remove")),
-    {
-      title: "Untag Scheduled Job",
-      description: "Remove a tag assignment from a scheduled job.",
-      inputSchema: { entityId: zod.z.string(), tagId: zod.z.string() }
-    },
-    async ({ entityId, tagId }) => {
-      try {
-        const data = await ctx.gql.workspace.request(
-          UNTAG_SCHEDULED_JOB,
-          { input: { entityId, tagId } }
-        );
-        return jsonResult({ removed: data.untagScheduledJob });
-      } catch (error) {
-        ctx.logger.error("scheduler_jobs_tag_remove failed", { error: String(error) });
-        return errorResult(
-          `Failed to untag: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-  );
-  server.registerTool(
-    track(mcpToolName(ctx.productName, "scheduler_tags_replace")),
-    {
-      title: "Replace Scheduled Job Tags",
-      description: "Replace all tag assignments on a scheduled job.",
-      inputSchema: { entityId: zod.z.string(), tagIds: zod.z.array(zod.z.string()) }
-    },
-    async ({ entityId, tagIds }) => {
-      try {
-        const data = await ctx.gql.workspace.request(
-          REPLACE_SCHEDULED_JOB_TAGS,
-          { input: { entityId, tagIds } }
-        );
-        return jsonResult(data.replaceScheduledJobTags);
-      } catch (error) {
-        ctx.logger.error("scheduler_jobs_tag_replace failed", { error: String(error) });
-        return errorResult(
-          `Failed to replace tags: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-  );
-  server.registerTool(
-    track(mcpToolName(ctx.productName, "scheduler_tags_list")),
-    {
-      title: "List Scheduled Job Tags",
-      description: "List tag assignments on a scheduled job.",
-      inputSchema: { entityId: zod.z.string() }
-    },
-    async ({ entityId }) => {
-      try {
-        const data = await ctx.gql.workspace.request(
-          GET_SCHEDULED_JOB_TAGS,
-          { input: { entityId } }
-        );
-        return jsonResult(data.getScheduledJobTags);
-      } catch (error) {
-        ctx.logger.error("scheduler_jobs_tag_list failed", { error: String(error) });
-        return errorResult(
-          `Failed to list tags: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-  );
-  server.registerTool(
-    track(mcpToolName(ctx.productName, "scheduler_executions_check")),
-    {
-      title: "Check Execution Status (poll)",
-      description: "Polling proxy for the executionUpdated subscription \u2014 returns the current state of an execution.",
-      inputSchema: { id: zod.z.string().describe("Execution ID") }
-    },
-    async ({ id }) => {
-      try {
-        const data = await ctx.gql.workspace.request(
-          EXECUTION_UPDATED_POLL,
-          { id }
-        );
-        if (!data.jobExecution) return errorResult(`Execution ${id} not found`);
-        return jsonResult(data.jobExecution);
-      } catch (error) {
-        ctx.logger.error("scheduler_executions_check failed", { error: String(error) });
-        return errorResult(`Failed: ${error instanceof Error ? error.message : String(error)}`);
-      }
-    }
-  );
-  server.registerTool(
-    track(mcpToolName(ctx.productName, "scheduler_jobs_check")),
-    {
-      title: "Check Job Status (poll)",
-      description: "Polling proxy for the jobStatusUpdated subscription \u2014 returns the current state of a scheduled job.",
-      inputSchema: { id: zod.z.string().describe("Schedule ID") }
-    },
-    async ({ id }) => {
-      try {
-        const data = await ctx.gql.workspace.request(
-          JOB_STATUS_UPDATED_POLL,
-          { id }
-        );
-        if (!data.scheduledJob) return errorResult(`Job ${id} not found`);
-        return jsonResult(data.scheduledJob);
-      } catch (error) {
-        ctx.logger.error("scheduler_jobs_check failed", { error: String(error) });
-        return errorResult(`Failed: ${error instanceof Error ? error.message : String(error)}`);
-      }
-    }
-  );
-  server.registerTool(
-    track(mcpToolName(ctx.productName, "scheduler_executions_retry")),
-    {
-      title: "Retry Job Execution",
-      description: "Re-run a failed (or completed) scheduled-job execution. Returns the new JobExecution row created for the retry.",
-      inputSchema: { executionId: zod.z.string().describe("Execution ID to retry") }
-    },
-    async ({ executionId }) => {
-      try {
-        const data = await ctx.gql.workspace.request(
-          RETRY_JOB_EXECUTION,
-          { executionId }
-        );
-        return jsonResult(data.retryJobExecution);
-      } catch (error) {
-        ctx.logger.error("scheduler_executions_retry failed", { error: String(error) });
-        return errorResult(
-          `Failed to retry job execution: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-  );
 }
 
 // src/modules/scheduler/index.ts