@sentry/junior 0.54.0 → 0.55.0

package/dist/chat/agent-dispatch/context.d.ts

@@ -0,0 +1,6 @@
+import type { HeartbeatHookContext } from "@sentry/junior-plugin-api";
+/** Build the plugin-scoped heartbeat context that gates durable dispatch access. */
+export declare function createHeartbeatContext(args: {
+    nowMs: number;
+    plugin: string;
+}): HeartbeatHookContext;

package/dist/chat/agent-dispatch/heartbeat.d.ts

@@ -0,0 +1,14 @@
+/** Re-drive stale core dispatches before invoking plugin heartbeat hooks. */
+export declare function recoverStaleDispatches(args: {
+    limit?: number;
+    nowMs: number;
+}): Promise<number>;
+/** Run trusted plugin heartbeat hooks with bounded per-invocation work. */
+export declare function runTrustedPluginHeartbeats(args: {
+    limit?: number;
+    nowMs: number;
+}): Promise<void>;
+/** Run the core heartbeat phases. */
+export declare function runHeartbeat(args: {
+    nowMs: number;
+}): Promise<void>;

package/dist/chat/agent-dispatch/runner.d.ts

@@ -0,0 +1,9 @@
+import { generateAssistantReply as generateAssistantReplyImpl } from "@/chat/respond";
+import { scheduleDispatchCallback } from "./signing";
+import type { DispatchCallback } from "./types";
+export interface AgentDispatchRunnerDeps {
+    generateAssistantReply?: typeof generateAssistantReplyImpl;
+    scheduleCallback?: typeof scheduleDispatchCallback;
+}
+/** Run one serverless slice for a core-owned agent dispatch. */
+export declare function runAgentDispatchSlice(callback: DispatchCallback, deps?: AgentDispatchRunnerDeps): Promise<void>;

package/dist/chat/agent-dispatch/signing.d.ts

@@ -0,0 +1,5 @@
+import type { DispatchCallback } from "./types";
+/** Schedule an authenticated internal callback to run a dispatched agent slice. */
+export declare function scheduleDispatchCallback(callback: DispatchCallback): Promise<void>;
+/** Verify and parse an authenticated agent dispatch callback request. */
+export declare function verifyDispatchCallbackRequest(request: Request): Promise<DispatchCallback | undefined>;

package/dist/chat/agent-dispatch/store.d.ts

@@ -0,0 +1,29 @@
+import type { StateAdapter } from "chat";
+import type { DispatchCreateResult, DispatchOptions, DispatchProjection, DispatchRecord, DispatchStatus } from "./types";
+/** Keep dispatch persistence keys consistent across callback and recovery paths. */
+export declare function getDispatchStorageKey(id: string): string;
+/** Map a dispatch destination to the conversation lock and memory key it owns. */
+export declare function getDispatchConversationId(destination: DispatchRecord["destination"]): string;
+/** Give dispatch slices stable turn ids for resumability and trace correlation. */
+export declare function getDispatchTurnId(dispatchId: string): string;
+/** Gate recovery to dispatches that can still make progress. */
+export declare function isTerminalDispatchStatus(status: DispatchStatus): boolean;
+/** Serialize mutations for a dispatch so callbacks and heartbeats stay idempotent. */
+export declare function withDispatchLock<T>(dispatchId: string, callback: (state: StateAdapter) => Promise<T>): Promise<T>;
+/** Load dispatch state for callback, recovery, and plugin projection paths. */
+export declare function getDispatchRecord(id: string): Promise<DispatchRecord | undefined>;
+/** Create a plugin dispatch idempotently from the plugin's idempotency key. */
+export declare function createOrGetDispatch(args: {
+    nowMs: number;
+    options: DispatchOptions;
+    plugin: string;
+}): Promise<DispatchCreateResult>;
+/** Advance dispatch versions so stale callbacks cannot overwrite newer state. */
+export declare function updateDispatchRecord(state: StateAdapter, record: DispatchRecord): Promise<DispatchRecord>;
+/** Feed heartbeat recovery from the durable incomplete-dispatch index. */
+export declare function listIncompleteDispatchIds(): Promise<string[]>;
+/** Return a plugin-scoped dispatch projection without exposing raw runtime state. */
+export declare function getPluginDispatchProjection(args: {
+    id: string;
+    plugin: string;
+}): Promise<DispatchProjection | undefined>;

package/dist/chat/agent-dispatch/types.d.ts

@@ -0,0 +1,57 @@
+export type DispatchStatus = "pending" | "running" | "awaiting_resume" | "completed" | "failed" | "blocked";
+export interface DispatchActor {
+    type: "system";
+    id: string;
+}
+export interface DispatchDestination {
+    platform: "slack";
+    teamId: string;
+    channelId: string;
+}
+export interface DispatchCredentialSubject {
+    type: "user";
+    userId: string;
+    allowedWhen: "private-direct-conversation";
+}
+export interface DispatchOptions {
+    credentialSubject?: DispatchCredentialSubject;
+    destination: DispatchDestination;
+    idempotencyKey: string;
+    input: string;
+    metadata?: Record<string, string>;
+}
+export interface DispatchRecord {
+    actor: DispatchActor;
+    attempt: number;
+    createdAtMs: number;
+    credentialSubject?: DispatchCredentialSubject;
+    destination: DispatchDestination;
+    errorMessage?: string;
+    id: string;
+    idempotencyKey: string;
+    input: string;
+    lastCallbackAtMs?: number;
+    leaseExpiresAtMs?: number;
+    maxAttempts: number;
+    metadata?: Record<string, string>;
+    plugin: string;
+    resultMessageTs?: string;
+    resumeCheckpointVersion?: number;
+    status: DispatchStatus;
+    updatedAtMs: number;
+    version: number;
+}
+export interface DispatchProjection {
+    errorMessage?: string;
+    id: string;
+    resultMessageTs?: string;
+    status: DispatchStatus;
+}
+export interface DispatchCallback {
+    expectedVersion: number;
+    id: string;
+}
+export interface DispatchCreateResult {
+    record: DispatchRecord;
+    status: "created" | "already_exists";
+}

package/dist/chat/agent-dispatch/validation.d.ts

@@ -0,0 +1,3 @@
+import type { DispatchOptions } from "./types";
+/** Validate plugin-provided dispatch options before core persists them. */
+export declare function validateDispatchOptions(options: DispatchOptions): void;

package/dist/chat/config.d.ts

@@ -24,6 +24,7 @@ export interface ChatConfig {
     };
     state: {
         adapter: "memory" | "redis";
+        keyPrefix?: string;
         redisUrl?: string;
     };
 }

package/dist/chat/ingress/workspace-membership.d.ts

@@ -1,5 +1,4 @@
-/** Run a callback with the workspace team ID available for membership checks. */
-export declare function runWithWorkspaceTeamId<T>(teamId: string | undefined, fn: () => T): T;
+export { runWithWorkspaceTeamId } from "@/chat/slack/workspace-context";
 /**
  * Return true when a Slack event's author is from an external workspace.
  *

package/dist/chat/logging.d.ts

@@ -20,6 +20,8 @@ export interface LogContext {
     slackUserName?: string;
     slackChannelId?: string;
     runId?: string;
+    actorType?: string;
+    actorId?: string;
     assistantUserName?: string;
     modelId?: string;
     skillName?: string;

package/dist/chat/plugins/agent-hooks.d.ts

@@ -0,0 +1,32 @@
+import type { AgentPluginRequester, JuniorPlugin } from "@sentry/junior-plugin-api";
+import type { ToolDefinition } from "@/chat/tools/definition";
+import type { ToolRuntimeContext } from "@/chat/tools/types";
+import type { SandboxInstance } from "@/chat/sandbox/workspace";
+/** Signal that a trusted plugin intentionally denied a tool execution. */
+export declare class AgentPluginHookDeniedError extends Error {
+    constructor(message: string);
+}
+export interface ToolHookInput {
+    input: Record<string, unknown>;
+    name: string;
+}
+export interface ToolHookResult {
+    env: Record<string, string>;
+    input: Record<string, unknown>;
+}
+export interface AgentPluginHookRunner {
+    beforeToolExecute(input: ToolHookInput): Promise<ToolHookResult>;
+    prepareSandbox(sandbox: SandboxInstance): Promise<void>;
+}
+/** Validate trusted plugin identity before it can affect process-wide hooks. */
+export declare function validateAgentPlugins(plugins: JuniorPlugin[]): void;
+/** Replace trusted agent plugins and return the previous list for rollback. */
+export declare function setAgentPlugins(plugins: JuniorPlugin[]): JuniorPlugin[];
+/** Return the current trusted agent plugins without exposing mutable state. */
+export declare function getAgentPlugins(): JuniorPlugin[];
+/** Collect turn-scoped tools exposed by trusted plugins. */
+export declare function getAgentPluginTools(context: ToolRuntimeContext): Record<string, ToolDefinition<any>>;
+/** Create one runner over trusted agent plugins registered by the app. */
+export declare function createAgentPluginHookRunner(input?: {
+    requester?: AgentPluginRequester;
+}): AgentPluginHookRunner;

package/dist/chat/plugins/logging.d.ts

@@ -0,0 +1,3 @@
+import type { AgentPluginLogger } from "@sentry/junior-plugin-api";
+/** Create the host logger exposed to trusted plugin hooks. */
+export declare function createAgentPluginLogger(plugin: string): AgentPluginLogger;

package/dist/chat/plugins/state.d.ts

@@ -0,0 +1,3 @@
+import type { AgentPluginState } from "@sentry/junior-plugin-api";
+/** Create a durable state namespace scoped to one trusted plugin. */
+export declare function createPluginState(plugin: string): AgentPluginState;

package/dist/chat/respond.d.ts

@@ -6,13 +6,20 @@ import type { PiMessage } from "@/chat/pi/messages";
 import { type SandboxAcquiredState } from "@/chat/sandbox/sandbox";
 import type { AssistantStatusSpec } from "@/chat/slack/assistant-thread/status";
 import { type AssistantReply, type AgentTurnDiagnostics } from "@/chat/services/turn-result";
+import { type AuthorizationFlowMode } from "@/chat/services/auth-pause";
 export type { AssistantReply, AgentTurnDiagnostics };
 export interface ReplyRequestContext {
     skillDirs?: string[];
+    credentialSubject?: {
+        type: "user";
+        userId: string;
+        allowedWhen: "private-direct-conversation";
+    };
     requester?: {
         userId?: string;
         userName?: string;
         fullName?: string;
+        email?: string;
     };
     correlation?: {
         conversationId?: string;
@@ -20,14 +27,18 @@ export interface ReplyRequestContext {
         turnId?: string;
         runId?: string;
         channelId?: string;
+        teamId?: string;
         messageTs?: string;
         threadTs?: string;
         requesterId?: string;
+        actorType?: string;
+        actorId?: string;
     };
     toolChannelId?: string;
     conversationContext?: string;
     artifactState?: ThreadArtifactsState;
     pendingAuth?: ConversationPendingAuthState;
+    authorizationFlowMode?: AuthorizationFlowMode;
     configuration?: Record<string, unknown>;
     /** Durable Pi transcript for this conversation, excluding ephemeral turn context. */
     piMessages?: PiMessage[];

package/dist/chat/runtime/thread-context.d.ts

@@ -20,3 +20,5 @@ export declare function getAssistantThreadContext(message: Message): {
     threadTs: string;
 } | undefined;
 export declare function getMessageTs(message: Message): string | undefined;
+/** Resolve the Slack workspace/team id from the raw inbound message payload. */
+export declare function getTeamId(message: Message): string | undefined;

package/dist/chat/sandbox/egress-proxy.d.ts

@@ -1,10 +1,17 @@
 import type { JWTPayload } from "jose";
+/** Intercepts a credential-injected sandbox HTTP request before live forwarding. */
+export type SandboxEgressHttpInterceptor = (input: {
+    provider: string;
+    request: Request;
+    upstreamUrl: URL;
+}) => Promise<Response | undefined>;
 interface ProxyDeps {
     fetch?: typeof fetch;
+    interceptHttp?: SandboxEgressHttpInterceptor;
     verifyOidc?: (token: string) => Promise<JWTPayload>;
 }
 /** Return whether a request appears to be from the Vercel Sandbox egress proxy. */
 export declare function isSandboxEgressForwardedRequest(request: Request): boolean;
-/** Proxy one Vercel Sandbox firewall egress request through lazy credential injection. */
+/** Proxy one Vercel Sandbox firewall egress request through lazy credential headers. */
 export declare function proxySandboxEgressRequest(request: Request, deps?: ProxyDeps): Promise<Response>;
 export {};

package/dist/chat/sandbox/sandbox.d.ts

@@ -1,4 +1,5 @@
 import { type LogContext } from "@/chat/logging";
+import type { AgentPluginHookRunner } from "@/chat/plugins/agent-hooks";
 import type { SandboxInstance } from "@/chat/sandbox/workspace";
 import type { SkillMetadata } from "@/chat/skills";
 interface SandboxExecutionInput {
@@ -43,6 +44,7 @@ export declare function createSandboxExecutor(options?: {
     credentialEgress?: {
         requesterId: string;
     };
+    agentHooks?: AgentPluginHookRunner;
     onSandboxAcquired?: (sandbox: SandboxAcquiredState) => void | Promise<void>;
     runBashCustomCommand?: (command: string) => Promise<{
         handled: boolean;

package/dist/chat/sandbox/session.d.ts

@@ -45,6 +45,7 @@ export declare function createSandboxSessionManager(options?: {
     traceContext?: LogContext;
     commandEnv?: () => Promise<Record<string, string>>;
     createNetworkPolicy?: (egressId: string) => NetworkPolicy | undefined;
+    onSandboxPrepare?: (sandbox: SandboxInstance) => void | Promise<void>;
     onSandboxAcquired?: (sandbox: {
         sandboxId: string;
         sandboxDependencyProfileHash?: string;

package/dist/chat/sandbox/skill-sync.d.ts

@@ -6,12 +6,11 @@ export declare function resolveHostSkillPath(availableSkills: SkillMetadata[], s
 export declare function resolveHostDataPath(referenceFiles: string[], sandboxPath: string): string | null;
 /** Detect missing host-backed skill files so reads can fall back to the sandbox copy. */
 export declare function isHostFileMissingError(error: unknown): boolean;
-/** Copy the current skill set and reference files into a sandbox and mark runtime shims executable. */
+/** Copy the current skill set and reference files into a sandbox. */
 export declare function syncSkillsToSandbox(params: {
     sandbox: SandboxInstance;
     skills: SkillMetadata[];
     referenceFiles?: string[];
     withSpan: <T>(name: string, op: string, attributes: Record<string, unknown>, callback: () => Promise<T>) => Promise<T>;
-    runtimeBinDir: string;
     workspaceRoot?: string;
 }): Promise<void>;

package/dist/chat/scheduler/cadence.d.ts

@@ -0,0 +1,24 @@
+import type { ScheduledCalendarFrequency, ScheduledTask, ScheduledTaskRecurrence } from "@/chat/scheduler/types";
+/** Parse an ISO timestamp into a finite Unix timestamp in milliseconds. */
+export declare function parseScheduleTimestamp(value: string): number | undefined;
+export interface ZonedDateTimeParts {
+    day: number;
+    hour: number;
+    minute: number;
+    month: number;
+    second: number;
+    weekday: number;
+    year: number;
+}
+/** Resolve a UTC timestamp into calendar parts for a named time zone. */
+export declare function getZonedDateTimeParts(timestampMs: number, timezone: string): ZonedDateTimeParts;
+/** Build a calendar recurrence anchored to an exact first run timestamp. */
+export declare function buildCalendarRecurrence(args: {
+    frequency: ScheduledCalendarFrequency;
+    interval?: number;
+    nextRunAtMs: number;
+    timezone: string;
+    weekdays?: number[];
+}): ScheduledTaskRecurrence;
+/** Return the next fire time after a completed run, when the task recurs. */
+export declare function getNextRunAtMs(task: ScheduledTask, scheduledForMs: number, afterMs?: number): number | undefined;

package/dist/chat/scheduler/plugin.d.ts

@@ -0,0 +1,2 @@
+/** Create Junior's built-in trusted scheduler plugin. */
+export declare function createSchedulerPlugin(): import("@sentry/junior-plugin-api").JuniorPlugin;

package/dist/chat/scheduler/prompt.d.ts

@@ -0,0 +1,7 @@
+import { type ScheduledRun, type ScheduledTask } from "@/chat/scheduler/types";
+/** Build the marker-delimited user prompt for one scheduled task execution. */
+export declare function buildScheduledTaskRunPrompt(args: {
+    nowMs: number;
+    run: ScheduledRun;
+    task: ScheduledTask;
+}): string;

package/dist/chat/scheduler/store.d.ts

@@ -0,0 +1,49 @@
+import type { StateAdapter } from "chat";
+import type { ScheduledRun, ScheduledTask } from "@/chat/scheduler/types";
+export interface SchedulerStore {
+    claimDueRun(args: {
+        nowMs: number;
+    }): Promise<ScheduledRun | undefined>;
+    getRun(runId: string): Promise<ScheduledRun | undefined>;
+    getTask(taskId: string): Promise<ScheduledTask | undefined>;
+    listIncompleteRuns(): Promise<ScheduledRun[]>;
+    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>;
+}
+/** Create the production scheduler store backed by Junior's state adapter. */
+export declare function createStateSchedulerStore(stateAdapter?: StateAdapter): SchedulerStore;

package/dist/chat/scheduler/types.d.ts

@@ -0,0 +1,86 @@
+export type ScheduledTaskStatus = "active" | "paused" | "blocked" | "deleted";
+export type ScheduledRunStatus = "pending" | "running" | "completed" | "failed" | "blocked" | "skipped";
+export interface ScheduledTaskPrincipal {
+    slackUserId: string;
+    fullName?: string;
+    userName?: string;
+}
+export interface ScheduledTaskExecutionActor {
+    type: "system";
+    id: string;
+}
+export declare const SCHEDULED_TASK_SYSTEM_ACTOR: Readonly<{
+    type: "system";
+    id: string;
+}>;
+export interface ScheduledTaskDestination {
+    platform: "slack";
+    teamId: string;
+    channelId: string;
+}
+export interface ScheduledTaskConversationAccess {
+    audience: "direct" | "group" | "channel";
+    visibility: "private" | "public" | "unknown";
+}
+export interface ScheduledTaskCredentialSubject {
+    type: "user";
+    userId: string;
+    allowedWhen: "private-direct-conversation";
+}
+export type ScheduledCalendarFrequency = "daily" | "weekly" | "monthly" | "yearly";
+export interface ScheduledLocalTime {
+    hour: number;
+    minute: number;
+}
+export interface ScheduledTaskRecurrence {
+    dayOfMonth?: number;
+    frequency: ScheduledCalendarFrequency;
+    interval: number;
+    month?: number;
+    startDate: string;
+    time: ScheduledLocalTime;
+    weekdays?: number[];
+}
+export interface ScheduledTaskSchedule {
+    description: string;
+    timezone: string;
+    kind: "one_off" | "recurring";
+    recurrence?: ScheduledTaskRecurrence;
+}
+export interface ScheduledTaskSpec {
+    text: string;
+}
+export interface ScheduledTask {
+    id: string;
+    createdAtMs: number;
+    createdBy: ScheduledTaskPrincipal;
+    conversationAccess?: ScheduledTaskConversationAccess;
+    credentialSubject?: ScheduledTaskCredentialSubject;
+    destination: ScheduledTaskDestination;
+    executionActor?: ScheduledTaskExecutionActor;
+    lastRunAtMs?: number;
+    nextRunAtMs?: number;
+    originalRequest?: string;
+    runNowAtMs?: number;
+    schedule: ScheduledTaskSchedule;
+    status: ScheduledTaskStatus;
+    statusReason?: string;
+    task: ScheduledTaskSpec;
+    updatedAtMs: number;
+    version: number;
+}
+export interface ScheduledRun {
+    id: string;
+    attempt: number;
+    claimedAtMs: number;
+    completedAtMs?: number;
+    dispatchId?: string;
+    errorMessage?: string;
+    idempotencyKey: string;
+    resultMessageTs?: string;
+    scheduledForMs: number;
+    startedAtMs?: number;
+    status: ScheduledRunStatus;
+    taskId: string;
+    taskVersion: number;
+}

package/dist/chat/services/auth-pause.d.ts

@@ -1,5 +1,6 @@
 export type AuthorizationPauseKind = "mcp" | "plugin";
 export type AuthorizationPauseDisposition = "link_already_sent" | "link_sent";
+export type AuthorizationFlowMode = "interactive" | "disabled";
 /**
  * Runtime-owned signal that the current turn must park until the user
  * completes an external authorization step.
@@ -10,3 +11,9 @@ export declare class AuthorizationPauseError extends Error {
     readonly provider: string;
     constructor(kind: AuthorizationPauseKind, provider: string, disposition: AuthorizationPauseDisposition);
 }
+/** Error indicating this turn cannot start an external authorization flow. */
+export declare class AuthorizationFlowDisabledError extends Error {
+    readonly kind: AuthorizationPauseKind;
+    readonly provider: string;
+    constructor(kind: AuthorizationPauseKind, provider: string);
+}

package/dist/chat/services/mcp-auth-orchestration.d.ts

@@ -1,5 +1,5 @@
 import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
-import { AuthorizationPauseError } from "@/chat/services/auth-pause";
+import { AuthorizationPauseError, type AuthorizationFlowMode } from "@/chat/services/auth-pause";
 import type { ThreadArtifactsState } from "@/chat/state/artifacts";
 import type { ConversationPendingAuthState } from "@/chat/state/conversation";
 import type { PluginDefinition } from "@/chat/plugins/types";
@@ -19,6 +19,7 @@ export interface McpAuthOrchestrationDeps {
     getArtifactState: () => ThreadArtifactsState | undefined;
     getMergedArtifactState: () => ThreadArtifactsState;
     onPendingAuth?: (pendingAuth: ConversationPendingAuthState) => void | Promise<void>;
+    authorizationFlowMode?: AuthorizationFlowMode;
 }
 export interface McpAuthOrchestration {
     authProviderFactory: (plugin: PluginDefinition) => Promise<OAuthClientProvider | undefined>;

package/dist/chat/services/plugin-auth-orchestration.d.ts

@@ -1,6 +1,6 @@
 import type { ChannelConfigurationService } from "@/chat/configuration/types";
 import type { UserTokenStore } from "@/chat/credentials/user-token-store";
-import { AuthorizationPauseError } from "@/chat/services/auth-pause";
+import { AuthorizationPauseError, type AuthorizationFlowMode } from "@/chat/services/auth-pause";
 import type { ConversationPendingAuthState } from "@/chat/state/conversation";
 import type { Skill } from "@/chat/skills";
 export declare class PluginAuthorizationPauseError extends AuthorizationPauseError {
@@ -20,6 +20,7 @@ export interface PluginAuthOrchestrationDeps {
     channelConfiguration?: ChannelConfigurationService;
     currentPendingAuth?: ConversationPendingAuthState;
     onPendingAuth?: (pendingAuth: ConversationPendingAuthState) => void | Promise<void>;
+    authorizationFlowMode?: AuthorizationFlowMode;
     userTokenStore?: UserTokenStore;
 }
 export interface PluginAuthOrchestration {

package/dist/chat/slack/ids.d.ts

@@ -0,0 +1,4 @@
+/** Return true when a value is a Slack workspace/team id. */
+export declare function isSlackTeamId(value: string): boolean;
+/** Return true when a value is a Slack conversation id. */
+export declare function isSlackConversationId(value: string): boolean;

package/dist/chat/slack/reply.d.ts

@@ -28,6 +28,6 @@ export declare function postSlackApiReplyPosts(args: {
         messageTs?: string;
         stage: PlannedSlackReplyStage;
     }) => Promise<void> | void;
-    threadTs: string;
+    threadTs?: string;
     posts: PlannedSlackReplyPost[];
 }): Promise<string | undefined>;

package/dist/chat/slack/user.d.ts

@@ -1,6 +1,7 @@
 interface SlackUserLookupResult {
     userName?: string;
     fullName?: string;
+    email?: string;
 }
 /** Fetch Slack user profile info with in-memory TTL cache to avoid repeated API calls. */
 export declare function lookupSlackUser(userId?: string): Promise<SlackUserLookupResult | null>;

package/dist/chat/slack/workspace-context.d.ts

@@ -0,0 +1,4 @@
+/** Run a callback with the Slack workspace team ID for the inbound webhook. */
+export declare function runWithWorkspaceTeamId<T>(teamId: string | undefined, fn: () => T): T;
+/** Return the Slack workspace team ID for the current inbound webhook. */
+export declare function getWorkspaceTeamId(): string | undefined;

package/dist/chat/tools/agent-tools.d.ts

@@ -5,5 +5,6 @@ import type { AssistantStatusSpec } from "@/chat/slack/assistant-thread/status";
 import type { SandboxExecutor } from "@/chat/sandbox/sandbox";
 import type { SkillSandbox } from "@/chat/sandbox/skill-sandbox";
 import type { ToolDefinition } from "@/chat/tools/definition";
+import type { AgentPluginHookRunner } from "@/chat/plugins/agent-hooks";
 /** Wrap tool definitions into Pi Agent tool objects with logging, validation, and sandbox execution. */
-export declare function createAgentTools(tools: Record<string, ToolDefinition<any>>, sandbox: SkillSandbox, spanContext: LogContext, onStatus?: (status: AssistantStatusSpec) => void | Promise<void>, sandboxExecutor?: SandboxExecutor, pluginAuthOrchestration?: PluginAuthOrchestration, onToolCall?: (toolName: string, params: Record<string, unknown>) => void): AgentTool[];
+export declare function createAgentTools(tools: Record<string, ToolDefinition<any>>, sandbox: SkillSandbox, spanContext: LogContext, onStatus?: (status: AssistantStatusSpec) => void | Promise<void>, sandboxExecutor?: SandboxExecutor, pluginAuthOrchestration?: PluginAuthOrchestration, onToolCall?: (toolName: string, params: Record<string, unknown>) => void, agentHooks?: AgentPluginHookRunner): AgentTool[];

package/dist/chat/tools/slack/schedule-tools.d.ts

@@ -0,0 +1,29 @@
+import type { ToolRuntimeContext } from "@/chat/tools/types";
+/** Create a tool that stores a scheduled task for the active Slack context. */
+export declare function createSlackScheduleCreateTaskTool(context: ToolRuntimeContext): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+    task: import("@sinclair/typebox").TString;
+    schedule: import("@sinclair/typebox").TString;
+    timezone: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    next_run_at: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    recurrence: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"daily">, import("@sinclair/typebox").TLiteral<"weekly">, import("@sinclair/typebox").TLiteral<"monthly">, import("@sinclair/typebox").TLiteral<"yearly">]>>;
+}>>;
+/** Create a tool that lists scheduled tasks for the active Slack destination. */
+export declare function createSlackScheduleListTasksTool(context: ToolRuntimeContext): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{}>>;
+/** Create a tool that edits a scheduled task in the active Slack destination. */
+export declare function createSlackScheduleUpdateTaskTool(context: ToolRuntimeContext): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+    task_id: import("@sinclair/typebox").TString;
+    task: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    schedule: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    timezone: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    next_run_at: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    recurrence: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"daily">, import("@sinclair/typebox").TLiteral<"weekly">, import("@sinclair/typebox").TLiteral<"monthly">, import("@sinclair/typebox").TLiteral<"yearly">]>, import("@sinclair/typebox").TNull]>>;
+    status: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"active">, import("@sinclair/typebox").TLiteral<"paused">, import("@sinclair/typebox").TLiteral<"blocked">]>>;
+}>>;
+/** Create a tool that removes a scheduled task from the active Slack destination. */
+export declare function createSlackScheduleDeleteTaskTool(context: ToolRuntimeContext): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+    task_id: import("@sinclair/typebox").TString;
+}>>;
+/** Create a tool that marks an existing scheduled task due immediately. */
+export declare function createSlackScheduleRunTaskNowTool(context: ToolRuntimeContext): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+    task_id: import("@sinclair/typebox").TString;
+}>>;

package/dist/chat/tools/types.d.ts

@@ -37,6 +37,12 @@ export interface ToolRuntimeContext {
     advisor?: AdvisorToolRuntimeContext;
     channelId?: string;
     channelCapabilities: ChannelCapabilities;
+    requester?: {
+        userId?: string;
+        userName?: string;
+        fullName?: string;
+    };
+    teamId?: string;
     messageTs?: string;
     threadTs?: string;
     userText?: string;

package/dist/{chunk-QCHPJ4FD.js → chunk-D3G3YOU4.js}

@@ -2,7 +2,7 @@ import {
   getPluginForSkillPath,
   getPluginSkillRoots,
   logWarn
-} from "./chunk-YITDDLS3.js";
+} from "./chunk-TTUY467K.js";
 import {
   skillRoots
 } from "./chunk-5LUISFEY.js";