@sentry/junior 0.53.0 → 0.55.0

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

@@ -0,0 +1,146 @@
+import type { UserTokenStore } from "@/chat/credentials/user-token-store";
+export interface PluginOAuthConfig {
+    clientIdEnv: string;
+    clientSecretEnv: string;
+    authorizeEndpoint: string;
+    tokenEndpoint: string;
+    scope?: string;
+    authorizeParams?: Record<string, string>;
+    tokenAuthMethod?: "body" | "basic";
+    tokenExtraHeaders?: Record<string, string>;
+}
+export interface OAuthProviderConfig extends PluginOAuthConfig {
+    callbackPath: string;
+}
+export interface OAuthBearerCredentials {
+    type: "oauth-bearer";
+    domains: string[];
+    apiHeaders?: Record<string, string>;
+    authTokenEnv: string;
+    authTokenPlaceholder?: string;
+}
+export interface GitHubAppCredentials {
+    type: "github-app";
+    domains: string[];
+    apiHeaders?: Record<string, string>;
+    authTokenEnv: string;
+    authTokenPlaceholder?: string;
+    appIdEnv: string;
+    privateKeyEnv: string;
+    installationIdEnv: string;
+}
+export type PluginCredentials = OAuthBearerCredentials | GitHubAppCredentials;
+export interface PluginNpmRuntimeDependency {
+    type: "npm";
+    package: string;
+    version: string;
+}
+export interface PluginSystemRuntimeDependency {
+    type: "system";
+    package: string;
+}
+export interface PluginSystemRuntimeDependencyFromUrl {
+    type: "system";
+    url: string;
+    sha256: string;
+}
+export type PluginRuntimeDependency = PluginNpmRuntimeDependency | PluginSystemRuntimeDependency | PluginSystemRuntimeDependencyFromUrl;
+export interface PluginRuntimePostinstallCommand {
+    cmd: string;
+    args?: string[];
+    sudo?: boolean;
+}
+export interface PluginMcpHttpConfig {
+    transport: "http";
+    url: string;
+    headers?: Record<string, string>;
+    allowedTools?: string[];
+}
+export type PluginMcpConfig = PluginMcpHttpConfig;
+export interface PluginEnvVarDeclaration {
+    default?: string;
+}
+export interface PluginManifest {
+    name: string;
+    description: string;
+    capabilities: string[];
+    configKeys: string[];
+    domains?: string[];
+    apiHeaders?: Record<string, string>;
+    commandEnv?: Record<string, string>;
+    envVars?: Record<string, PluginEnvVarDeclaration>;
+    credentials?: PluginCredentials;
+    runtimeDependencies?: PluginRuntimeDependency[];
+    runtimePostinstall?: PluginRuntimePostinstallCommand[];
+    mcp?: PluginMcpConfig;
+    oauth?: PluginOAuthConfig;
+    target?: {
+        type: string;
+        configKey: string;
+        commandFlags?: string[];
+    };
+}
+type PluginRuntimeDependencyConfig = {
+    type: "npm";
+    package: string;
+    version?: string;
+} | {
+    type: "system";
+    package: string;
+} | {
+    type: "system";
+    url: string;
+    sha256: string;
+};
+interface PluginOAuthConfigPatch extends Omit<Partial<PluginOAuthConfig>, "authorizeParams" | "tokenExtraHeaders"> {
+    authorizeParams?: Record<string, string | null> | null;
+    tokenExtraHeaders?: Record<string, string | null> | null;
+}
+/** Install-level changes applied to one plugin manifest before validation. */
+export interface PluginManifestConfig {
+    description?: string;
+    capabilities?: string[];
+    configKeys?: string[];
+    domains?: string[] | null;
+    apiHeaders?: Record<string, string | null> | null;
+    commandEnv?: Record<string, string | null> | null;
+    envVars?: Record<string, PluginEnvVarDeclaration | null> | null;
+    credentials?: {
+        type?: "oauth-bearer" | "github-app";
+        domains?: string[];
+        apiHeaders?: Record<string, string | null> | null;
+        authTokenEnv?: string;
+        authTokenPlaceholder?: string | null;
+        appIdEnv?: string;
+        privateKeyEnv?: string;
+        installationIdEnv?: string;
+    } | null;
+    runtimeDependencies?: PluginRuntimeDependencyConfig[] | null;
+    runtimePostinstall?: PluginRuntimePostinstallCommand[] | null;
+    mcp?: {
+        transport?: "http";
+        url?: string;
+        headers?: Record<string, string | null> | null;
+        allowedTools?: string[] | null;
+    } | null;
+    oauth?: PluginOAuthConfigPatch | null;
+    target?: {
+        type?: string;
+        configKey?: string;
+        commandFlags?: string[] | null;
+    } | null;
+}
+/** Install-level plugin package list and manifest configuration. */
+export interface PluginConfig {
+    packages?: string[];
+    manifests?: Record<string, PluginManifestConfig>;
+}
+export interface PluginBrokerDeps {
+    userTokenStore: UserTokenStore;
+}
+export interface PluginDefinition {
+    manifest: PluginManifest;
+    dir: string;
+    skillsDir: string;
+}
+export {};

package/dist/chat/prompt.d.ts

@@ -0,0 +1,39 @@
+import type { ThreadArtifactsState } from "@/chat/state/artifacts";
+import type { Skill, SkillMetadata, SkillInvocation } from "@/chat/skills";
+import type { ActiveMcpCatalogSummary } from "@/chat/tools/skill/mcp-tool-summary";
+export declare const JUNIOR_PERSONALITY: string;
+export declare const JUNIOR_WORLD: string | null;
+interface ToolPromptContext {
+    name: string;
+    promptGuidelines?: string[];
+    promptSnippet?: string;
+}
+type TurnContextPromptInput = {
+    availableSkills: SkillMetadata[];
+    activeSkills: Skill[];
+    activeMcpCatalogs?: ActiveMcpCatalogSummary[];
+    toolGuidance?: ToolPromptContext[];
+    runtime?: {
+        conversationId?: string;
+        traceId?: string;
+    };
+    invocation: SkillInvocation | null;
+    requester?: {
+        userName?: string;
+        fullName?: string;
+        userId?: string;
+    };
+    artifactState?: ThreadArtifactsState;
+    configuration?: Record<string, unknown>;
+    /**
+     * Whether this turn is a fresh prompt or a resume from a prior checkpoint
+     * (OAuth pause or timeout-resume). Surfaced in <context> so the model knows
+     * it is continuing rather than starting fresh.
+     */
+    turnState?: "fresh" | "resumed";
+};
+/** Return byte-stable platform instructions shared by every conversation and turn. */
+export declare function buildSystemPrompt(): string;
+/** Build volatile runtime context that belongs in the user turn, not the system prompt. */
+export declare function buildTurnContextPrompt(params: TurnContextPromptInput): string;
+export {};

package/dist/chat/queue/thread-message-dispatcher.d.ts

@@ -0,0 +1,33 @@
+import type { Message, Thread } from "chat";
+import type { SlackTurnRuntime } from "@/chat/runtime/slack-runtime";
+import { downloadPrivateSlackFile as downloadPrivateSlackFileImpl } from "@/chat/slack/client";
+export type ThreadMessageKind = "new_mention" | "subscribed_message";
+export interface ThreadMessageDispatchArgs {
+    beforeFirstResponsePost?: () => Promise<void>;
+    kind: ThreadMessageKind;
+    message: Message;
+    thread: Thread;
+}
+export type ThreadMessageRuntime = Pick<SlackTurnRuntime<unknown>, "handleNewMention" | "handleSubscribedMessage">;
+export type ThreadMessageDispatcher = (args: ThreadMessageDispatchArgs) => Promise<void>;
+export interface CreateThreadMessageDispatcherOptions {
+    downloadPrivateSlackFile?: typeof downloadPrivateSlackFileImpl;
+    runtime: ThreadMessageRuntime;
+}
+/**
+ * Attach Slack private-file download functions to deserialized attachments.
+ *
+ * The Chat SDK's `concurrency: "queue"` strategy serializes queued messages
+ * via `Message.toJSON()`, which strips `fetchData` (a function) and `data`
+ * (a Buffer). When dequeued, attachments have a `url` but no fetcher.
+ * This re-attaches a bot-token-auth'd download callback.
+ *
+ * No-ops when `fetchData` is already present, so safe to call unconditionally.
+ */
+export declare function rehydrateAttachmentFetchers(message: {
+    attachments: Array<{
+        fetchData?: unknown;
+        url?: string;
+    }>;
+}, downloadPrivateSlackFile?: typeof downloadPrivateSlackFileImpl): void;
+export declare function createThreadMessageDispatcher(options: CreateThreadMessageDispatcherOptions): ThreadMessageDispatcher;

package/dist/chat/respond-helpers.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Pure helper functions used by the agent reply orchestration in respond.ts.
+ *
+ * These are extracted to reduce the size of the main orchestration module and
+ * make individual helpers independently testable.
+ */
+import type { AssistantMessage, ToolResultMessage } from "@earendil-works/pi-ai";
+import type { PiMessage } from "@/chat/pi/messages";
+import type { Skill } from "@/chat/skills";
+/** Extract conversation and session identifiers from correlation context. */
+export declare function getSessionIdentifiers(context: {
+    correlation?: {
+        conversationId?: string;
+        threadId?: string;
+        turnId?: string;
+        runId?: string;
+    };
+}): {
+    conversationId?: string;
+    sessionId?: string;
+};
+/** Detect polite execution deferral phrases that signal the model is stalling. */
+export declare function isExecutionDeferralResponse(text: string): boolean;
+/** Detect disclaimers about missing tool access. */
+export declare function isToolAccessDisclaimerResponse(text: string): boolean;
+/** True when the model produced an escape response instead of executing. */
+export declare function isExecutionEscapeResponse(text: string): boolean;
+/** Best-effort JSON extraction from text that may contain fenced blocks. */
+export declare function parseJsonCandidate(text: string): unknown;
+/** Check whether a parsed object looks like a raw tool call/result payload. */
+export declare function isToolPayloadShape(payload: unknown): boolean;
+/** Detect responses that are raw tool payloads leaked as text. */
+export declare function isRawToolPayloadResponse(text: string): boolean;
+/** Redact image data from prompt content parts for observability. */
+export declare function toObservablePromptPart(part: {
+    type: "text";
+    text: string;
+} | {
+    type: "image";
+    data: string;
+    mimeType: string;
+}): Record<string, unknown>;
+/** Truncate message text for log attributes. */
+export declare function summarizeMessageText(text: string): string;
+/**
+ * Put prior thread text before the current instruction when no Pi history
+ * exists. These are top-level sibling blocks in the user message.
+ */
+export declare function buildUserTurnText(userInput: string, conversationContext?: string): string;
+/** Encode a non-image attachment as base64 XML for the prompt. */
+export declare function encodeNonImageAttachmentForPrompt(attachment: {
+    data: Buffer;
+    mediaType: string;
+    filename?: string;
+}): string;
+/** Type guard for Pi SDK tool result messages. */
+export declare function isToolResultMessage(value: unknown): value is ToolResultMessage<any>;
+/** Extract the tool name from a raw tool result message. */
+export declare function normalizeToolNameFromResult(result: unknown): string | undefined;
+/** Check whether a tool result carries an error flag. */
+export declare function isToolResultError(result: unknown): boolean;
+/** Type guard for Pi SDK assistant messages. */
+export declare function isAssistantMessage(value: unknown): value is AssistantMessage;
+/** Extract role string from a raw Pi message. */
+export declare function getPiMessageRole(value: unknown): string | undefined;
+/** Refresh volatile runtime context in a checkpoint before continuing Pi. */
+export declare function refreshRuntimeTurnContext(messages: PiMessage[], turnContextPrompt: string): PiMessage[];
+/** Remove volatile runtime context before using checkpoint messages as history. */
+export declare function stripRuntimeTurnContext(messages: PiMessage[]): PiMessage[];
+/** Concatenate text content parts from an assistant message. */
+export declare function extractAssistantText(message: AssistantMessage): string;
+/** Return assistant messages that belong to the terminal post-tool reply phase. */
+export declare function getTerminalAssistantMessages(messages: readonly unknown[]): AssistantMessage[];
+/** Upsert a skill into the active skills list by name. */
+export declare function upsertActiveSkill(activeSkills: Skill[], next: Skill): void;
+/** Remove trailing assistant messages before checkpointing. */
+export declare function trimTrailingAssistantMessages(messages: PiMessage[]): PiMessage[];

package/dist/chat/respond.d.ts

@@ -0,0 +1,75 @@
+import type { ChannelConfigurationService } from "@/chat/configuration/types";
+import type { ThreadArtifactsState } from "@/chat/state/artifacts";
+import type { ConversationPendingAuthState } from "@/chat/state/conversation";
+import type { ImageGenerateToolDeps, WebFetchToolDeps, WebSearchToolDeps } from "@/chat/tools/types";
+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;
+        threadId?: string;
+        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[];
+    channelConfiguration?: ChannelConfigurationService;
+    userAttachments?: Array<{
+        data?: Buffer;
+        mediaType: string;
+        filename?: string;
+        promptText?: string;
+    }>;
+    inboundAttachmentCount?: number;
+    omittedImageAttachmentCount?: number;
+    sandbox?: {
+        sandboxId?: string;
+        sandboxDependencyProfileHash?: string;
+    };
+    onSandboxAcquired?: (sandbox: SandboxAcquiredState) => void | Promise<void>;
+    onArtifactStateUpdated?: (artifactState: ThreadArtifactsState) => void | Promise<void>;
+    toolOverrides?: {
+        imageGenerate?: ImageGenerateToolDeps;
+        webFetch?: WebFetchToolDeps;
+        webSearch?: WebSearchToolDeps;
+    };
+    onStatus?: (status: AssistantStatusSpec) => void | Promise<void>;
+    onAuthPending?: (pendingAuth: ConversationPendingAuthState) => void | Promise<void>;
+    onTextDelta?: (deltaText: string) => void | Promise<void>;
+    onAssistantMessageStart?: () => void | Promise<void>;
+    onToolInvocation?: (invocation: {
+        toolName: string;
+        params: Record<string, unknown>;
+    }) => void;
+}
+/** Run a full agent turn: discover skills, execute tools, and return the assistant reply. */
+export declare function generateAssistantReply(messageText: string, context?: ReplyRequestContext): Promise<AssistantReply>;

package/dist/chat/runtime/auth-pause-state.d.ts

@@ -0,0 +1,11 @@
+import { type ThreadConversationState } from "@/chat/state/conversation";
+/** Mark an auth-paused turn complete after private authorization link delivery. */
+export declare function completeAuthPauseTurn(args: {
+    conversation: ThreadConversationState;
+    sessionId: string;
+}): void;
+/** Reload thread state, mark the auth pause as parked, and persist it. */
+export declare function persistAuthPauseTurnState(args: {
+    sessionId: string;
+    threadStateId: string;
+}): Promise<void>;

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

@@ -0,0 +1,15 @@
+import type { AssistantReply } from "@/chat/respond";
+import type { ThreadConversationState } from "@/chat/state/conversation";
+import type { ThreadArtifactsState } from "@/chat/state/artifacts";
+import { type ThreadStatePatch } from "@/chat/runtime/thread-state";
+/** Build the canonical thread-state patch after final Slack delivery succeeds. */
+export declare function buildDeliveredTurnStatePatch(args: {
+    artifactStatePatch?: Partial<ThreadArtifactsState>;
+    artifacts: ThreadArtifactsState;
+    conversation: ThreadConversationState;
+    reply: AssistantReply;
+    sessionId: string;
+    userMessageId?: string;
+}): ThreadStatePatch & {
+    conversation: ThreadConversationState;
+};

package/dist/chat/runtime/dev-agent-trace.d.ts

@@ -0,0 +1 @@
+export declare function shouldEmitDevAgentTrace(): boolean;

package/dist/chat/runtime/processing-reaction.d.ts

@@ -0,0 +1,25 @@
+import type { Message, Thread } from "chat";
+/** Controls the automatic Slack processing reaction lifecycle for one message. */
+export interface ProcessingReactionSession {
+    keep: () => void;
+    stop: () => Promise<void>;
+}
+/** Return true when a Slack reaction tool call should leave the processing reaction in place. */
+export declare function shouldKeepProcessingReactionForToolInvocation(input: {
+    params: Record<string, unknown>;
+    toolName: string;
+}): boolean;
+/** Start Junior's automatic Slack processing reaction for one inbound message. */
+export declare function startSlackProcessingReaction(args: {
+    logException: (error: unknown, eventName: string, context?: Record<string, unknown>, attributes?: Record<string, unknown>, body?: string) => string | undefined;
+    logContext: Record<string, unknown>;
+    message: Message;
+    thread: Thread;
+}): Promise<ProcessingReactionSession>;
+/** Start Junior's automatic Slack processing reaction for a known Slack message. */
+export declare function startSlackProcessingReactionForMessage(args: {
+    channelId: string;
+    timestamp: string;
+    logException: (error: unknown, eventName: string, context?: Record<string, unknown>, attributes?: Record<string, unknown>, body?: string) => string | undefined;
+    logContext: Record<string, unknown>;
+}): Promise<ProcessingReactionSession>;

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

@@ -0,0 +1,56 @@
+import type { Message, Thread } from "chat";
+import type { SlackAdapter } from "@chat-adapter/slack";
+import { generateAssistantReply as generateAssistantReplyImpl } from "@/chat/respond";
+import type { PreparedTurnState } from "@/chat/runtime/turn-preparation";
+import { type ConversationMemoryService } from "@/chat/services/conversation-memory";
+import { lookupSlackUser } from "@/chat/slack/user";
+import type { TurnContinuationRequest } from "@/chat/services/timeout-resume";
+export interface ReplyExecutorServices {
+    generateAssistantReply: typeof generateAssistantReplyImpl;
+    generateThreadTitle: ConversationMemoryService["generateThreadTitle"];
+    getAwaitingTurnContinuationRequest: (args: {
+        conversationId: string;
+        sessionId: string;
+    }) => Promise<TurnContinuationRequest | undefined>;
+    lookupSlackUser: typeof lookupSlackUser;
+    scheduleTurnTimeoutResume: (request: TurnContinuationRequest) => Promise<void>;
+}
+interface ReplyExecutorDeps {
+    getSlackAdapter: () => SlackAdapter;
+    resolveUserAttachments: (attachments: Message["attachments"] | undefined, context: {
+        threadId?: string;
+        requesterId?: string;
+        channelId?: string;
+        runId?: string;
+        conversation?: PreparedTurnState["conversation"];
+        messageTs?: string;
+    }) => Promise<Array<{
+        data?: Buffer;
+        mediaType: string;
+        filename?: string;
+        promptText?: string;
+    }>>;
+    prepareTurnState: (args: {
+        explicitMention: boolean;
+        message: Message;
+        thread: Thread;
+        userText: string;
+        context: {
+            threadId?: string;
+            requesterId?: string;
+            channelId?: string;
+            runId?: string;
+        };
+    }) => Promise<PreparedTurnState>;
+    services: ReplyExecutorServices;
+}
+export declare function createReplyToThread(deps: ReplyExecutorDeps): (thread: Thread, message: Message, options?: {
+    beforeFirstResponsePost?: () => Promise<void>;
+    explicitMention?: boolean;
+    onToolInvocation?: (invocation: {
+        params: Record<string, unknown>;
+        toolName: string;
+    }) => void;
+    preparedState?: PreparedTurnState;
+}) => Promise<void>;
+export {};

package/dist/chat/runtime/report-progress.d.ts

@@ -0,0 +1,3 @@
+import type { AssistantStatusSpec } from "@/chat/slack/assistant-thread/status-render";
+/** Convert a `reportProgress` tool payload into assistant status text. */
+export declare function buildReportedProgressStatus(input: unknown): AssistantStatusSpec | undefined;

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

@@ -0,0 +1,50 @@
+import { generateAssistantReply, type AssistantReply, type ReplyRequestContext } from "@/chat/respond";
+/** Error raised when another worker already owns the resume lock. */
+export declare class ResumeTurnBusyError extends Error {
+    constructor(lockKey: string);
+}
+interface ResumeSlackTurnArgs {
+    messageText: string;
+    channelId: string;
+    threadTs: string;
+    messageTs?: string;
+    replyContext?: ReplyRequestContext;
+    lockKey?: string;
+    initialText?: string;
+    generateReply?: typeof generateAssistantReply;
+    onSuccess?: (reply: AssistantReply) => Promise<void>;
+    onFailure?: (error: unknown) => Promise<void>;
+    onAuthPause?: (error: unknown) => Promise<void>;
+    onTimeoutPause?: (error: unknown) => Promise<void>;
+    onPostDeliveryCommitFailure?: (error: unknown) => Promise<void>;
+    beforeStart?: () => Promise<Partial<ResumeSlackTurnArgs> | false | void>;
+    replyTimeoutMs?: number;
+}
+/**
+ * Resume a paused Slack turn under the normal thread lock.
+ *
+ * Success is defined by final reply delivery, not only by successful assistant
+ * generation. If the final visible Slack post fails, the resumed turn is
+ * treated as failed so thread state does not claim the user saw a reply that
+ * never arrived.
+ */
+export declare function resumeSlackTurn(args: ResumeSlackTurnArgs): Promise<void>;
+/** Resume an OAuth-paused Slack request through the shared resume runner. */
+export declare function resumeAuthorizedRequest(args: {
+    messageText: string;
+    channelId: string;
+    threadTs: string;
+    messageTs?: string;
+    connectedText: string;
+    replyContext?: ReplyRequestContext;
+    lockKey?: string;
+    generateReply?: typeof generateAssistantReply;
+    onSuccess?: (reply: AssistantReply) => Promise<void>;
+    onFailure?: (error: unknown) => Promise<void>;
+    onAuthPause?: (error: unknown) => Promise<void>;
+    onTimeoutPause?: (error: unknown) => Promise<void>;
+    onPostDeliveryCommitFailure?: (error: unknown) => Promise<void>;
+    beforeStart?: () => Promise<Partial<ResumeSlackTurnArgs> | false | void>;
+    replyTimeoutMs?: number;
+}): Promise<void>;
+export {};

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

@@ -0,0 +1,100 @@
+import type { Message, Thread } from "chat";
+import type { SubscribedReplyDecision } from "@/chat/services/subscribed-reply-policy";
+export interface AssistantLifecycleEvent {
+    channelId: string;
+    context?: {
+        channelId?: string;
+    };
+    threadId: string;
+    threadTs: string;
+    userId?: string;
+}
+export interface ThreadContext {
+    channelId?: string;
+    requesterId?: string;
+    threadId?: string;
+    runId?: string;
+}
+export interface ReplyHooks {
+    beforeFirstResponsePost?: () => Promise<void>;
+    onToolInvocation?: (invocation: {
+        params: Record<string, unknown>;
+        toolName: string;
+    }) => void;
+}
+export interface SlackTurnRuntimeDependencies<TPreparedState> {
+    assistantUserName: string;
+    getChannelId: (thread: Thread, message: Message) => string | undefined;
+    getPreparedConversationContext: (preparedState: TPreparedState) => string | undefined;
+    getThreadId: (thread: Thread, message: Message) => string | undefined;
+    getRunId: (thread: Thread, message: Message) => string | undefined;
+    initializeAssistantThread: (event: {
+        channelId: string;
+        sourceChannelId?: string;
+        threadId: string;
+        threadTs: string;
+    }) => Promise<void>;
+    refreshAssistantThreadContext: (event: {
+        channelId: string;
+        sourceChannelId?: string;
+        threadId: string;
+        threadTs: string;
+    }) => Promise<void>;
+    logException: (error: unknown, eventName: string, context?: Record<string, unknown>, attributes?: Record<string, unknown>, body?: string) => string | undefined;
+    logWarn: (eventName: string, context?: Record<string, unknown>, attributes?: Record<string, unknown>, body?: string) => void;
+    modelId: string;
+    now: () => number;
+    recordSkippedSubscribedMessage: (args: {
+        completedAtMs: number;
+        decision: SubscribedReplyDecision;
+        message: Message;
+        thread: Thread;
+        userText: string;
+    }) => Promise<void>;
+    onSubscribedMessageSkipped: (args: {
+        completedAtMs: number;
+        decision: SubscribedReplyDecision;
+        message: Message;
+        preparedState?: TPreparedState;
+        thread: Thread;
+    }) => Promise<void>;
+    persistPreparedState: (args: {
+        preparedState: TPreparedState;
+        thread: Thread;
+    }) => Promise<void>;
+    prepareTurnState: (args: {
+        context: ThreadContext;
+        explicitMention: boolean;
+        message: Message;
+        thread: Thread;
+        userText: string;
+    }) => Promise<TPreparedState>;
+    replyToThread: (thread: Thread, message: Message, options?: {
+        beforeFirstResponsePost?: () => Promise<void>;
+        explicitMention?: boolean;
+        onToolInvocation?: (invocation: {
+            params: Record<string, unknown>;
+            toolName: string;
+        }) => void;
+        preparedState?: TPreparedState;
+    }) => Promise<void>;
+    decideSubscribedReply: (args: {
+        context: ThreadContext;
+        conversationContext?: string;
+        hasAttachments?: boolean;
+        isExplicitMention?: boolean;
+        rawText: string;
+        text: string;
+    }) => Promise<SubscribedReplyDecision>;
+    stripLeadingBotMention: (text: string, options: {
+        stripLeadingSlackMentionToken?: boolean;
+    }) => string;
+    withSpan: (name: string, op: string, context: Record<string, unknown>, callback: () => Promise<void>) => Promise<void>;
+}
+export interface SlackTurnRuntime<_TPreparedState, TAssistantEvent extends AssistantLifecycleEvent = AssistantLifecycleEvent> {
+    handleAssistantContextChanged: (event: TAssistantEvent) => Promise<void>;
+    handleAssistantThreadStarted: (event: TAssistantEvent) => Promise<void>;
+    handleNewMention: (thread: Thread, message: Message, hooks?: ReplyHooks) => Promise<void>;
+    handleSubscribedMessage: (thread: Thread, message: Message, hooks?: ReplyHooks) => Promise<void>;
+}
+export declare function createSlackTurnRuntime<TPreparedState, TAssistantEvent extends AssistantLifecycleEvent = AssistantLifecycleEvent>(deps: SlackTurnRuntimeDependencies<TPreparedState>): SlackTurnRuntime<TPreparedState, TAssistantEvent>;

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

@@ -0,0 +1,24 @@
+import type { Message, Thread } from "chat";
+export declare function stripLeadingBotMention(text: string, options?: {
+    stripLeadingSlackMentionToken?: boolean;
+}): string;
+export declare function getThreadId(thread: Thread, _message: Message): string | undefined;
+export declare function getRunId(thread: Thread, message: Message): string | undefined;
+export declare function getChannelId(thread: Thread, message: Message): string | undefined;
+export declare function getThreadTs(threadId: string | undefined): string | undefined;
+/**
+ * Resolve Slack assistant-thread API context for the current turn.
+ *
+ * Slack assistant-thread methods must use the live inbound thread context
+ * Slack provided on the current message. Slack's assistant utilities build
+ * `setStatus`/`setTitle` from `message.channel` plus `message.thread_ts ?? message.ts`
+ * for non-DM message events, while `message.im` still requires an explicit
+ * `thread_ts`. Do not synthesize assistant-thread roots from persisted state.
+ */
+export declare function getAssistantThreadContext(message: Message): {
+    channelId: string;
+    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;