@sentry/junior-scheduler 0.88.0 → 0.90.0

package/dist/tool-support.d.ts

@@ -0,0 +1,275 @@
+import { type PluginCredentialSubject, type SlackDestination, type SlackRequester, type SlackSource } from "@sentry/junior-plugin-api";
+import { z } from "zod";
+import { type SchedulerStore } from "./store";
+import type { ScheduledTask, ScheduledTaskConversationAccess, ScheduledTaskPrincipal, ScheduledTaskRecurrence, ScheduledTaskStatus } from "./types";
+export interface SchedulerToolContext {
+    credentialSubject?: PluginCredentialSubject;
+    requester?: SlackRequester;
+    source?: SlackSource;
+    store: SchedulerStore;
+    userText?: string;
+}
+export declare const MAX_LISTED_TASKS = 50;
+declare const compactTaskResultSchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        blocked: "blocked";
+        active: "active";
+        paused: "paused";
+        deleted: "deleted";
+    }>;
+    task: z.ZodString;
+    schedule: z.ZodString;
+    timezone: z.ZodString;
+    recurrence: z.ZodNullable<z.ZodUnknown>;
+    next_run_at: z.ZodNullable<z.ZodString>;
+    conversation_access: z.ZodNullable<z.ZodUnknown>;
+    credential_subject: z.ZodNullable<z.ZodUnknown>;
+    last_run_at: z.ZodNullable<z.ZodString>;
+    run_now_at: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const scheduleTaskToolResultSchema: z.ZodObject<{
+    truncated: z.ZodOptional<z.ZodBoolean>;
+    continuation: z.ZodOptional<z.ZodObject<{
+        arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    error: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodString;
+        message: z.ZodString;
+        retryable: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>, z.ZodString]>>;
+    ok: z.ZodLiteral<true>;
+    status: z.ZodLiteral<"success">;
+    target: z.ZodString;
+    data: z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+        task: z.ZodObject<{
+            id: z.ZodString;
+            status: z.ZodEnum<{
+                blocked: "blocked";
+                active: "active";
+                paused: "paused";
+                deleted: "deleted";
+            }>;
+            task: z.ZodString;
+            schedule: z.ZodString;
+            timezone: z.ZodString;
+            recurrence: z.ZodNullable<z.ZodUnknown>;
+            next_run_at: z.ZodNullable<z.ZodString>;
+            conversation_access: z.ZodNullable<z.ZodUnknown>;
+            credential_subject: z.ZodNullable<z.ZodUnknown>;
+            last_run_at: z.ZodNullable<z.ZodString>;
+            run_now_at: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    task: z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodEnum<{
+            blocked: "blocked";
+            active: "active";
+            paused: "paused";
+            deleted: "deleted";
+        }>;
+        task: z.ZodString;
+        schedule: z.ZodString;
+        timezone: z.ZodString;
+        recurrence: z.ZodNullable<z.ZodUnknown>;
+        next_run_at: z.ZodNullable<z.ZodString>;
+        conversation_access: z.ZodNullable<z.ZodUnknown>;
+        credential_subject: z.ZodNullable<z.ZodUnknown>;
+        last_run_at: z.ZodNullable<z.ZodString>;
+        run_now_at: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$loose>;
+export declare const scheduleListToolResultSchema: z.ZodObject<{
+    continuation: z.ZodOptional<z.ZodObject<{
+        arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    error: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodString;
+        message: z.ZodString;
+        retryable: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>, z.ZodString]>>;
+    ok: z.ZodLiteral<true>;
+    status: z.ZodLiteral<"success">;
+    target: z.ZodString;
+    data: z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+        tasks: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            status: z.ZodEnum<{
+                blocked: "blocked";
+                active: "active";
+                paused: "paused";
+                deleted: "deleted";
+            }>;
+            task: z.ZodString;
+            schedule: z.ZodString;
+            timezone: z.ZodString;
+            recurrence: z.ZodNullable<z.ZodUnknown>;
+            next_run_at: z.ZodNullable<z.ZodString>;
+            conversation_access: z.ZodNullable<z.ZodUnknown>;
+            credential_subject: z.ZodNullable<z.ZodUnknown>;
+            last_run_at: z.ZodNullable<z.ZodString>;
+            run_now_at: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>;
+    tasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodEnum<{
+            blocked: "blocked";
+            active: "active";
+            paused: "paused";
+            deleted: "deleted";
+        }>;
+        task: z.ZodString;
+        schedule: z.ZodString;
+        timezone: z.ZodString;
+        recurrence: z.ZodNullable<z.ZodUnknown>;
+        next_run_at: z.ZodNullable<z.ZodString>;
+        conversation_access: z.ZodNullable<z.ZodUnknown>;
+        credential_subject: z.ZodNullable<z.ZodUnknown>;
+        last_run_at: z.ZodNullable<z.ZodString>;
+        run_now_at: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    truncated: z.ZodBoolean;
+}, z.core.$loose>;
+export type CompactTaskResult = z.output<typeof compactTaskResultSchema>;
+/** Normalize scheduler validation failures into the plugin tool error contract. */
+export declare function throwToolInputError(error: string): never;
+/** Require scheduler mutations to stay scoped to the active Slack conversation. */
+export declare function requireActiveConversation(context: SchedulerToolContext): SlackDestination;
+/** Require a concrete Slack requester before creating scheduler ownership state. */
+export declare function requireRequester(context: SchedulerToolContext): ScheduledTaskPrincipal;
+/** Preserve destination visibility so scheduled work can replay with matching access. */
+export declare function getConversationAccess(destination: SlackDestination): ScheduledTaskConversationAccess;
+/** Carry private-DM credential authority only when scheduled work is allowed to reuse it. */
+export declare function getCredentialSubject(args: {
+    access: ScheduledTaskConversationAccess;
+    subject: PluginCredentialSubject | undefined;
+}): PluginCredentialSubject | undefined;
+/** Keep scheduler management operations bound to the task's original Slack destination. */
+export declare function sameDestination(task: ScheduledTask, destination: SlackDestination): boolean;
+/** Look up a mutable task only after enforcing active-conversation ownership. */
+export declare function getWritableTask(args: {
+    context: SchedulerToolContext;
+    taskId: string;
+}): Promise<ScheduledTask>;
+/** Project scheduled task state into the stable model-facing result shape. */
+export declare function compactTask(task: ScheduledTask): CompactTaskResult;
+/** Build the structured result shared by single-task scheduler tools. */
+export declare function scheduleTaskToolResult(target: string, task: CompactTaskResult): {
+    readonly ok: true;
+    readonly status: "success";
+    readonly target: string;
+    readonly data: {
+        readonly ok: true;
+        readonly task: {
+            id: string;
+            status: "blocked" | "active" | "paused" | "deleted";
+            task: string;
+            schedule: string;
+            timezone: string;
+            recurrence: unknown;
+            next_run_at: string | null;
+            conversation_access: unknown;
+            credential_subject: unknown;
+            last_run_at: string | null;
+            run_now_at: string | null;
+        };
+    };
+    readonly task: {
+        id: string;
+        status: "blocked" | "active" | "paused" | "deleted";
+        task: string;
+        schedule: string;
+        timezone: string;
+        recurrence: unknown;
+        next_run_at: string | null;
+        conversation_access: unknown;
+        credential_subject: unknown;
+        last_run_at: string | null;
+        run_now_at: string | null;
+    };
+};
+/** Build the structured result for listing scheduler tools. */
+export declare function scheduleListToolResult(args: {
+    target: string;
+    tasks: CompactTaskResult[];
+    truncated: boolean;
+}): {
+    readonly ok: true;
+    readonly status: "success";
+    readonly target: string;
+    readonly data: {
+        readonly ok: true;
+        readonly tasks: {
+            id: string;
+            status: "blocked" | "active" | "paused" | "deleted";
+            task: string;
+            schedule: string;
+            timezone: string;
+            recurrence: unknown;
+            next_run_at: string | null;
+            conversation_access: unknown;
+            credential_subject: unknown;
+            last_run_at: string | null;
+            run_now_at: string | null;
+        }[];
+        readonly truncated: boolean;
+    };
+    readonly tasks: {
+        id: string;
+        status: "blocked" | "active" | "paused" | "deleted";
+        task: string;
+        schedule: string;
+        timezone: string;
+        recurrence: unknown;
+        next_run_at: string | null;
+        conversation_access: unknown;
+        credential_subject: unknown;
+        last_run_at: string | null;
+        run_now_at: string | null;
+    }[];
+    readonly truncated: boolean;
+};
+/** Prefix generated scheduler ids so tool results are distinguishable from provider ids. */
+export declare function buildTaskId(): string;
+/** Keep concrete scheduler tools coupled to the injected store, not global state. */
+export declare function schedulerStore(context: SchedulerToolContext): SchedulerStore;
+/** Accept only persisted scheduler statuses from model-facing update input. */
+export declare function normalizeStatus(value: string | undefined): ScheduledTaskStatus | undefined;
+/** Rebuild recurrence only from validated daily-or-slower schedule requests. */
+export declare function buildRecurrence(args: {
+    existing?: ScheduledTaskRecurrence;
+    input: {
+        recurrence?: unknown;
+    };
+    nextRunAtMs: number | undefined;
+    timezone: string;
+}): ScheduledTaskRecurrence | undefined;
+/** Reject recurrence values that would exceed the scheduler cadence policy. */
+export declare function validateRecurringFrequencyLimit(input: {
+    recurrence?: unknown;
+}): void;
+/** Force create-tool callers to explicitly choose one-off versus recurring semantics. */
+export declare function validateCreateScheduleKind(input: {
+    recurrence?: unknown;
+    schedule_kind?: unknown;
+}): void;
+/** Detect update inputs that affect calendar recurrence materialization. */
+export declare function shouldRebuildRecurrence(input: {
+    next_run_at?: string;
+    recurrence?: unknown;
+    timezone?: string;
+}): boolean;
+/** Centralize scheduler timezone defaulting for all concrete tool entry points. */
+export declare function getDefaultScheduleTimezone(): string;
+/** Validate IANA timezone names before persisting scheduler cadence state. */
+export declare function isValidTimeZone(timezone: string): boolean;
+/** Parse model-supplied timestamps without leaking date parser details to tools. */
+export declare function parseNextRunAtMs(nextRunAtIso: string | undefined): number | undefined;
+export {};

package/dist/tools/create-task.d.ts

@@ -0,0 +1,54 @@
+import { type SchedulerToolContext } from "../tool-support";
+/** Create a tool that stores a scheduled task for the active Slack context. */
+export declare function createSlackScheduleCreateTaskTool(context: SchedulerToolContext): import("@sentry/junior-plugin-api").PluginToolDefinition<{
+    task: string;
+    schedule: string;
+    schedule_kind: "one_off" | "recurring";
+    timezone?: string | undefined;
+    next_run_at?: string | undefined;
+    recurrence?: "daily" | "weekly" | "monthly" | "yearly" | null | undefined;
+}, {
+    [x: string]: unknown;
+    ok: true;
+    status: "success";
+    target: string;
+    data: {
+        ok: true;
+        task: {
+            id: string;
+            status: "blocked" | "active" | "paused" | "deleted";
+            task: string;
+            schedule: string;
+            timezone: string;
+            recurrence: unknown;
+            next_run_at: string | null;
+            conversation_access: unknown;
+            credential_subject: unknown;
+            last_run_at: string | null;
+            run_now_at: string | null;
+        };
+    };
+    task: {
+        id: string;
+        status: "blocked" | "active" | "paused" | "deleted";
+        task: string;
+        schedule: string;
+        timezone: string;
+        recurrence: unknown;
+        next_run_at: string | null;
+        conversation_access: unknown;
+        credential_subject: unknown;
+        last_run_at: string | null;
+        run_now_at: string | null;
+    };
+    truncated?: boolean | undefined;
+    continuation?: {
+        arguments: Record<string, unknown>;
+        reason?: string | undefined;
+    } | undefined;
+    error?: string | {
+        kind: string;
+        message: string;
+        retryable?: boolean | undefined;
+    } | undefined;
+}>;

package/dist/tools/delete-task.d.ts

@@ -0,0 +1,49 @@
+import { type SchedulerToolContext } from "../tool-support";
+/** Create a tool that removes a scheduled task from the active Slack conversation. */
+export declare function createSlackScheduleDeleteTaskTool(context: SchedulerToolContext): import("@sentry/junior-plugin-api").PluginToolDefinition<{
+    task_id: string;
+}, {
+    [x: string]: unknown;
+    ok: true;
+    status: "success";
+    target: string;
+    data: {
+        ok: true;
+        task: {
+            id: string;
+            status: "blocked" | "active" | "paused" | "deleted";
+            task: string;
+            schedule: string;
+            timezone: string;
+            recurrence: unknown;
+            next_run_at: string | null;
+            conversation_access: unknown;
+            credential_subject: unknown;
+            last_run_at: string | null;
+            run_now_at: string | null;
+        };
+    };
+    task: {
+        id: string;
+        status: "blocked" | "active" | "paused" | "deleted";
+        task: string;
+        schedule: string;
+        timezone: string;
+        recurrence: unknown;
+        next_run_at: string | null;
+        conversation_access: unknown;
+        credential_subject: unknown;
+        last_run_at: string | null;
+        run_now_at: string | null;
+    };
+    truncated?: boolean | undefined;
+    continuation?: {
+        arguments: Record<string, unknown>;
+        reason?: string | undefined;
+    } | undefined;
+    error?: string | {
+        kind: string;
+        message: string;
+        retryable?: boolean | undefined;
+    } | undefined;
+}>;

package/dist/tools/list-tasks.d.ts

@@ -0,0 +1,48 @@
+import { type SchedulerToolContext } from "../tool-support";
+/** Create a tool that lists scheduled tasks for the active Slack conversation. */
+export declare function createSlackScheduleListTasksTool(context: SchedulerToolContext): import("@sentry/junior-plugin-api").PluginToolDefinition<Record<string, never>, {
+    [x: string]: unknown;
+    ok: true;
+    status: "success";
+    target: string;
+    data: {
+        ok: true;
+        tasks: {
+            id: string;
+            status: "blocked" | "active" | "paused" | "deleted";
+            task: string;
+            schedule: string;
+            timezone: string;
+            recurrence: unknown;
+            next_run_at: string | null;
+            conversation_access: unknown;
+            credential_subject: unknown;
+            last_run_at: string | null;
+            run_now_at: string | null;
+        }[];
+        truncated: boolean;
+    };
+    tasks: {
+        id: string;
+        status: "blocked" | "active" | "paused" | "deleted";
+        task: string;
+        schedule: string;
+        timezone: string;
+        recurrence: unknown;
+        next_run_at: string | null;
+        conversation_access: unknown;
+        credential_subject: unknown;
+        last_run_at: string | null;
+        run_now_at: string | null;
+    }[];
+    truncated: boolean;
+    continuation?: {
+        arguments: Record<string, unknown>;
+        reason?: string | undefined;
+    } | undefined;
+    error?: string | {
+        kind: string;
+        message: string;
+        retryable?: boolean | undefined;
+    } | undefined;
+}>;

package/dist/tools/run-task-now.d.ts

@@ -0,0 +1,49 @@
+import { type SchedulerToolContext } from "../tool-support";
+/** Create a tool that marks an existing scheduled task due immediately. */
+export declare function createSlackScheduleRunTaskNowTool(context: SchedulerToolContext): import("@sentry/junior-plugin-api").PluginToolDefinition<{
+    task_id: string;
+}, {
+    [x: string]: unknown;
+    ok: true;
+    status: "success";
+    target: string;
+    data: {
+        ok: true;
+        task: {
+            id: string;
+            status: "blocked" | "active" | "paused" | "deleted";
+            task: string;
+            schedule: string;
+            timezone: string;
+            recurrence: unknown;
+            next_run_at: string | null;
+            conversation_access: unknown;
+            credential_subject: unknown;
+            last_run_at: string | null;
+            run_now_at: string | null;
+        };
+    };
+    task: {
+        id: string;
+        status: "blocked" | "active" | "paused" | "deleted";
+        task: string;
+        schedule: string;
+        timezone: string;
+        recurrence: unknown;
+        next_run_at: string | null;
+        conversation_access: unknown;
+        credential_subject: unknown;
+        last_run_at: string | null;
+        run_now_at: string | null;
+    };
+    truncated?: boolean | undefined;
+    continuation?: {
+        arguments: Record<string, unknown>;
+        reason?: string | undefined;
+    } | undefined;
+    error?: string | {
+        kind: string;
+        message: string;
+        retryable?: boolean | undefined;
+    } | undefined;
+}>;

package/dist/tools/update-task.d.ts

@@ -0,0 +1,55 @@
+import { type SchedulerToolContext } from "../tool-support";
+/** Create a tool that edits a scheduled task in the active Slack conversation. */
+export declare function createSlackScheduleUpdateTaskTool(context: SchedulerToolContext): import("@sentry/junior-plugin-api").PluginToolDefinition<{
+    task_id: string;
+    task?: string | undefined;
+    schedule?: string | undefined;
+    timezone?: string | undefined;
+    next_run_at?: string | undefined;
+    recurrence?: "daily" | "weekly" | "monthly" | "yearly" | null | undefined;
+    status?: "blocked" | "active" | "paused" | undefined;
+}, {
+    [x: string]: unknown;
+    ok: true;
+    status: "success";
+    target: string;
+    data: {
+        ok: true;
+        task: {
+            id: string;
+            status: "blocked" | "active" | "paused" | "deleted";
+            task: string;
+            schedule: string;
+            timezone: string;
+            recurrence: unknown;
+            next_run_at: string | null;
+            conversation_access: unknown;
+            credential_subject: unknown;
+            last_run_at: string | null;
+            run_now_at: string | null;
+        };
+    };
+    task: {
+        id: string;
+        status: "blocked" | "active" | "paused" | "deleted";
+        task: string;
+        schedule: string;
+        timezone: string;
+        recurrence: unknown;
+        next_run_at: string | null;
+        conversation_access: unknown;
+        credential_subject: unknown;
+        last_run_at: string | null;
+        run_now_at: string | null;
+    };
+    truncated?: boolean | undefined;
+    continuation?: {
+        arguments: Record<string, unknown>;
+        reason?: string | undefined;
+    } | undefined;
+    error?: string | {
+        kind: string;
+        message: string;
+        retryable?: boolean | undefined;
+    } | undefined;
+}>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior-scheduler",
-  "version": "0.88.0",
+  "version": "0.90.0",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -23,10 +23,9 @@
     "src"
   ],
   "dependencies": {
-    "@sinclair/typebox": "^0.34.49",
     "drizzle-orm": "^0.45.2",
     "zod": "^4.4.3",
-    "@sentry/junior-plugin-api": "0.88.0"
+    "@sentry/junior-plugin-api": "0.90.0"
   },
   "devDependencies": {
     "@types/node": "^25.9.1",

package/src/plugin.ts

@@ -431,7 +431,7 @@ export function createSchedulerPlugin() {
           ctx.source.platform !== "slack" ||
           ctx.requester?.platform !== "slack"
         ) {
-          return {} as Record<string, PluginToolDefinition<any>>;
+          return {} as Record<string, PluginToolDefinition>;
         }
         const context = createSchedulerToolContext(ctx);
         return {
@@ -440,7 +440,7 @@ export function createSchedulerPlugin() {
           slackScheduleUpdateTask: createSlackScheduleUpdateTaskTool(context),
           slackScheduleDeleteTask: createSlackScheduleDeleteTaskTool(context),
           slackScheduleRunTaskNow: createSlackScheduleRunTaskNowTool(context),
-        } satisfies Record<string, PluginToolDefinition<any>>;
+        } satisfies Record<string, PluginToolDefinition>;
       },
       async heartbeat(ctx) {
         const store = schedulerStore(ctx);