@sentry/junior 0.128.1 → 0.129.0

package/dist/chat/scheduled-tasks/schedule-intent.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Owns model-facing schedule intent and materializes it against the trusted
+ * server clock into the canonical schedule persisted by core.
+ */
+import { z } from "zod";
+import type { ScheduledTaskSchedule } from "./types";
+export declare const scheduleIntentSchema: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"one_off">;
+    timezone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    timing: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"after">;
+        value: z.ZodNumber;
+        unit: z.ZodEnum<{
+            day: "day";
+            hour: "hour";
+            minute: "minute";
+            second: "second";
+            week: "week";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"at">;
+        date: z.ZodString;
+        time: z.ZodString;
+    }, z.core.$strict>], "type">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"recurring">;
+    frequency: z.ZodEnum<{
+        daily: "daily";
+        weekly: "weekly";
+        monthly: "monthly";
+        yearly: "yearly";
+    }>;
+    interval: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    time: z.ZodString;
+    weekdays: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodEnum<{
+        sunday: "sunday";
+        monday: "monday";
+        tuesday: "tuesday";
+        wednesday: "wednesday";
+        thursday: "thursday";
+        friday: "friday";
+        saturday: "saturday";
+    }>>>>;
+    day_of_month: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    month: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    start_date: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    timezone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>]>;
+export type ScheduleIntent = z.infer<typeof scheduleIntentSchema>;
+export interface CompiledScheduleIntent {
+    nextRunAtMs: number;
+    schedule: ScheduledTaskSchedule;
+}
+export declare class ScheduleIntentError extends Error {
+}
+/** Materialize model-interpreted schedule intent against the trusted server clock. */
+export declare function compileScheduleIntent(args: {
+    defaultTimezone: string;
+    intent: ScheduleIntent;
+    nowMs: number;
+}): CompiledScheduleIntent;

package/dist/chat/scheduled-tasks/store.d.ts

@@ -0,0 +1,77 @@
+import { type PluginReadState, type PluginState } from "@sentry/junior-plugin-api";
+import type { PgDatabase } from "drizzle-orm/pg-core";
+import type { PgQueryResultHKT } from "drizzle-orm/pg-core/session";
+import * as schedulerSqlSchema from "@/db/schema/scheduled-tasks";
+import { type ScheduledRun, type ScheduledTask } from "./types";
+export type SchedulerDb = PgDatabase<PgQueryResultHKT, typeof schedulerSqlSchema>;
+export interface SchedulerStore {
+    claimDueRun(args: {
+        nowMs: number;
+    }): Promise<ScheduledRun | undefined>;
+    createTask(task: ScheduledTask): Promise<ScheduledTask>;
+    getRun(runId: string): Promise<ScheduledRun | undefined>;
+    getTask(taskId: string): Promise<ScheduledTask | undefined>;
+    listIncompleteRuns(): Promise<ScheduledRun[]>;
+    listTasks(): Promise<ScheduledTask[]>;
+    listTasksCreatedBy(input: ListTasksCreatedByInput): Promise<ScheduledTask[]>;
+    listTasksForTeam(teamId: string): Promise<ScheduledTask[]>;
+    markRunBlocked(args: {
+        completedAtMs: number;
+        errorMessage: string;
+        runId: string;
+        startedAtMs?: number;
+    }): Promise<ScheduledRun | undefined>;
+    markRunCompleted(args: {
+        completedAtMs: number;
+        resultMessageTs?: string;
+        runId: string;
+        startedAtMs: number;
+    }): Promise<ScheduledRun | undefined>;
+    markRunFailed(args: {
+        completedAtMs: number;
+        errorMessage: string;
+        startedAtMs?: number;
+        runId: string;
+    }): Promise<ScheduledRun | undefined>;
+    markRunSkipped(args: {
+        completedAtMs: number;
+        errorMessage: string;
+        runId: string;
+    }): Promise<ScheduledRun | undefined>;
+    markRunDispatched(args: {
+        claimedAtMs: number;
+        dispatchId: string;
+        nowMs: number;
+        runId: string;
+    }): Promise<ScheduledRun | undefined>;
+    saveTask(task: ScheduledTask): Promise<void>;
+    updateTaskAfterRun(args: {
+        errorMessage?: string;
+        nowMs: number;
+        run: ScheduledRun;
+        status: "blocked" | "completed" | "failed";
+    }): Promise<void>;
+}
+export interface ListTasksCreatedByInput {
+    before?: {
+        createdAtMs: number;
+        id: string;
+    };
+    identityIds: string[];
+    limit: number;
+    query?: string;
+}
+export interface SchedulerOperationalStore {
+    listIncompleteRunsForTasks(tasks: ScheduledTask[]): Promise<ScheduledRun[]>;
+    listTasks(): Promise<ScheduledTask[]>;
+}
+/** Create a scheduler store backed by this plugin's durable state namespace. */
+export declare function createSchedulerStore(state: PluginState): SchedulerStore;
+/** Create a read-only scheduler store for operational reporting. */
+export declare function createSchedulerOperationalStore(state: PluginReadState): SchedulerOperationalStore;
+/** List scheduled tasks whose current Slack destination is public. */
+export declare function listPublicScheduledTasksForTeams(db: SchedulerDb, teamIds: string[], limit: number): Promise<ScheduledTask[]>;
+/** Create a scheduler store backed by the plugin SQL database. */
+export declare function createSchedulerSqlStore(db: SchedulerDb): SchedulerStore;
+/** Create a read-only scheduler operational store backed by SQL. */
+export declare function createSchedulerOperationalSqlStore(db: SchedulerDb): SchedulerOperationalStore;

package/dist/chat/scheduled-tasks/tool-support.d.ts

@@ -0,0 +1,203 @@
+import { type Identity, type SlackDestination, type SlackActor, type SlackSource, type User } from "@sentry/junior-plugin-api";
+import { z } from "zod";
+import { type SchedulerStore } from "./store";
+import type { ScheduledTask, ScheduledTaskConversationAccess, ScheduledTaskPrincipal, ScheduledTaskStatus } from "./types";
+export interface SchedulerToolContext {
+    actor?: SlackActor;
+    now?: () => number;
+    source?: SlackSource;
+    store: SchedulerStore;
+    users: {
+        resolveActor(): Promise<{
+            identity: Identity;
+            user?: User;
+        } | undefined>;
+    };
+    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.ZodObject<{
+        audience: z.ZodEnum<{
+            direct: "direct";
+            channel: "channel";
+            group: "group";
+        }>;
+        visibility: z.ZodEnum<{
+            public: "public";
+            private: "private";
+        }>;
+    }, z.core.$strict>;
+    credential_mode: z.ZodEnum<{
+        system: "system";
+        creator: "creator";
+    }>;
+    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>>;
+    target: z.ZodString;
+    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.ZodObject<{
+            audience: z.ZodEnum<{
+                direct: "direct";
+                channel: "channel";
+                group: "group";
+            }>;
+            visibility: z.ZodEnum<{
+                public: "public";
+                private: "private";
+            }>;
+        }, z.core.$strict>;
+        credential_mode: z.ZodEnum<{
+            system: "system";
+            creator: "creator";
+        }>;
+        last_run_at: z.ZodNullable<z.ZodString>;
+        run_now_at: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+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>>;
+    target: z.ZodString;
+    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.ZodObject<{
+            audience: z.ZodEnum<{
+                direct: "direct";
+                channel: "channel";
+                group: "group";
+            }>;
+            visibility: z.ZodEnum<{
+                public: "public";
+                private: "private";
+            }>;
+        }, z.core.$strict>;
+        credential_mode: z.ZodEnum<{
+            system: "system";
+            creator: "creator";
+        }>;
+        last_run_at: z.ZodNullable<z.ZodString>;
+        run_now_at: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    truncated: z.ZodBoolean;
+}, z.core.$strict>;
+export type CompactTaskResult = z.output<typeof compactTaskResultSchema>;
+/** Normalize scheduled-task validation failures into the core tool 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 actor before creating scheduler ownership state. */
+export declare function requireActor(context: SchedulerToolContext, destination: SlackDestination): ScheduledTaskPrincipal;
+/** Preserve the active destination's ingress-confirmed access classification. */
+export declare function getConversationAccess(destination: SlackDestination, source: SlackSource | undefined): ScheduledTaskConversationAccess;
+/** 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 target: string;
+    readonly task: {
+        id: string;
+        status: "blocked" | "active" | "paused" | "deleted";
+        task: string;
+        schedule: string;
+        timezone: string;
+        recurrence: unknown;
+        next_run_at: string | null;
+        conversation_access: {
+            audience: "direct" | "channel" | "group";
+            visibility: "public" | "private";
+        };
+        credential_mode: "system" | "creator";
+        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 target: string;
+    readonly tasks: {
+        id: string;
+        status: "blocked" | "active" | "paused" | "deleted";
+        task: string;
+        schedule: string;
+        timezone: string;
+        recurrence: unknown;
+        next_run_at: string | null;
+        conversation_access: {
+            audience: "direct" | "channel" | "group";
+            visibility: "public" | "private";
+        };
+        credential_mode: "system" | "creator";
+        last_run_at: string | null;
+        run_now_at: string | null;
+    }[];
+    readonly truncated: boolean;
+};
+/** Build a retry-stable scheduler id scoped to the creating actor and destination. */
+export declare function buildTaskId(args: {
+    actor: ScheduledTaskPrincipal;
+    destination: SlackDestination;
+    toolCallId: string | undefined;
+}): 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;
+/** Centralize scheduler timezone defaulting for all concrete tool entry points. */
+export declare function getDefaultScheduleTimezone(): string;
+export {};

package/dist/chat/scheduled-tasks/tools/create.d.ts

@@ -0,0 +1,80 @@
+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): Omit<import("../../tools/definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+    inputSchema: import("../../tools/definition").JsonSchemaObject;
+    outputSchema: import("../../tools/definition").JsonSchemaObject;
+    prepareArguments(args: unknown): {
+        task: string;
+        schedule: {
+            kind: "recurring";
+            frequency: "daily" | "weekly" | "monthly" | "yearly";
+            time: string;
+            interval?: number | null | undefined;
+            weekdays?: ("sunday" | "monday" | "tuesday" | "wednesday" | "thursday" | "friday" | "saturday")[] | null | undefined;
+            day_of_month?: number | null | undefined;
+            month?: number | null | undefined;
+            start_date?: string | null | undefined;
+            timezone?: string | null | undefined;
+        } | {
+            kind: "one_off";
+            timing: {
+                type: "after";
+                value: number;
+                unit: "day" | "hour" | "minute" | "second" | "week";
+            } | {
+                type: "at";
+                date: string;
+                time: string;
+            };
+            timezone?: string | null | undefined;
+        };
+        credential_mode?: "system" | "creator" | null | undefined;
+    };
+    execute?: ((input: unknown, options: import("../../tools/definition").ToolExecuteOptions) => {
+        target: string;
+        task: {
+            id: string;
+            status: "blocked" | "active" | "paused" | "deleted";
+            task: string;
+            schedule: string;
+            timezone: string;
+            recurrence: unknown;
+            next_run_at: string | null;
+            conversation_access: {
+                audience: "direct" | "channel" | "group";
+                visibility: "public" | "private";
+            };
+            credential_mode: "system" | "creator";
+            last_run_at: string | null;
+            run_now_at: string | null;
+        };
+        truncated?: boolean | undefined;
+        continuation?: {
+            arguments: Record<string, unknown>;
+            reason?: string | undefined;
+        } | undefined;
+    } | Promise<{
+        target: string;
+        task: {
+            id: string;
+            status: "blocked" | "active" | "paused" | "deleted";
+            task: string;
+            schedule: string;
+            timezone: string;
+            recurrence: unknown;
+            next_run_at: string | null;
+            conversation_access: {
+                audience: "direct" | "channel" | "group";
+                visibility: "public" | "private";
+            };
+            credential_mode: "system" | "creator";
+            last_run_at: string | null;
+            run_now_at: string | null;
+        };
+        truncated?: boolean | undefined;
+        continuation?: {
+            arguments: Record<string, unknown>;
+            reason?: string | undefined;
+        } | undefined;
+    }>) | undefined;
+};

package/dist/chat/scheduled-tasks/tools/delete.d.ts

@@ -0,0 +1,56 @@
+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): Omit<import("../../tools/definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+    inputSchema: import("../../tools/definition").JsonSchemaObject;
+    outputSchema: import("../../tools/definition").JsonSchemaObject;
+    prepareArguments(args: unknown): {
+        task_id: string;
+    };
+    execute?: ((input: unknown, options: import("../../tools/definition").ToolExecuteOptions) => {
+        target: string;
+        task: {
+            id: string;
+            status: "blocked" | "active" | "paused" | "deleted";
+            task: string;
+            schedule: string;
+            timezone: string;
+            recurrence: unknown;
+            next_run_at: string | null;
+            conversation_access: {
+                audience: "direct" | "channel" | "group";
+                visibility: "public" | "private";
+            };
+            credential_mode: "system" | "creator";
+            last_run_at: string | null;
+            run_now_at: string | null;
+        };
+        truncated?: boolean | undefined;
+        continuation?: {
+            arguments: Record<string, unknown>;
+            reason?: string | undefined;
+        } | undefined;
+    } | Promise<{
+        target: string;
+        task: {
+            id: string;
+            status: "blocked" | "active" | "paused" | "deleted";
+            task: string;
+            schedule: string;
+            timezone: string;
+            recurrence: unknown;
+            next_run_at: string | null;
+            conversation_access: {
+                audience: "direct" | "channel" | "group";
+                visibility: "public" | "private";
+            };
+            credential_mode: "system" | "creator";
+            last_run_at: string | null;
+            run_now_at: string | null;
+        };
+        truncated?: boolean | undefined;
+        continuation?: {
+            arguments: Record<string, unknown>;
+            reason?: string | undefined;
+        } | undefined;
+    }>) | undefined;
+};

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

@@ -0,0 +1,54 @@
+import { type SchedulerToolContext } from "../tool-support";
+/** Create a tool that lists scheduled tasks for the active Slack conversation. */
+export declare function createSlackScheduleListTasksTool(context: SchedulerToolContext): Omit<import("../../tools/definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+    inputSchema: import("../../tools/definition").JsonSchemaObject;
+    outputSchema: import("../../tools/definition").JsonSchemaObject;
+    prepareArguments(args: unknown): Record<string, never>;
+    execute?: ((input: unknown, options: import("../../tools/definition").ToolExecuteOptions) => {
+        target: string;
+        tasks: {
+            id: string;
+            status: "blocked" | "active" | "paused" | "deleted";
+            task: string;
+            schedule: string;
+            timezone: string;
+            recurrence: unknown;
+            next_run_at: string | null;
+            conversation_access: {
+                audience: "direct" | "channel" | "group";
+                visibility: "public" | "private";
+            };
+            credential_mode: "system" | "creator";
+            last_run_at: string | null;
+            run_now_at: string | null;
+        }[];
+        truncated: boolean;
+        continuation?: {
+            arguments: Record<string, unknown>;
+            reason?: string | undefined;
+        } | undefined;
+    } | Promise<{
+        target: string;
+        tasks: {
+            id: string;
+            status: "blocked" | "active" | "paused" | "deleted";
+            task: string;
+            schedule: string;
+            timezone: string;
+            recurrence: unknown;
+            next_run_at: string | null;
+            conversation_access: {
+                audience: "direct" | "channel" | "group";
+                visibility: "public" | "private";
+            };
+            credential_mode: "system" | "creator";
+            last_run_at: string | null;
+            run_now_at: string | null;
+        }[];
+        truncated: boolean;
+        continuation?: {
+            arguments: Record<string, unknown>;
+            reason?: string | undefined;
+        } | undefined;
+    }>) | undefined;
+};

package/dist/chat/scheduled-tasks/tools/run-now.d.ts

@@ -0,0 +1,56 @@
+import { type SchedulerToolContext } from "../tool-support";
+/** Create a tool that marks an existing scheduled task due immediately. */
+export declare function createSlackScheduleRunTaskNowTool(context: SchedulerToolContext): Omit<import("../../tools/definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+    inputSchema: import("../../tools/definition").JsonSchemaObject;
+    outputSchema: import("../../tools/definition").JsonSchemaObject;
+    prepareArguments(args: unknown): {
+        task_id: string;
+    };
+    execute?: ((input: unknown, options: import("../../tools/definition").ToolExecuteOptions) => {
+        target: string;
+        task: {
+            id: string;
+            status: "blocked" | "active" | "paused" | "deleted";
+            task: string;
+            schedule: string;
+            timezone: string;
+            recurrence: unknown;
+            next_run_at: string | null;
+            conversation_access: {
+                audience: "direct" | "channel" | "group";
+                visibility: "public" | "private";
+            };
+            credential_mode: "system" | "creator";
+            last_run_at: string | null;
+            run_now_at: string | null;
+        };
+        truncated?: boolean | undefined;
+        continuation?: {
+            arguments: Record<string, unknown>;
+            reason?: string | undefined;
+        } | undefined;
+    } | Promise<{
+        target: string;
+        task: {
+            id: string;
+            status: "blocked" | "active" | "paused" | "deleted";
+            task: string;
+            schedule: string;
+            timezone: string;
+            recurrence: unknown;
+            next_run_at: string | null;
+            conversation_access: {
+                audience: "direct" | "channel" | "group";
+                visibility: "public" | "private";
+            };
+            credential_mode: "system" | "creator";
+            last_run_at: string | null;
+            run_now_at: string | null;
+        };
+        truncated?: boolean | undefined;
+        continuation?: {
+            arguments: Record<string, unknown>;
+            reason?: string | undefined;
+        } | undefined;
+    }>) | undefined;
+};

package/dist/chat/scheduled-tasks/tools/update.d.ts

@@ -0,0 +1,82 @@
+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): Omit<import("../../tools/definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+    inputSchema: import("../../tools/definition").JsonSchemaObject;
+    outputSchema: import("../../tools/definition").JsonSchemaObject;
+    prepareArguments(args: unknown): {
+        task_id: string;
+        task?: string | undefined;
+        schedule?: {
+            kind: "recurring";
+            frequency: "daily" | "weekly" | "monthly" | "yearly";
+            time: string;
+            interval?: number | null | undefined;
+            weekdays?: ("sunday" | "monday" | "tuesday" | "wednesday" | "thursday" | "friday" | "saturday")[] | null | undefined;
+            day_of_month?: number | null | undefined;
+            month?: number | null | undefined;
+            start_date?: string | null | undefined;
+            timezone?: string | null | undefined;
+        } | {
+            kind: "one_off";
+            timing: {
+                type: "after";
+                value: number;
+                unit: "day" | "hour" | "minute" | "second" | "week";
+            } | {
+                type: "at";
+                date: string;
+                time: string;
+            };
+            timezone?: string | null | undefined;
+        } | null | undefined;
+        status?: "blocked" | "active" | "paused" | undefined;
+        credential_mode?: "system" | "creator" | null | undefined;
+    };
+    execute?: ((input: unknown, options: import("../../tools/definition").ToolExecuteOptions) => {
+        target: string;
+        task: {
+            id: string;
+            status: "blocked" | "active" | "paused" | "deleted";
+            task: string;
+            schedule: string;
+            timezone: string;
+            recurrence: unknown;
+            next_run_at: string | null;
+            conversation_access: {
+                audience: "direct" | "channel" | "group";
+                visibility: "public" | "private";
+            };
+            credential_mode: "system" | "creator";
+            last_run_at: string | null;
+            run_now_at: string | null;
+        };
+        truncated?: boolean | undefined;
+        continuation?: {
+            arguments: Record<string, unknown>;
+            reason?: string | undefined;
+        } | undefined;
+    } | Promise<{
+        target: string;
+        task: {
+            id: string;
+            status: "blocked" | "active" | "paused" | "deleted";
+            task: string;
+            schedule: string;
+            timezone: string;
+            recurrence: unknown;
+            next_run_at: string | null;
+            conversation_access: {
+                audience: "direct" | "channel" | "group";
+                visibility: "public" | "private";
+            };
+            credential_mode: "system" | "creator";
+            last_run_at: string | null;
+            run_now_at: string | null;
+        };
+        truncated?: boolean | undefined;
+        continuation?: {
+            arguments: Record<string, unknown>;
+            reason?: string | undefined;
+        } | undefined;
+    }>) | undefined;
+};

package/dist/chat/scheduled-tasks/tools.d.ts

@@ -0,0 +1,6 @@
+export { createSlackScheduleCreateTaskTool } from "./tools/create";
+export { createSlackScheduleDeleteTaskTool } from "./tools/delete";
+export { createSlackScheduleListTasksTool } from "./tools/list";
+export { createSlackScheduleRunTaskNowTool } from "./tools/run-now";
+export { createSlackScheduleUpdateTaskTool } from "./tools/update";
+export type { SchedulerToolContext } from "./tool-support";