@sentry/junior-scheduler 0.88.0 → 0.90.0

package/dist/index.js

@@ -1148,14 +1148,9 @@ function scheduledTaskPrincipalLabel(principal) {
   return `Slack User ${author.slackUserId}`;
 }
 
-// src/schedule-tools.ts
-import { randomUUID } from "crypto";
-import { Type } from "@sinclair/typebox";
-import {
-  PluginToolInputError,
-  pluginCredentialSubjectSchema as pluginCredentialSubjectSchema2,
-  sourceSchema
-} from "@sentry/junior-plugin-api";
+// src/tools/create-task.ts
+import { definePluginTool } from "@sentry/junior-plugin-api";
+import { z as z3 } from "zod";
 
 // src/types.ts
 var SCHEDULED_TASK_SYSTEM_ACTOR = Object.freeze({
@@ -1163,10 +1158,55 @@ var SCHEDULED_TASK_SYSTEM_ACTOR = Object.freeze({
   id: "scheduled-task"
 });
 
-// src/schedule-tools.ts
+// src/tool-support.ts
+import { randomUUID } from "crypto";
+import {
+  PluginToolInputError,
+  pluginToolResultSchema,
+  pluginCredentialSubjectSchema as pluginCredentialSubjectSchema2,
+  sourceSchema
+} from "@sentry/junior-plugin-api";
+import { z as z2 } from "zod";
 var TASK_ID_PREFIX = "sched";
 var MAX_LISTED_TASKS = 50;
 var DEFAULT_SCHEDULE_TIMEZONE = "America/Los_Angeles";
+var compactTaskResultSchema = z2.object({
+  id: z2.string(),
+  status: z2.enum(["active", "paused", "blocked", "deleted"]),
+  task: z2.string(),
+  schedule: z2.string(),
+  timezone: z2.string(),
+  recurrence: z2.unknown().nullable(),
+  next_run_at: z2.string().nullable(),
+  conversation_access: z2.unknown().nullable(),
+  credential_subject: z2.unknown().nullable(),
+  last_run_at: z2.string().nullable(),
+  run_now_at: z2.string().nullable()
+}).strict();
+var scheduleTaskResultDataSchema = z2.object({
+  ok: z2.literal(true),
+  task: compactTaskResultSchema
+}).strict();
+var scheduleTaskToolResultSchema = pluginToolResultSchema.extend({
+  ok: z2.literal(true),
+  status: z2.literal("success"),
+  target: z2.string(),
+  data: scheduleTaskResultDataSchema,
+  task: compactTaskResultSchema
+});
+var scheduleListResultDataSchema = z2.object({
+  ok: z2.literal(true),
+  tasks: z2.array(compactTaskResultSchema),
+  truncated: z2.boolean()
+}).strict();
+var scheduleListToolResultSchema = pluginToolResultSchema.extend({
+  ok: z2.literal(true),
+  status: z2.literal("success"),
+  target: z2.string(),
+  data: scheduleListResultDataSchema,
+  tasks: z2.array(compactTaskResultSchema),
+  truncated: z2.boolean()
+});
 function throwToolInputError(error) {
   throw new PluginToolInputError(error);
 }
@@ -1214,9 +1254,6 @@ function requireRequester(context) {
     ...context.requester?.fullName ? { fullName: context.requester.fullName } : {}
   });
 }
-function tool(definition) {
-  return definition;
-}
 function isDmChannel(channelId) {
   return channelId.startsWith("D");
 }
@@ -1269,7 +1306,7 @@ async function getWritableTask(args) {
   return task;
 }
 function compactTask(task) {
-  return {
+  return compactTaskResultSchema.parse({
     id: task.id,
     status: task.status,
     task: task.task.text,
@@ -1292,6 +1329,34 @@ function compactTask(task) {
     } : null,
     last_run_at: task.lastRunAtMs ? new Date(task.lastRunAtMs).toISOString() : null,
     run_now_at: task.runNowAtMs ? new Date(task.runNowAtMs).toISOString() : null
+  });
+}
+function scheduleTaskToolResult(target, task) {
+  const data = {
+    ok: true,
+    task
+  };
+  return {
+    ok: true,
+    status: "success",
+    target,
+    data,
+    task
+  };
+}
+function scheduleListToolResult(args) {
+  const data = {
+    ok: true,
+    tasks: args.tasks,
+    truncated: args.truncated
+  };
+  return {
+    ok: true,
+    status: "success",
+    target: args.target,
+    data,
+    tasks: args.tasks,
+    truncated: args.truncated
   };
 }
 function buildTaskId() {
@@ -1351,7 +1416,7 @@ function validateCreateScheduleKind(input) {
   if (input.schedule_kind !== "one_off" && input.schedule_kind !== "recurring") {
     throwToolInputError("schedule_kind must be one_off or recurring.");
   }
-  if (input.schedule_kind === "one_off" && input.recurrence !== void 0) {
+  if (input.schedule_kind === "one_off" && input.recurrence !== void 0 && input.recurrence !== null) {
     throwToolInputError("Omit recurrence when schedule_kind is one_off.");
   }
   if (input.schedule_kind === "recurring" && (input.recurrence === void 0 || input.recurrence === null)) {
@@ -1382,46 +1447,29 @@ function parseNextRunAtMs(nextRunAtIso) {
   }
   return void 0;
 }
+
+// src/tools/create-task.ts
 function createSlackScheduleCreateTaskTool(context) {
-  return tool({
+  return definePluginTool({
     description: "Create a one-time or recurring Junior task in the active Slack conversation. For one-time reminders or one-time scheduled work, omit recurrence entirely; never choose a default recurrence. Use only when the user explicitly asks Junior to do work later or on a recurring cadence. Only manage tasks for the active Slack DM or channel; never target threads, other channels, or another user's DM. When the task, schedule, and destination are clear, create it without asking for confirmation; ask only when one of those is ambiguous.",
     executionMode: "sequential",
-    inputSchema: Type.Object({
-      task: Type.String({ minLength: 1, maxLength: 4e3 }),
-      schedule: Type.String({ minLength: 1, maxLength: 300 }),
-      schedule_kind: Type.Union(
-        [Type.Literal("one_off"), Type.Literal("recurring")],
-        {
-          description: "Required schedule classification. Use one_off for one-time reminders or one-time scheduled work. Use recurring only when the user explicitly asks for a repeating schedule."
-        }
-      ),
-      timezone: Type.Optional(
-        Type.String({
-          minLength: 1,
-          maxLength: 80,
-          description: "IANA timezone, e.g. 'America/Los_Angeles'. Defaults to the channel's configured timezone."
-        })
-      ),
-      next_run_at: Type.Optional(
-        Type.String({
-          minLength: 1,
-          description: "Exact next run time as an ISO timestamp, computed from the user's requested schedule."
-        })
+    inputSchema: z3.object({
+      task: z3.string().min(1).max(4e3),
+      schedule: z3.string().min(1).max(300),
+      schedule_kind: z3.enum(["one_off", "recurring"]).describe(
+        "Required schedule classification. Use one_off for one-time reminders or one-time scheduled work. Use recurring only when the user explicitly asks for a repeating schedule."
       ),
-      recurrence: Type.Optional(
-        Type.Union(
-          [
-            Type.Literal("daily"),
-            Type.Literal("weekly"),
-            Type.Literal("monthly"),
-            Type.Literal("yearly")
-          ],
-          {
-            description: "Required when schedule_kind is recurring. Omit when schedule_kind is one_off. Recurring tasks run at most once per day: use daily, weekly, monthly, or yearly only."
-          }
-        )
-      )
+      timezone: z3.string().min(1).max(80).describe(
+        "IANA timezone, e.g. 'America/Los_Angeles'. Defaults to the channel's configured timezone."
+      ).optional(),
+      next_run_at: z3.string().min(1).describe(
+        "Exact next run time as an ISO timestamp, computed from the user's requested schedule."
+      ).optional(),
+      recurrence: z3.enum(["daily", "weekly", "monthly", "yearly"]).nullable().describe(
+        "Required when schedule_kind is recurring. Omit when schedule_kind is one_off. Recurring tasks run at most once per day: use daily, weekly, monthly, or yearly only."
+      ).optional()
     }),
+    outputSchema: scheduleTaskToolResultSchema,
     execute: async (input) => {
       const destination = requireActiveConversation(context);
       const requester = requireRequester(context);
@@ -1469,18 +1517,54 @@ function createSlackScheduleCreateTaskTool(context) {
         }
       };
       await schedulerStore(context).saveTask(task);
-      return {
-        ok: true,
-        task: compactTask(task)
+      return scheduleTaskToolResult(
+        "slackScheduleCreateTask",
+        compactTask(task)
+      );
+    }
+  });
+}
+
+// src/tools/delete-task.ts
+import { definePluginTool as definePluginTool2 } from "@sentry/junior-plugin-api";
+import { z as z4 } from "zod";
+function createSlackScheduleDeleteTaskTool(context) {
+  return definePluginTool2({
+    description: "Delete one scheduled Junior task from the active Slack conversation. Use only task IDs returned for this conversation. Do not delete schedules from threads, other channels, or another user's DM.",
+    executionMode: "sequential",
+    inputSchema: z4.object({
+      task_id: z4.string().min(1).describe(
+        "ID of the task to delete. Must be from this active Slack conversation."
+      )
+    }),
+    outputSchema: scheduleTaskToolResultSchema,
+    execute: async ({ task_id }) => {
+      const lookup = await getWritableTask({ context, taskId: task_id });
+      const next = {
+        ...lookup,
+        updatedAtMs: Date.now(),
+        status: "deleted",
+        nextRunAtMs: void 0,
+        runNowAtMs: void 0
       };
+      await schedulerStore(context).saveTask(next);
+      return scheduleTaskToolResult(
+        "slackScheduleDeleteTask",
+        compactTask(next)
+      );
     }
   });
 }
+
+// src/tools/list-tasks.ts
+import { definePluginTool as definePluginTool3 } from "@sentry/junior-plugin-api";
+import { z as z5 } from "zod";
 function createSlackScheduleListTasksTool(context) {
-  return tool({
+  return definePluginTool3({
     description: "List scheduled Junior tasks for the active Slack conversation. Use when the user asks what is scheduled here, or when task IDs are needed before editing, deleting, or running schedules. Only manages tasks for the active Slack DM or channel.",
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: Type.Object({}),
+    inputSchema: z5.object({}),
+    outputSchema: scheduleListToolResultSchema,
     execute: async () => {
       const destination = requireActiveConversation(context);
       const tasks = await schedulerStore(context).listTasksForTeam(
@@ -1490,59 +1574,73 @@ function createSlackScheduleListTasksTool(context) {
         (task) => sameDestination(task, destination)
       );
       const visible = matching.slice(0, MAX_LISTED_TASKS).map(compactTask);
-      return {
-        ok: true,
+      return scheduleListToolResult({
+        target: "slackScheduleListTasks",
         tasks: visible,
         truncated: matching.length > visible.length
+      });
+    }
+  });
+}
+
+// src/tools/run-task-now.ts
+import { definePluginTool as definePluginTool4 } from "@sentry/junior-plugin-api";
+import { z as z6 } from "zod";
+function createSlackScheduleRunTaskNowTool(context) {
+  return definePluginTool4({
+    description: "Queue an existing active scheduled Junior task to run as soon as possible, without changing its cadence. Use when the user asks to run an existing scheduled task now. Use only task IDs returned for this conversation.",
+    executionMode: "sequential",
+    inputSchema: z6.object({
+      task_id: z6.string().min(1).describe(
+        "ID of the active task to run now. Must be from this active Slack conversation."
+      )
+    }),
+    outputSchema: scheduleTaskToolResultSchema,
+    execute: async ({ task_id }) => {
+      const lookup = await getWritableTask({ context, taskId: task_id });
+      if (lookup.status !== "active") {
+        throwToolInputError(
+          "Scheduled task must be active before it can be run now. Resume the task first if you want it to run."
+        );
+      }
+      const nowMs = Date.now();
+      const next = {
+        ...lookup,
+        updatedAtMs: nowMs,
+        runNowAtMs: nowMs
       };
+      await schedulerStore(context).saveTask(next);
+      return scheduleTaskToolResult(
+        "slackScheduleRunTaskNow",
+        compactTask(next)
+      );
     }
   });
 }
+
+// src/tools/update-task.ts
+import { definePluginTool as definePluginTool5 } from "@sentry/junior-plugin-api";
+import { z as z7 } from "zod";
 function createSlackScheduleUpdateTaskTool(context) {
-  return tool({
+  return definePluginTool5({
     description: "Edit, pause, resume, or reschedule an existing Junior scheduled task in the active Slack conversation. Use only task IDs returned for this conversation. Do not move scheduled tasks across conversations.",
     executionMode: "sequential",
-    inputSchema: Type.Object({
-      task_id: Type.String({
-        minLength: 1,
-        description: "ID of the task to update. Must be from this active Slack conversation."
-      }),
-      task: Type.Optional(Type.String({ minLength: 1, maxLength: 4e3 })),
-      schedule: Type.Optional(Type.String({ minLength: 1, maxLength: 300 })),
-      timezone: Type.Optional(Type.String({ minLength: 1, maxLength: 80 })),
-      next_run_at: Type.Optional(
-        Type.String({
-          minLength: 1,
-          description: "Exact ISO timestamp when changing the next run time."
-        })
-      ),
-      recurrence: Type.Optional(
-        Type.Union(
-          [
-            Type.Literal("daily"),
-            Type.Literal("weekly"),
-            Type.Literal("monthly"),
-            Type.Literal("yearly"),
-            Type.Null()
-          ],
-          {
-            description: "Provide only for repeating schedules. Omit for one-time requests. Set to null to convert a recurring task to one-time."
-          }
-        )
+    inputSchema: z7.object({
+      task_id: z7.string().min(1).describe(
+        "ID of the task to update. Must be from this active Slack conversation."
       ),
-      status: Type.Optional(
-        Type.Union(
-          [
-            Type.Literal("active"),
-            Type.Literal("paused"),
-            Type.Literal("blocked")
-          ],
-          {
-            description: "Set to active, paused, or blocked to resume, pause, or block the task."
-          }
-        )
-      )
+      task: z7.string().min(1).max(4e3).optional(),
+      schedule: z7.string().min(1).max(300).optional(),
+      timezone: z7.string().min(1).max(80).optional(),
+      next_run_at: z7.string().min(1).describe("Exact ISO timestamp when changing the next run time.").optional(),
+      recurrence: z7.enum(["daily", "weekly", "monthly", "yearly"]).nullable().describe(
+        "Provide only for repeating schedules. Omit for one-time requests. Set to null to convert a recurring task to one-time."
+      ).optional(),
+      status: z7.enum(["active", "paused", "blocked"]).describe(
+        "Set to active, paused, or blocked to resume, pause, or block the task."
+      ).optional()
     }),
+    outputSchema: scheduleTaskToolResultSchema,
     execute: async (input) => {
       const lookup = await getWritableTask({
         context,
@@ -1591,68 +1689,10 @@ function createSlackScheduleUpdateTaskTool(context) {
         task: input.task ? { text: input.task } : lookup.task
       };
       await schedulerStore(context).saveTask(next);
-      return {
-        ok: true,
-        task: compactTask(next)
-      };
-    }
-  });
-}
-function createSlackScheduleDeleteTaskTool(context) {
-  return tool({
-    description: "Delete one scheduled Junior task from the active Slack conversation. Use only task IDs returned for this conversation. Do not delete schedules from threads, other channels, or another user's DM.",
-    executionMode: "sequential",
-    inputSchema: Type.Object({
-      task_id: Type.String({
-        minLength: 1,
-        description: "ID of the task to delete. Must be from this active Slack conversation."
-      })
-    }),
-    execute: async ({ task_id }) => {
-      const lookup = await getWritableTask({ context, taskId: task_id });
-      const next = {
-        ...lookup,
-        updatedAtMs: Date.now(),
-        status: "deleted",
-        nextRunAtMs: void 0,
-        runNowAtMs: void 0
-      };
-      await schedulerStore(context).saveTask(next);
-      return {
-        ok: true,
-        task: compactTask(next)
-      };
-    }
-  });
-}
-function createSlackScheduleRunTaskNowTool(context) {
-  return tool({
-    description: "Queue an existing active scheduled Junior task to run as soon as possible, without changing its cadence. Use when the user asks to run an existing scheduled task now. Use only task IDs returned for this conversation.",
-    executionMode: "sequential",
-    inputSchema: Type.Object({
-      task_id: Type.String({
-        minLength: 1,
-        description: "ID of the active task to run now. Must be from this active Slack conversation."
-      })
-    }),
-    execute: async ({ task_id }) => {
-      const lookup = await getWritableTask({ context, taskId: task_id });
-      if (lookup.status !== "active") {
-        throwToolInputError(
-          "Scheduled task must be active before it can be run now. Resume the task first if you want it to run."
-        );
-      }
-      const nowMs = Date.now();
-      const next = {
-        ...lookup,
-        updatedAtMs: nowMs,
-        runNowAtMs: nowMs
-      };
-      await schedulerStore(context).saveTask(next);
-      return {
-        ok: true,
-        task: compactTask(next)
-      };
+      return scheduleTaskToolResult(
+        "slackScheduleUpdateTask",
+        compactTask(next)
+      );
     }
   });
 }

package/dist/schedule-tools.d.ts

@@ -1,19 +1,6 @@
-import { type PluginCredentialSubject, type PluginToolDefinition, type SlackRequester, type SlackSource } from "@sentry/junior-plugin-api";
-import { type SchedulerStore } from "./store";
-export interface SchedulerToolContext {
-    credentialSubject?: PluginCredentialSubject;
-    requester?: SlackRequester;
-    source?: SlackSource;
-    store: SchedulerStore;
-    userText?: string;
-}
-/** Create a tool that stores a scheduled task for the active Slack context. */
-export declare function createSlackScheduleCreateTaskTool(context: SchedulerToolContext): PluginToolDefinition<any>;
-/** Create a tool that lists scheduled tasks for the active Slack conversation. */
-export declare function createSlackScheduleListTasksTool(context: SchedulerToolContext): PluginToolDefinition<any>;
-/** Create a tool that edits a scheduled task in the active Slack conversation. */
-export declare function createSlackScheduleUpdateTaskTool(context: SchedulerToolContext): PluginToolDefinition<any>;
-/** Create a tool that removes a scheduled task from the active Slack conversation. */
-export declare function createSlackScheduleDeleteTaskTool(context: SchedulerToolContext): PluginToolDefinition<any>;
-/** Create a tool that marks an existing scheduled task due immediately. */
-export declare function createSlackScheduleRunTaskNowTool(context: SchedulerToolContext): PluginToolDefinition<any>;
+export { createSlackScheduleCreateTaskTool } from "./tools/create-task";
+export { createSlackScheduleDeleteTaskTool } from "./tools/delete-task";
+export { createSlackScheduleListTasksTool } from "./tools/list-tasks";
+export { createSlackScheduleRunTaskNowTool } from "./tools/run-task-now";
+export { createSlackScheduleUpdateTaskTool } from "./tools/update-task";
+export type { SchedulerToolContext } from "./tool-support";