@sentry/junior 0.88.0 → 0.90.0

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

@@ -1,6 +1,6 @@
 import type { PluginConversations, PluginRoute, PluginOperationalReport, PluginRouteApp, SlackConversationLink, PluginRegistration } from "@sentry/junior-plugin-api";
 import type { PluginPromptContributionContext } from "@/chat/plugins/prompt";
-import type { ToolDefinition } from "@/chat/tools/definition";
+import type { AnyToolDefinition } from "@/chat/tools/definition";
 import type { ToolRuntimeContext } from "@/chat/tools/types";
 import type { SandboxInstance } from "@/chat/sandbox/workspace";
 import type { Requester } from "@/chat/requester";
@@ -40,7 +40,7 @@ export declare function getPluginUserPromptContributions(args: {
     context: Pick<ToolRuntimeContext, "conversationId" | "destination" | "requester" | "source" | "userText">;
 }): Promise<PluginPromptContributionContext[]>;
 /** Collect turn-scoped tools exposed by plugins. */
-export declare function getPluginTools(context: ToolRuntimeContext): Record<string, ToolDefinition<any>>;
+export declare function getPluginTools(context: ToolRuntimeContext): Record<string, AnyToolDefinition>;
 /** Collect route handlers exposed by plugins for app-level mounting. */
 export declare function getPluginRoutes(): PluginRouteRegistration[];
 /** Collect authenticated product API route apps exposed by plugins. */

package/dist/chat/prompt.d.ts

@@ -1,7 +1,7 @@
 import type { SlackConversationContext } from "@/chat/slack/conversation-context";
 import type { ThreadArtifactsState } from "@/chat/state/artifacts";
 import type { SkillMetadata, SkillInvocation } from "@/chat/skills";
-import type { ActiveMcpCatalogSummary } from "@/chat/tools/skill/mcp-tool-summary";
+import type { ActiveMcpCatalogSummary } from "@/chat/tool-support/skill/mcp-tool-summary";
 import type { PluginPromptContributionContext } from "@/chat/plugins/prompt";
 import type { Destination, Source } from "@sentry/junior-plugin-api";
 export declare const JUNIOR_PERSONALITY: string;

package/dist/chat/runtime/agent-continue-runner.d.ts

@@ -1,9 +1,9 @@
 import { resumeSlackTurn } from "@/chat/runtime/slack-resume";
 import { type AgentContinueRequest } from "@/chat/services/agent-continue";
-import type { generateAssistantReply } from "@/chat/respond";
+import type { AgentRunner } from "@/chat/runtime/agent-runner";
 /** Runtime ports for agent continuation scheduling. */
 export interface AgentContinueRunnerOptions {
-    generateReply?: typeof generateAssistantReply;
+    agentRunner: AgentRunner;
     resumeTurn?: typeof resumeSlackTurn;
     scheduleAgentContinue?: (request: AgentContinueRequest) => Promise<void>;
     scheduleSessionCompletedPluginTasks?: (params: {
@@ -16,9 +16,9 @@ export interface AgentContinueRunnerOptions {
  *
  * Returns false when the session became stale before generation began.
  */
-export declare function continueSlackAgentRun(payload: AgentContinueRequest, options?: AgentContinueRunnerOptions): Promise<boolean>;
+export declare function continueSlackAgentRun(payload: AgentContinueRequest, options: AgentContinueRunnerOptions): Promise<boolean>;
 /** Resume the first valid paused Slack session for an idle conversation. */
-export declare function resumeAwaitingSlackContinuation(conversationId: string, options?: AgentContinueRunnerOptions): Promise<boolean>;
+export declare function resumeAwaitingSlackContinuation(conversationId: string, options: AgentContinueRunnerOptions): Promise<boolean>;
 /**
  * Retry agent continuation when the normal Slack thread lock is briefly busy.
  *
@@ -26,4 +26,4 @@ export declare function resumeAwaitingSlackContinuation(conversationId: string,
  * lock that is rescheduled still returns true because runnable work remains
  * durable.
  */
-export declare function continueSlackAgentRunWithLockRetry(payload: AgentContinueRequest, options?: AgentContinueRunnerOptions): Promise<boolean>;
+export declare function continueSlackAgentRunWithLockRetry(payload: AgentContinueRequest, options: AgentContinueRunnerOptions): Promise<boolean>;

package/dist/chat/runtime/agent-run-outcome.d.ts

@@ -0,0 +1,21 @@
+import type { AgentRunResult } from "@/chat/services/turn-result";
+/**
+ * How an agent run ended. `completed` carries the terminal result (success or
+ * failure — `result.diagnostics` distinguishes them). `suspended` means the run
+ * persisted an awaiting_resume session record and stopped at a safe boundary;
+ * the caller resumes it by scheduling a continuation against `resumeVersion`,
+ * the session record's optimistic-concurrency version. `awaiting_auth` means
+ * the run parked for user authorization.
+ */
+export type AgentRunOutcome = {
+    status: "completed";
+    result: AgentRunResult;
+} | {
+    status: "suspended";
+    resumeVersion: number;
+} | {
+    status: "awaiting_auth";
+    providerDisplayName: string;
+};
+/** Wrap a terminal result (successful or failed per its diagnostics) as an outcome. */
+export declare function completedAgentRun(result: AgentRunResult): AgentRunOutcome;

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

@@ -0,0 +1,11 @@
+import type { AgentRunRequest } from "@/chat/agent/request";
+import type { AgentRunOutcome } from "@/chat/runtime/agent-run-outcome";
+import type { SandboxEgressTracePropagationConfig } from "@/chat/sandbox/egress/tracing";
+/** Run one agent-run slice behind runtime-owned orchestration boundaries. */
+export interface AgentRunner {
+    run(request: AgentRunRequest): Promise<AgentRunOutcome>;
+}
+/** Adapt the Pi-facing agent-run executor behind the runtime-owned runner seam. */
+export declare function createAgentRunner(run: AgentRunner["run"], options?: {
+    tracePropagation?: SandboxEgressTracePropagationConfig;
+}): AgentRunner;

package/dist/chat/runtime/delivered-turn-state.d.ts

@@ -1,4 +1,4 @@
-import type { AssistantReply } from "@/chat/respond";
+import type { AgentRunResult } from "@/chat/services/turn-result";
 import type { ThreadConversationState } from "@/chat/state/conversation";
 import type { ThreadArtifactsState } from "@/chat/state/artifacts";
 import { type ThreadStatePatch } from "@/chat/runtime/thread-state";
@@ -7,7 +7,7 @@ export declare function buildDeliveredTurnStatePatch(args: {
     artifactStatePatch?: Partial<ThreadArtifactsState>;
     artifacts: ThreadArtifactsState;
     conversation: ThreadConversationState;
-    reply: AssistantReply;
+    reply: AgentRunResult;
     sessionId: string;
     userMessageId?: string;
 }): ThreadStatePatch & {

package/dist/chat/runtime/generated-artifacts.d.ts

@@ -0,0 +1,16 @@
+import type { FileUpload } from "chat";
+import type { GeneratedArtifactFileRef } from "@/chat/tools/types";
+import type { SandboxCommandResult } from "@/chat/sandbox/workspace";
+/** Sandbox operations needed to make generated artifacts visible to later tools. */
+export interface GeneratedArtifactSandbox {
+    runCommand(input: {
+        args?: string[];
+        cmd: string;
+    }): Promise<SandboxCommandResult>;
+    writeFiles(files: Array<{
+        content: string | Uint8Array;
+        path: string;
+    }>): Promise<void>;
+}
+/** Persist generated artifacts into the sandbox before returning model-visible handles. */
+export declare function writeSandboxGeneratedArtifacts(sandbox: GeneratedArtifactSandbox, files: FileUpload[]): Promise<GeneratedArtifactFileRef[]>;

package/dist/chat/runtime/reply-executor.d.ts

@@ -1,7 +1,7 @@
 import type { Message, Thread } from "chat";
 import type { SlackAdapter } from "@chat-adapter/slack";
 import { type Destination } from "@sentry/junior-plugin-api";
-import { generateAssistantReply as generateAssistantReplyImpl } from "@/chat/respond";
+import type { AgentRunner } from "@/chat/runtime/agent-runner";
 import type { PreparedTurnState } from "@/chat/runtime/turn-preparation";
 import { type PrepareTurnStateInput, type QueuedTurnMessage, type TurnToolInvocation } from "@/chat/runtime/turn-input";
 import { type ConversationMemoryService } from "@/chat/services/conversation-memory";
@@ -9,8 +9,8 @@ import type { ContextCompactor } from "@/chat/services/context-compaction";
 import { lookupSlackUser } from "@/chat/slack/user";
 import type { AgentContinueRequest } from "@/chat/services/agent-continue";
 export interface ReplyExecutorServices {
+    agentRunner: AgentRunner;
     contextCompactor: ContextCompactor;
-    generateAssistantReply: typeof generateAssistantReplyImpl;
     generateThreadTitle: ConversationMemoryService["generateThreadTitle"];
     getAwaitingAgentContinueRequest: (args: {
         conversationId: string;

package/dist/chat/runtime/slack-resume.d.ts

@@ -1,5 +1,6 @@
-import { generateAssistantReply, type AssistantReply, type AssistantReplyRequestContext } from "@/chat/respond";
-import type { Source } from "@sentry/junior-plugin-api";
+import type { AgentRunRequest } from "@/chat/agent/request";
+import type { AgentRunResult } from "@/chat/services/turn-result";
+import type { AgentRunner } from "@/chat/runtime/agent-runner";
 import type { SlackMessageTs } from "@/chat/slack/timestamp";
 /** Error raised when another worker already owns the resume lock. */
 export declare class ResumeTurnBusyError extends Error {
@@ -13,21 +14,25 @@ interface ResumeSlackTurnArgs {
     replyContext?: ResumeReplyContext;
     lockKey?: string;
     initialText?: string;
-    generateReply?: typeof generateAssistantReply;
+    agentRunner: AgentRunner;
     scheduleSessionCompletedPluginTasks?: (params: {
         conversationId: string;
         sessionId: string;
     }) => Promise<void>;
-    onSuccess?: (reply: AssistantReply) => Promise<void>;
+    onSuccess?: (reply: AgentRunResult) => Promise<void>;
     onFailure?: (error: unknown) => Promise<void>;
-    onAuthPause?: (error: unknown) => Promise<void>;
-    onTimeoutPause?: (error: unknown) => Promise<void>;
+    onAuthPause?: (pause: {
+        providerDisplayName: string;
+    }) => Promise<void>;
+    onTimeoutPause?: (resume: {
+        resumeVersion: number;
+    }) => Promise<void>;
     onPostDeliveryCommitFailure?: (error: unknown) => Promise<void>;
     beforeStart?: () => Promise<Partial<ResumeSlackTurnArgs> | false | void>;
     replyTimeoutMs?: number;
 }
-type ResumeReplyContext = AssistantReplyRequestContext & {
-    source: Source;
+type ResumeReplyContext = Omit<AgentRunRequest, "input"> & {
+    input?: Omit<AgentRunRequest["input"], "messageText">;
 };
 /**
  * Resume a paused Slack turn under the normal thread lock.
@@ -46,11 +51,15 @@ export declare function resumeAuthorizedRequest(args: {
     connectedText: string;
     replyContext?: ResumeReplyContext;
     lockKey?: string;
-    generateReply?: typeof generateAssistantReply;
-    onSuccess?: (reply: AssistantReply) => Promise<void>;
+    agentRunner: AgentRunner;
+    onSuccess?: (reply: AgentRunResult) => Promise<void>;
     onFailure?: (error: unknown) => Promise<void>;
-    onAuthPause?: (error: unknown) => Promise<void>;
-    onTimeoutPause?: (error: unknown) => Promise<void>;
+    onAuthPause?: (pause: {
+        providerDisplayName: string;
+    }) => Promise<void>;
+    onTimeoutPause?: (resume: {
+        resumeVersion: number;
+    }) => Promise<void>;
     onPostDeliveryCommitFailure?: (error: unknown) => Promise<void>;
     beforeStart?: () => Promise<Partial<ResumeSlackTurnArgs> | false | void>;
     replyTimeoutMs?: number;

package/dist/chat/runtime/turn.d.ts

@@ -1,44 +1,10 @@
 import type { ThreadConversationState } from "@/chat/state/conversation";
-import type { AuthorizationPauseDisposition, AuthorizationPauseKind } from "@/chat/services/auth-pause";
-import type { TurnThinkingSelection } from "@/chat/services/turn-thinking-level";
-import type { AgentTurnUsage } from "@/chat/usage";
 export { buildDeterministicTurnId } from "@/chat/state/turn-id";
-export type RetryableTurnReason = "mcp_auth_resume" | "plugin_auth_resume" | "agent_continue";
-/** Auth-pause reasons require a known provider before a resume can be parked. */
-export type AuthResumeRetryableTurnReason = Extract<RetryableTurnReason, "mcp_auth_resume" | "plugin_auth_resume">;
-export interface RetryableTurnMetadata {
-    authDisposition?: AuthorizationPauseDisposition;
-    authDurationMs?: number;
-    authKind?: AuthorizationPauseKind;
-    authProvider?: string;
-    authProviderDisplayName?: string;
-    authThinkingLevel?: TurnThinkingSelection["thinkingLevel"];
-    authUsage?: AgentTurnUsage;
-    version?: number;
-    conversationId?: string;
-    sessionId?: string;
-    sliceId?: number;
-}
-export interface AuthResumeRetryableTurnMetadata extends RetryableTurnMetadata {
-    authProvider: string;
-    authProviderDisplayName: string;
-}
-export type AuthResumeRetryableTurnError = RetryableTurnError & {
-    readonly reason: AuthResumeRetryableTurnReason;
-    readonly metadata: AuthResumeRetryableTurnMetadata;
-};
-/** Error indicating an agent run can continue later after timeout or auth pause. */
-export declare class RetryableTurnError extends Error {
-    readonly code = "retryable_turn";
-    readonly metadata?: RetryableTurnMetadata;
-    readonly reason: RetryableTurnReason;
-    constructor(reason: AuthResumeRetryableTurnReason, message: string, metadata: AuthResumeRetryableTurnMetadata);
-    constructor(reason: "agent_continue", message: string, metadata?: RetryableTurnMetadata);
-}
-export declare function isRetryableTurnError(error: unknown, reason?: RetryableTurnReason): error is RetryableTurnError;
-/** Return whether a retryable turn is waiting for provider authorization. */
-export declare function isAuthResumeRetryableTurnError(error: unknown): error is AuthResumeRetryableTurnError;
-/** Error indicating the turn paused voluntarily at a safe continuation boundary. */
+/**
+ * Queue-worker yield routing: respond.ts returns a suspended AgentRunOutcome
+ * and the Slack executor raises this at the worker boundary so the lease owner
+ * requeues the conversation.
+ */
 export declare class CooperativeTurnYieldError extends Error {
     readonly code = "cooperative_turn_yield";
     constructor(message?: string);

package/dist/chat/services/reply-delivery-plan.d.ts

@@ -1,13 +1,5 @@
 export type ReplyDeliveryMode = "thread" | "channel_only";
-export type ReplyFileDelivery = "none" | "inline" | "followup";
 export interface ReplyDeliveryPlan {
     mode: ReplyDeliveryMode;
     postThreadText: boolean;
-    attachFiles: ReplyFileDelivery;
 }
-/** Determine how a reply should be delivered (thread vs channel, file handling). */
-export declare function buildReplyDeliveryPlan(args: {
-    explicitChannelPostIntent: boolean;
-    channelPostPerformed: boolean;
-    hasFiles: boolean;
-}): ReplyDeliveryPlan;

package/dist/chat/services/turn-failure-response.d.ts

@@ -1,15 +1,15 @@
 import type { LogContext } from "@/chat/logging";
-import type { AssistantReply } from "@/chat/services/turn-result";
+import type { AgentRunResult } from "@/chat/services/turn-result";
 type LogException = (error: unknown, eventName: string, context?: LogContext, attributes?: Record<string, unknown>, body?: string) => string | undefined;
 /** Require captured turn failures to carry a real Sentry event reference. */
 export declare function requireTurnFailureEventId(eventId: string | undefined, eventName: string): string;
 /** Keep failed-turn Sentry captures and completion spans on the same keys. */
-export declare function getAgentTurnDiagnosticsAttributes(reply: AssistantReply): Record<string, unknown>;
+export declare function getAgentTurnDiagnosticsAttributes(reply: AgentRunResult): Record<string, unknown>;
 /** Enforce one captured, event-ID-bearing failure response before delivery. */
 export declare function finalizeFailedTurnReply(args: {
-    reply: AssistantReply;
+    reply: AgentRunResult;
     logException: LogException;
     context: LogContext;
     attributes?: Record<string, unknown>;
-}): AssistantReply;
+}): AgentRunResult;
 export {};

package/dist/chat/services/turn-result.d.ts

@@ -1,9 +1,8 @@
-import type { FileUpload } from "chat";
 import type { LogContext } from "@/chat/logging";
 import type { PiMessage } from "@/chat/pi/messages";
 import type { TurnThinkingSelection } from "@/chat/services/turn-thinking-level";
 import type { AgentTurnUsage } from "@/chat/usage";
-import { type ReplyDeliveryPlan } from "@/chat/services/reply-delivery-plan";
+import type { ReplyDeliveryPlan } from "@/chat/services/reply-delivery-plan";
 import type { ThreadArtifactsState } from "@/chat/state/artifacts";
 export interface AgentTurnDiagnostics {
     assistantMessageCount: number;
@@ -20,9 +19,8 @@ export interface AgentTurnDiagnostics {
     usage?: AgentTurnUsage;
     usedPrimaryText: boolean;
 }
-export interface AssistantReply {
+export interface AgentRunResult {
     text: string;
-    files?: FileUpload[];
     artifactStatePatch?: Partial<ThreadArtifactsState>;
     deliveryPlan?: ReplyDeliveryPlan;
     deliveryMode?: "thread" | "channel_only";
@@ -34,7 +32,6 @@ export interface AssistantReply {
 export interface TurnResultInput {
     newMessages: unknown[];
     userInput: string;
-    replyFiles: FileUpload[];
     artifactStatePatch: Partial<ThreadArtifactsState>;
     toolCalls: string[];
     sandboxId?: string;
@@ -54,5 +51,5 @@ export interface TurnResultInput {
     };
     assistantUserName?: string;
 }
-/** Process raw agent messages into a structured AssistantReply. */
-export declare function buildTurnResult(input: TurnResultInput): AssistantReply;
+/** Process raw agent messages into a structured AgentRunResult. */
+export declare function buildTurnResult(input: TurnResultInput): AgentRunResult;

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

@@ -1,3 +1,5 @@
+import type { SlackChannelId } from "@/chat/slack/ids";
+import type { SlackMessageTs } from "@/chat/slack/timestamp";
 export interface SlackChannelMessage {
     ts?: string;
     user?: string;
@@ -27,21 +29,23 @@ export interface SlackThreadReply {
     files?: SlackFileRef[];
     attachments?: unknown[];
 }
+/** List channel history using Slack-native, pre-validated timestamp bounds. */
 export declare function listChannelMessages(input: {
-    channelId: string;
+    channelId: SlackChannelId;
     limit: number;
     cursor?: string;
-    oldest?: string;
-    latest?: string;
+    oldest?: SlackMessageTs;
+    latest?: SlackMessageTs;
     inclusive?: boolean;
     maxPages?: number;
 }): Promise<{
     messages: SlackChannelMessage[];
     nextCursor?: string;
 }>;
+/** Read replies from a Slack thread identified by a validated native thread timestamp. */
 export declare function listThreadReplies(input: {
-    channelId: string;
-    threadTs: string;
+    channelId: SlackChannelId;
+    threadTs: SlackMessageTs;
     limit?: number;
     maxPages?: number;
     targetMessageTs?: string[];

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

@@ -1,4 +1,5 @@
 import { WebClient } from "@slack/web-api";
+import { type SlackChannelId } from "@/chat/slack/ids";
 export type SlackActionErrorCode = "missing_token" | "missing_scope" | "rate_limited" | "feature_unavailable" | "canvas_creation_failed" | "canvas_editing_failed" | "invalid_arguments" | "not_found" | "not_in_channel" | "already_reacted" | "no_reaction" | "read_only_channel" | "internal_error";
 export declare class SlackActionError extends Error {
     code: SlackActionErrorCode;
@@ -47,7 +48,8 @@ export declare function getHeaderString(headers: unknown, name: string): string
  * credentials rather than the env fallback token.
  */
 export declare function runWithSlackInstallationToken<T>(token: string, fn: () => T): T;
-export declare function normalizeSlackConversationId(channelId: string | undefined): string | undefined;
+/** Normalize Junior Slack references to native Slack conversation IDs. */
+export declare function normalizeSlackConversationId(channelId: string | undefined): SlackChannelId | undefined;
 /**
  * Run a Slack Web API call with bounded retries so transient platform
  * failures do not surface as turn failures, while non-idempotent posts are

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

@@ -1,9 +1,21 @@
-/** Extract channelId and threadTs from a `slack:<channel>:<ts>` thread identifier. */
+import { type SlackChannelId, type SlackTeamId } from "@/chat/slack/ids";
+import { type SlackMessageTs } from "@/chat/slack/timestamp";
+export interface SlackRawMessageContext {
+    authorTeamId?: SlackTeamId;
+    channelId?: SlackChannelId;
+    messageTs?: SlackMessageTs;
+    nestedMessageTs?: SlackMessageTs;
+    teamId?: SlackTeamId;
+    threadTs?: SlackMessageTs;
+}
+/** Project only the Slack raw fields consumed by runtime thread context. */
+export declare function readSlackRawMessageContext(message: unknown): SlackRawMessageContext | undefined;
+/** Extract a channel ID and validated Slack timestamp from `slack:<channel>:<ts>`. */
 export declare function parseSlackThreadId(threadId: string | undefined): {
-    channelId: string;
-    threadTs: string;
+    channelId: SlackChannelId;
+    threadTs: SlackMessageTs;
 } | undefined;
 /** Resolve the Slack channel ID from a `slack:<channel>:<ts>` thread identifier. */
-export declare function resolveSlackChannelIdFromThreadId(threadId: string | undefined): string | undefined;
+export declare function resolveSlackChannelIdFromThreadId(threadId: string | undefined): SlackChannelId | undefined;
 /** Best-effort channel ID extraction from a raw Slack message payload. */
-export declare function resolveSlackChannelIdFromMessage(message: unknown): string | undefined;
+export declare function resolveSlackChannelIdFromMessage(message: unknown): SlackChannelId | undefined;

package/dist/chat/slack/id-param.d.ts

@@ -0,0 +1,25 @@
+import { type SlackChannelId, type SlackUserId } from "@/chat/slack/ids";
+import { z } from "zod";
+type RequiredSlackChannelIdParamResult = {
+    ok: true;
+    value: SlackChannelId;
+} | {
+    ok: false;
+    error: string;
+};
+type RequiredSlackUserIdParamResult = {
+    ok: true;
+    value: SlackUserId;
+} | {
+    ok: false;
+    error: string;
+};
+/** Define a model-facing Slack channel ID parameter. */
+export declare function slackChannelIdParam(description: string): z.ZodString;
+/** Define a model-facing Slack user ID parameter. */
+export declare function slackUserIdParam(description: string): z.ZodString;
+/** Parse a required tool input channel ID into a branded Slack channel ID. */
+export declare function parseRequiredSlackChannelIdParam(field: string, value: unknown): RequiredSlackChannelIdParamResult;
+/** Parse a required tool input user ID into a branded Slack user ID. */
+export declare function parseRequiredSlackUserIdParam(field: string, value: unknown): RequiredSlackUserIdParamResult;
+export {};

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

@@ -1,4 +1,18 @@
-/** 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;
+import { z } from "zod";
+declare const slackChannelIdSchema: z.core.$ZodBranded<z.ZodString, "SlackChannelId", "out">;
+declare const slackTeamIdSchema: z.core.$ZodBranded<z.ZodString, "SlackTeamId", "out">;
+declare const slackUserIdSchema: z.core.$ZodBranded<z.ZodString, "SlackUserId", "out">;
+export type SlackChannelId = z.output<typeof slackChannelIdSchema>;
+export type SlackTeamId = z.output<typeof slackTeamIdSchema>;
+export type SlackUserId = z.output<typeof slackUserIdSchema>;
+/** Parse an exact Slack channel/conversation ID from untrusted input. */
+export declare function parseSlackChannelId(value: unknown): SlackChannelId | undefined;
+/** Parse a Slack channel ID from native IDs or Junior Slack reference strings. */
+export declare function parseSlackChannelReferenceId(value: unknown): SlackChannelId | undefined;
+/** Parse a Slack workspace/team ID from untrusted metadata. */
+export declare function parseSlackTeamId(value: unknown): SlackTeamId | undefined;
+/** Parse a Slack user ID from untrusted metadata. */
+export declare function parseSlackUserId(value: unknown): SlackUserId | undefined;
+/** Return true when a value is exactly a Slack workspace/team id. */
+export declare function isSlackTeamId(value: string): value is SlackTeamId;
+export {};

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

@@ -28,6 +28,22 @@ export declare function postSlackEphemeralMessage(input: {
 }): Promise<{
     messageTs?: string;
 }>;
+/** Minimal Slack file metadata exposed outside the Slack client boundary. */
+export interface SlackUploadedFile {
+    id?: string;
+}
+/** Upload files into a Slack conversation or thread via the shared outbound file boundary. */
+export declare function uploadFilesToConversation(input: {
+    channelId: string;
+    initialComment?: string;
+    threadTs?: string;
+    files: Array<{
+        data: Buffer;
+        filename: string;
+    }>;
+}): Promise<{
+    files?: SlackUploadedFile[];
+}>;
 /** Upload files into a Slack thread via the shared outbound file boundary. */
 export declare function uploadFilesToThread(input: {
     channelId: string;

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

@@ -1,4 +1,4 @@
-import type { FileUpload, PostableMessage } from "chat";
+import type { PostableMessage } from "chat";
 /** Return the first continuation-safe chunk plus any remaining text. */
 export declare function takeSlackContinuationPrefix(text: string, options?: {
     forceSplit?: boolean;
@@ -46,8 +46,8 @@ export declare function getSlackContinuationBudget(): {
     maxChars: number;
     maxLines: number;
 };
-/** Normalize text for Slack and wrap it as a PostableMessage with optional file attachments. */
-export declare function buildSlackOutputMessage(text: string, files?: FileUpload[]): PostableMessage;
+/** Normalize text for Slack and wrap it as a PostableMessage. */
+export declare function buildSlackOutputMessage(text: string): PostableMessage;
 export declare const slackOutputPolicy: {
     maxInlineChars: number;
     maxInlineLines: number;

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

@@ -1,18 +1,16 @@
-import type { FileUpload } from "chat";
-import type { AssistantReply } from "@/chat/respond";
+import type { AgentRunResult } from "@/chat/services/turn-result";
 import { type SlackReplyFooter } from "@/chat/slack/footer";
-export type PlannedSlackReplyStage = "thread_reply" | "thread_reply_continuation" | "thread_reply_files_followup";
+export type PlannedSlackReplyStage = "thread_reply" | "thread_reply_continuation";
 export interface PlannedSlackReplyPost {
-    files?: FileUpload[];
     stage: PlannedSlackReplyStage;
     text: string;
 }
 /**
  * Plan the Slack thread posts needed to realize a completed assistant reply,
- * including chunking, interruption markers, and file delivery.
+ * including chunking and interruption markers.
  */
 export declare function planSlackReplyPosts(args: {
-    reply: AssistantReply;
+    reply: AgentRunResult;
 }): PlannedSlackReplyPost[];
 /**
  * Deliver planned Slack reply posts over raw Slack Web API calls for resume and
@@ -22,7 +20,6 @@ export declare function postSlackApiReplyPosts(args: {
     beforePost?: () => Promise<void>;
     footer?: SlackReplyFooter;
     channelId: string;
-    fileUploadFailureMode?: "best_effort" | "strict";
     onPostError?: (context: {
         error: unknown;
         messageTs?: string;

package/dist/chat/slack/timestamp-param.d.ts

@@ -0,0 +1,25 @@
+import { type SlackMessageTs } from "@/chat/slack/timestamp";
+import { z } from "zod";
+type SlackTimestampParamResult = {
+    ok: true;
+    value: SlackMessageTs | undefined;
+} | {
+    ok: false;
+    error: string;
+};
+type RequiredSlackTimestampParamResult = {
+    ok: true;
+    value: SlackMessageTs;
+} | {
+    ok: false;
+    error: string;
+};
+/** Define a model-facing Slack timestamp, normalizing numeric model args to strings. */
+export declare function slackTimestampParam(description: string): z.ZodPreprocess<z.ZodString>;
+/** Define an optional model-facing Slack timestamp string parameter. */
+export declare function optionalSlackTimestampParam(description: string): z.ZodOptional<z.ZodPreprocess<z.ZodString>>;
+/** Parse tool input into a branded Slack timestamp before provider calls. */
+export declare function parseSlackTimestampParam(field: string, value: string | number | undefined): SlackTimestampParamResult;
+/** Parse a required tool input timestamp into a branded Slack timestamp. */
+export declare function parseRequiredSlackTimestampParam(field: string, value: string | number): RequiredSlackTimestampParamResult;
+export {};

package/dist/chat/slack/tools/canvas/context.d.ts

@@ -0,0 +1,18 @@
+import type { CanvasArtifactSummary } from "@/chat/state/artifacts";
+import type { ToolState } from "@/chat/tools/types";
+/** Merge a created canvas into artifact state without growing context forever. */
+export declare function mergeRecentCanvases(existing: CanvasArtifactSummary[] | undefined, created: {
+    id: string;
+    title: string;
+    url?: string;
+}): CanvasArtifactSummary[];
+/** Resolve model-provided canvas references before Slack API calls. */
+export declare function resolveCanvasTarget(canvas: string): {
+    ok: true;
+    canvasId: string;
+} | {
+    ok: false;
+    error: string;
+};
+/** Preserve known canvas permalinks when tools only receive an ID. */
+export declare function storedCanvasUrl(state: ToolState, canvasId: string): string | undefined;

package/dist/chat/slack/tools/canvas/create.d.ts

@@ -0,0 +1,4 @@
+import type { SlackToolContext } from "@/chat/slack/tools/context";
+import type { ToolState } from "@/chat/tools/types";
+/** Create a tool that provisions a new Slack canvas in the active channel. */
+export declare function createSlackCanvasCreateTool(context: SlackToolContext, state: ToolState): import("../../../tools/definition").AnyToolDefinition;

package/dist/chat/slack/tools/canvas/edit.d.ts

@@ -0,0 +1,3 @@
+import type { ToolState } from "@/chat/tools/types";
+/** Create a tool that edits a Slack canvas like a markdown file. */
+export declare function createSlackCanvasEditTool(state: ToolState): import("../../../tools/definition").AnyToolDefinition;

package/dist/chat/slack/tools/canvas/read.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Create a tool that reads a Slack canvas the bot has access to. Accepts
+ * either a canvas/file ID (`F...`) or a Slack canvas/docs URL and returns the
+ * canvas body downloaded via the bot's file access.
+ */
+export declare function createSlackCanvasReadTool(): import("../../../tools/definition").AnyToolDefinition;

package/dist/chat/slack/tools/canvas/write.d.ts

@@ -0,0 +1,3 @@
+import type { ToolState } from "@/chat/tools/types";
+/** Create a tool that deliberately replaces a Slack canvas body. */
+export declare function createSlackCanvasWriteTool(state: ToolState): import("../../../tools/definition").AnyToolDefinition;

package/dist/chat/{tools/slack → slack/tools}/channel-access.d.ts

@@ -1,4 +1,5 @@
 import type { ConversationPrivacy } from "@/chat/conversation-privacy";
+import type { SlackChannelId, SlackTeamId } from "@/chat/slack/ids";
 /** Minimal persisted-visibility port for cross-conversation read gates. */
 export interface DestinationVisibilityReader {
     getDestinationVisibility(args: {
@@ -22,8 +23,8 @@ export type SlackChannelReadAccess = {
  * ids), so missing or private destinations fail closed.
  */
 export declare function checkSlackChannelReadAccess(args: {
-    currentChannelIds: Array<string | undefined>;
+    currentChannelIds: Array<SlackChannelId | undefined>;
     store?: DestinationVisibilityReader;
-    targetChannelId: string;
-    teamId: string;
+    targetChannelId: SlackChannelId;
+    teamId: SlackTeamId;
 }): Promise<SlackChannelReadAccess>;