@sentry/junior 0.53.0 → 0.54.0

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

@@ -0,0 +1,74 @@
+import { type AgentTurnSessionCheckpoint } from "@/chat/state/turn-session-store";
+import type { PiMessage } from "@/chat/pi/messages";
+import { type AgentTurnUsage } from "@/chat/usage";
+export interface TurnCheckpointContext {
+    conversationId?: string;
+    sessionId?: string;
+}
+export interface TurnCheckpointState {
+    canUseTurnSession: boolean;
+    resumedFromCheckpoint: boolean;
+    currentSliceId: number;
+    existingCheckpoint?: AgentTurnSessionCheckpoint;
+}
+interface CheckpointLogContext {
+    threadId?: string;
+    requesterId?: string;
+    channelId?: string;
+    runId?: string;
+    assistantUserName?: string;
+    modelId: string;
+}
+/** Load turn checkpoint state for a conversation/session pair. */
+export declare function loadTurnCheckpoint(ctx: TurnCheckpointContext): Promise<TurnCheckpointState>;
+/** Persist the latest safe in-progress boundary without scheduling continuation. */
+export declare function persistRunningCheckpoint(args: {
+    conversationId: string;
+    sessionId: string;
+    sliceId: number;
+    messages: PiMessage[];
+    loadedSkillNames: string[];
+    logContext: CheckpointLogContext;
+}): Promise<void>;
+/** Persist a completed turn checkpoint. */
+export declare function persistCompletedCheckpoint(args: {
+    conversationId: string;
+    currentDurationMs?: number;
+    currentUsage?: AgentTurnUsage;
+    sessionId: string;
+    sliceId: number;
+    allMessages: PiMessage[];
+    loadedSkillNames: string[];
+    logContext: CheckpointLogContext;
+}): Promise<void>;
+/**
+ * Persist an auth-pause checkpoint. Returns the durable checkpoint only when
+ * the caller can safely hand the user to an authorization resume flow.
+ */
+export declare function persistAuthPauseCheckpoint(args: {
+    conversationId: string;
+    sessionId: string;
+    currentSliceId: number;
+    currentDurationMs?: number;
+    currentUsage?: AgentTurnUsage;
+    messages: PiMessage[];
+    loadedSkillNames: string[];
+    errorMessage: string;
+    logContext: CheckpointLogContext;
+}): Promise<AgentTurnSessionCheckpoint | undefined>;
+/**
+ * Persist a timeout checkpoint at the last safe boundary. Returns the durable
+ * checkpoint when persistence succeeds so callers can enqueue a continuation.
+ */
+export declare function persistTimeoutCheckpoint(args: {
+    conversationId: string;
+    sessionId: string;
+    currentSliceId: number;
+    currentDurationMs?: number;
+    currentUsage?: AgentTurnUsage;
+    messages: PiMessage[];
+    loadedSkillNames: string[];
+    errorMessage: string;
+    logContext: CheckpointLogContext;
+}): Promise<AgentTurnSessionCheckpoint | undefined>;
+export {};

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

@@ -0,0 +1,2 @@
+/** Build the user-facing response for a turn parked for continuation. */
+export declare function buildTurnContinuationResponse(): string;

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

@@ -0,0 +1,15 @@
+import type { LogContext } from "@/chat/logging";
+import type { AssistantReply } 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>;
+/** Enforce one captured, event-ID-bearing failure response before delivery. */
+export declare function finalizeFailedTurnReply(args: {
+    reply: AssistantReply;
+    logException: LogException;
+    context: LogContext;
+    attributes?: Record<string, unknown>;
+}): AssistantReply;
+export {};

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

@@ -0,0 +1,55 @@
+import type { FileUpload } from "chat";
+import type { LogContext } from "@/chat/logging";
+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 { ThreadArtifactsState } from "@/chat/state/artifacts";
+export interface AgentTurnDiagnostics {
+    assistantMessageCount: number;
+    durationMs?: number;
+    errorMessage?: string;
+    providerError?: unknown;
+    modelId: string;
+    outcome: "success" | "execution_failure" | "provider_error";
+    thinkingLevel?: TurnThinkingSelection["thinkingLevel"];
+    stopReason?: string;
+    toolCalls: string[];
+    toolErrorCount: number;
+    toolResultCount: number;
+    usage?: AgentTurnUsage;
+    usedPrimaryText: boolean;
+}
+export interface AssistantReply {
+    text: string;
+    files?: FileUpload[];
+    artifactStatePatch?: Partial<ThreadArtifactsState>;
+    deliveryPlan?: ReplyDeliveryPlan;
+    deliveryMode?: "thread" | "channel_only";
+    sandboxId?: string;
+    sandboxDependencyProfileHash?: string;
+    diagnostics: AgentTurnDiagnostics;
+}
+export interface TurnResultInput {
+    newMessages: unknown[];
+    userInput: string;
+    replyFiles: FileUpload[];
+    artifactStatePatch: Partial<ThreadArtifactsState>;
+    toolCalls: string[];
+    sandboxId?: string;
+    sandboxDependencyProfileHash?: string;
+    durationMs?: number;
+    generatedFileCount: number;
+    shouldTrace: boolean;
+    spanContext: LogContext;
+    usage?: AgentTurnUsage;
+    thinkingSelection: TurnThinkingSelection;
+    correlation?: {
+        threadId?: string;
+        requesterId?: string;
+        channelId?: string;
+        runId?: string;
+    };
+    assistantUserName?: string;
+}
+/** Process raw agent messages into a structured AssistantReply. */
+export declare function buildTurnResult(input: TurnResultInput): AssistantReply;

package/dist/chat/services/turn-thinking-level.d.ts

@@ -0,0 +1,49 @@
+import type { ThinkingLevel as AgentThinkingLevel } from "@earendil-works/pi-agent-core";
+import type { ThinkingLevel as ProviderThinkingLevel } from "@earendil-works/pi-ai";
+import { z } from "zod";
+declare const TURN_THINKING_LEVELS: readonly ["none", "low", "medium", "high", "xhigh"];
+declare const turnExecutionProfileSchema: z.ZodObject<{
+    thinking_level: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+        none: "none";
+    }>;
+    confidence: z.ZodPreprocess<z.ZodNumber>;
+    reason: z.ZodString;
+}, z.core.$strip>;
+type TurnThinkingLevel = (typeof TURN_THINKING_LEVELS)[number];
+export interface TurnThinkingSelection {
+    confidence?: number;
+    thinkingLevel: TurnThinkingLevel;
+    reason: string;
+}
+/** Choose the thinking level for the upcoming assistant turn. */
+export declare function selectTurnThinkingLevel(args: {
+    completeObject: (args: {
+        modelId: string;
+        schema: typeof turnExecutionProfileSchema;
+        maxTokens: number;
+        metadata: Record<string, string>;
+        prompt: string;
+        thinkingLevel?: ProviderThinkingLevel;
+        system: string;
+        temperature: number;
+    }) => Promise<{
+        object: unknown;
+    }>;
+    conversationContext?: string;
+    context?: {
+        channelId?: string;
+        requesterId?: string;
+        runId?: string;
+        threadId?: string;
+    };
+    currentTurnBlocks?: string[];
+    fastModelId: string;
+    messageText: string;
+}): Promise<TurnThinkingSelection>;
+/** Convert a routing bucket into the Pi Agent thinking level for a main turn. */
+export declare function toAgentThinkingLevel(level: TurnThinkingSelection["thinkingLevel"]): AgentThinkingLevel | "off";
+export {};

package/dist/chat/services/vision-context.d.ts

@@ -0,0 +1,61 @@
+import type { Attachment } from "chat";
+import type { completeText } from "@/chat/pi/client";
+import type { ThreadConversationState } from "@/chat/state/conversation";
+export interface UserInputAttachment {
+    data?: Buffer;
+    mediaType: string;
+    filename?: string;
+    promptText?: string;
+}
+interface VisionThreadFile {
+    id?: string;
+    mimetype?: string;
+    name?: string;
+    size?: number;
+    url_private?: string;
+    url_private_download?: string;
+}
+interface VisionThreadReply {
+    ts?: string;
+    subtype?: string;
+    bot_id?: string;
+    files?: VisionThreadFile[];
+}
+export interface VisionContextDeps {
+    completeText: typeof completeText;
+    downloadFile: (url: string) => Promise<Buffer>;
+    listThreadReplies: (input: {
+        channelId: string;
+        threadTs: string;
+        limit?: number;
+        maxPages?: number;
+        targetMessageTs?: string[];
+    }) => Promise<VisionThreadReply[]>;
+}
+export interface VisionContextService {
+    hydrateConversationVisionContext: (conversation: ThreadConversationState, context: {
+        threadId?: string;
+        channelId?: string;
+        requesterId?: string;
+        runId?: string;
+        threadTs?: string;
+    }) => Promise<void>;
+    resolveUserAttachments: (attachments: Attachment[] | undefined, context: ResolveUserAttachmentsContext) => Promise<UserInputAttachment[]>;
+}
+interface ResolveUserAttachmentsContext {
+    threadId?: string;
+    requesterId?: string;
+    channelId?: string;
+    runId?: string;
+    conversation?: ThreadConversationState;
+    messageTs?: string;
+}
+/** Report whether the current Slack message carries an image that needs vision hydration. */
+export declare function hasPotentialImageAttachment(attachments: Attachment[] | undefined): boolean;
+/** Count image-bearing Slack attachments before vision filtering removes them. */
+export declare function countPotentialImageAttachments(attachments: Attachment[] | undefined): number;
+/** Report whether a dedicated vision model is configured for image analysis. */
+export declare function isVisionEnabled(): boolean;
+/** Build the vision service that owns thread image hydration and attachment preprocessing. */
+export declare function createVisionContextService(deps: VisionContextDeps): VisionContextService;
+export {};

package/dist/chat/skills.d.ts

@@ -0,0 +1,48 @@
+export interface ParsedSkillFile {
+    name: string;
+    description: string;
+    body: string;
+    metadata?: Record<string, unknown>;
+    compatibility?: string;
+    license?: string;
+    allowedTools?: string[];
+    disableModelInvocation?: boolean;
+}
+/** Strip YAML frontmatter from a skill file, returning only the body. */
+export declare function stripFrontmatter(raw: string): string;
+/** Parse a SKILL.md file's frontmatter and body. */
+export declare function parseSkillFile(raw: string, expectedName?: string): {
+    ok: true;
+    skill: ParsedSkillFile;
+} | {
+    ok: false;
+    error: string;
+};
+export interface SkillMetadata {
+    name: string;
+    description: string;
+    skillPath: string;
+    pluginProvider?: string;
+    allowedTools?: string[];
+    disableModelInvocation?: boolean;
+}
+export interface Skill extends SkillMetadata {
+    body: string;
+}
+export interface SkillInvocation {
+    skillName: string;
+    args: string;
+}
+export interface DiscoverSkillsOptions {
+    additionalRoots?: string[];
+}
+/** Clear the cached skill discovery results so the next call re-scans disk. */
+export declare function resetSkillDiscoveryCache(): void;
+/** Scan all configured skill roots and return discovered skill metadata, using a cache when roots match. */
+export declare function discoverSkills(options?: DiscoverSkillsOptions): Promise<SkillMetadata[]>;
+/** Extract a skill invocation (name + args) from a user message, or return null if none matches. */
+export declare function parseSkillInvocation(messageText: string, availableSkills: SkillMetadata[]): SkillInvocation | null;
+/** Look up a skill by name from the available set. */
+export declare function findSkillByName(skillName: string, available: SkillMetadata[]): SkillMetadata | null;
+/** Load full skill bodies for a list of skill names, reading SKILL.md files from disk. */
+export declare function loadSkillsByName(skillNames: string[], available: SkillMetadata[]): Promise<Skill[]>;

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

@@ -0,0 +1,9 @@
+import { type SlackAdapter, type SlackAdapterConfig } from "@chat-adapter/slack";
+/**
+ * Create the repository's Slack adapter.
+ *
+ * Junior used to patch private Slack adapter internals to alter native stream
+ * buffering. Visible reply delivery now relies on finalized thread posts plus
+ * assistant status updates, so we keep the adapter on the documented surface.
+ */
+export declare function createJuniorSlackAdapter(config?: SlackAdapterConfig): SlackAdapter;

package/dist/chat/slack/app-home.d.ts

@@ -0,0 +1,11 @@
+import type { WebClient, KnownBlock } from "@slack/web-api";
+import type { UserTokenStore } from "@/chat/credentials/user-token-store";
+interface HomeView {
+    type: "home";
+    blocks: KnownBlock[];
+}
+/** Build the Slack App Home tab view showing skills, connected accounts, and version. */
+export declare function buildHomeView(userId: string, userTokenStore: UserTokenStore): Promise<HomeView>;
+/** Publish the App Home view to a specific Slack user. */
+export declare function publishAppHomeView(slackClient: WebClient, userId: string, userTokenStore: UserTokenStore): Promise<void>;
+export {};

package/dist/chat/slack/assistant-thread/lifecycle.d.ts

@@ -0,0 +1,13 @@
+import type { SlackAdapter } from "@chat-adapter/slack";
+interface AssistantThreadLifecycleEvent {
+    channelId: string;
+    threadTs: string;
+    sourceChannelId?: string;
+    getSlackAdapter: () => SlackAdapter;
+    onContextChannelResolved: (sourceChannelId: string) => Promise<void>;
+}
+/** Initialize a newly started Slack assistant thread. */
+export declare function initializeAssistantThread(event: AssistantThreadLifecycleEvent): Promise<void>;
+/** Refresh Slack assistant thread context without resetting the thread title. */
+export declare function refreshAssistantThreadContext(event: AssistantThreadLifecycleEvent): Promise<void>;
+export {};

package/dist/chat/slack/assistant-thread/status-render.d.ts

@@ -0,0 +1,28 @@
+declare const DEFAULT_STATUS_CONTEXTS: {
+    readonly thinking: "…";
+    readonly searching: "sources";
+    readonly reading: "task";
+    readonly reviewing: "results";
+    readonly drafting: "reply";
+    readonly running: "tasks";
+};
+type AssistantStatusVerb = keyof typeof DEFAULT_STATUS_CONTEXTS;
+export interface AssistantStatusSpec {
+    text: string;
+}
+interface AssistantStatusPresentation {
+    key: string;
+    visible: string;
+}
+/** Build assistant progress text from a verb and optional context. */
+export declare function makeAssistantStatus(verb: AssistantStatusVerb, context?: string): AssistantStatusSpec;
+/** Normalize a progress update into the visible Slack loading copy. */
+export declare function renderAssistantStatus(args: {
+    status: AssistantStatusSpec;
+}): AssistantStatusPresentation;
+/** Select and normalize the loading messages used for Slack status rotation. */
+export declare function selectAssistantLoadingMessages(args: {
+    messages: string[];
+    random?: () => number;
+}): string[] | undefined;
+export {};

package/dist/chat/slack/assistant-thread/status-scheduler.d.ts

@@ -0,0 +1,23 @@
+import { type AssistantStatusSpec } from "@/chat/slack/assistant-thread/status-render";
+export type TimerHandle = ReturnType<typeof setTimeout>;
+export interface AssistantStatusSession {
+    start: () => void;
+    stop: () => Promise<void>;
+    update: (status: AssistantStatusSpec) => void;
+}
+/**
+ * Pace assistant loading-state writes for a single turn.
+ *
+ * This layer owns only local scheduling policy: debounce, minimum visible
+ * duration, refresh cadence, and write ordering. It deals in user-visible
+ * progress copy; the transport decides how that maps onto Slack's `status`
+ * versus `loading_messages` fields.
+ */
+export declare function createAssistantStatusScheduler(args: {
+    sendStatus: (text: string, loadingMessages?: string[]) => Promise<void>;
+    loadingMessages?: string[];
+    now?: () => number;
+    setTimer?: (callback: () => void, delayMs: number) => TimerHandle;
+    clearTimer?: (timer: TimerHandle) => void;
+    random?: () => number;
+}): AssistantStatusSession;

package/dist/chat/slack/assistant-thread/status-send.d.ts

@@ -0,0 +1,31 @@
+import type { SlackAdapter } from "@chat-adapter/slack";
+import { getSlackClient } from "@/chat/slack/client";
+/**
+ * Slack's assistant loading UI accepts both `status` and `loading_messages`,
+ * but product policy keeps `status` stable and generic. User-visible progress
+ * copy belongs in `loading_messages`.
+ */
+export declare const SLACK_ASSISTANT_ACTIVE_STATUS = "is working on your request...";
+type AssistantStatusSender = (text: string, loadingMessages?: string[]) => Promise<void>;
+/**
+ * Build a best-effort sender for Slack's assistant loading state.
+ *
+ * The `text` argument is internal progress copy. This transport maps it onto
+ * Slack's loading surface and keeps the raw Slack `status` field fixed.
+ */
+export declare function createSlackAdapterStatusSender(args: {
+    channelId?: string;
+    threadTs?: string;
+    getSlackAdapter: () => Pick<SlackAdapter, "setAssistantStatus">;
+}): AssistantStatusSender;
+/**
+ * Build a best-effort sender for Slack's assistant loading state over raw Web
+ * API calls. As with the adapter-backed path, the dynamic copy goes to
+ * `loading_messages` while `status` stays fixed and generic.
+ */
+export declare function createSlackWebApiStatusSender(args: {
+    channelId?: string;
+    threadTs?: string;
+    getSlackClient?: typeof getSlackClient;
+}): AssistantStatusSender;
+export {};

package/dist/chat/slack/assistant-thread/status.d.ts

@@ -0,0 +1,36 @@
+import type { SlackAdapter } from "@chat-adapter/slack";
+import { getSlackClient } from "@/chat/slack/client";
+import { type AssistantStatusSession, type TimerHandle } from "@/chat/slack/assistant-thread/status-scheduler";
+export { makeAssistantStatus, type AssistantStatusSpec, } from "@/chat/slack/assistant-thread/status-render";
+export type { AssistantStatusSession } from "@/chat/slack/assistant-thread/status-scheduler";
+/**
+ * Create a Slack adapter-backed session for Slack's assistant loading state.
+ *
+ * The session accepts internal progress updates and leaves it to the sender to
+ * map them onto Slack's fixed generic `status` field plus dynamic
+ * `loading_messages`.
+ */
+export declare function createSlackAdapterAssistantStatusSession(args: {
+    channelId?: string;
+    threadTs?: string;
+    getSlackAdapter: () => Pick<SlackAdapter, "setAssistantStatus">;
+    loadingMessages?: string[];
+    now?: () => number;
+    setTimer?: (callback: () => void, delayMs: number) => TimerHandle;
+    clearTimer?: (timer: TimerHandle) => void;
+    random?: () => number;
+}): AssistantStatusSession;
+/**
+ * Create a Web API-backed session for Slack's assistant loading state in
+ * resume/callback flows that do not use the adapter thread object.
+ */
+export declare function createSlackWebApiAssistantStatusSession(args: {
+    channelId?: string;
+    threadTs?: string;
+    getSlackClient?: typeof getSlackClient;
+    loadingMessages?: string[];
+    now?: () => number;
+    setTimer?: (callback: () => void, delayMs: number) => TimerHandle;
+    clearTimer?: (timer: TimerHandle) => void;
+    random?: () => number;
+}): AssistantStatusSession;

package/dist/chat/slack/assistant-thread/title.d.ts

@@ -0,0 +1,28 @@
+import type { SlackAdapter } from "@chat-adapter/slack";
+import { type ConversationMemoryService } from "@/chat/services/conversation-memory";
+import type { ThreadArtifactsState } from "@/chat/state/artifacts";
+import type { ThreadConversationState } from "@/chat/state/conversation";
+/**
+ * Best-effort assistant-thread title update for DM assistant threads.
+ *
+ * Title generation is intentionally detached from reply generation and visible
+ * reply delivery. Stable Slack permission failures are treated as a terminal
+ * skip for the current source message so later turns do not keep paying for
+ * the same fast-model title generation call.
+ */
+export declare function maybeUpdateAssistantTitle(args: {
+    assistantThreadContext?: {
+        channelId: string;
+        threadTs: string;
+    };
+    assistantUserName: string;
+    artifacts: ThreadArtifactsState;
+    channelId?: string;
+    conversation: ThreadConversationState;
+    generateThreadTitle: ConversationMemoryService["generateThreadTitle"];
+    getSlackAdapter: () => Pick<SlackAdapter, "setAssistantTitle">;
+    modelId: string;
+    requesterId?: string;
+    runId?: string;
+    threadId?: string;
+}): Promise<string | undefined>;

package/dist/chat/slack/canvas-references.d.ts

@@ -0,0 +1,2 @@
+/** Resolve a Slack Canvas/file ID from a bare ID or Slack docs/canvas/files URL. */
+export declare function extractCanvasId(input: string): string | undefined;

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

@@ -0,0 +1,48 @@
+export interface SlackChannelMessage {
+    ts?: string;
+    user?: string;
+    text?: string;
+    thread_ts?: string;
+    subtype?: string;
+    bot_id?: string;
+    type?: string;
+    attachments?: unknown[];
+}
+export interface SlackFileRef {
+    id?: string;
+    mimetype?: string;
+    name?: string;
+    size?: number;
+    url_private?: string;
+    url_private_download?: string;
+}
+export interface SlackThreadReply {
+    ts?: string;
+    user?: string;
+    text?: string;
+    thread_ts?: string;
+    subtype?: string;
+    bot_id?: string;
+    type?: string;
+    files?: SlackFileRef[];
+    attachments?: unknown[];
+}
+export declare function listChannelMessages(input: {
+    channelId: string;
+    limit: number;
+    cursor?: string;
+    oldest?: string;
+    latest?: string;
+    inclusive?: boolean;
+    maxPages?: number;
+}): Promise<{
+    messages: SlackChannelMessage[];
+    nextCursor?: string;
+}>;
+export declare function listThreadReplies(input: {
+    channelId: string;
+    threadTs: string;
+    limit?: number;
+    maxPages?: number;
+    targetMessageTs?: string[];
+}): Promise<SlackThreadReply[]>;

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

@@ -0,0 +1,52 @@
+import { WebClient } from "@slack/web-api";
+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" | "internal_error";
+export declare class SlackActionError extends Error {
+    code: SlackActionErrorCode;
+    apiError?: string;
+    needed?: string;
+    provided?: string;
+    statusCode?: number;
+    requestId?: string;
+    errorData?: string;
+    retryAfterSeconds?: number;
+    detail?: string;
+    detailLine?: number;
+    detailRule?: string;
+    constructor(message: string, code: SlackActionErrorCode, options?: {
+        apiError?: string;
+        needed?: string;
+        provided?: string;
+        statusCode?: number;
+        requestId?: string;
+        errorData?: string;
+        retryAfterSeconds?: number;
+        detail?: string;
+        detailLine?: number;
+        detailRule?: string;
+    });
+}
+interface SlackRetryContext {
+    action?: string;
+    attributes?: Record<string, string | number | boolean>;
+}
+/** Extract a header value by case-insensitive name from a raw headers object. */
+export declare function getHeaderString(headers: unknown, name: string): string | undefined;
+export declare function normalizeSlackConversationId(channelId: string | undefined): string | undefined;
+export declare function withSlackRetries<T>(task: () => Promise<T>, maxAttempts?: number, context?: SlackRetryContext): Promise<T>;
+export declare function getSlackClient(): WebClient;
+/**
+ * Slack channel ID prefixes:
+ * - C: public channel
+ * - G: private channel / group DM
+ * - D: direct message (1:1)
+ */
+export declare function isDmChannel(channelId: string): boolean;
+/**
+ * Conversation-scoped Slack contexts backed by a concrete conversation ID.
+ * Includes channels/groups/DMs (C/G/D).
+ */
+export declare function isConversationScopedChannel(channelId: string | undefined): boolean;
+export declare function isConversationChannel(channelId: string | undefined): boolean;
+export declare function getFilePermalink(fileId: string): Promise<string | undefined>;
+export declare function downloadPrivateSlackFile(url: string): Promise<Buffer>;
+export {};

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

@@ -0,0 +1,9 @@
+/** Extract channelId and threadTs from a `slack:<channel>:<ts>` thread identifier. */
+export declare function parseSlackThreadId(threadId: string | undefined): {
+    channelId: string;
+    threadTs: string;
+} | undefined;
+/** Resolve the Slack channel ID from a `slack:<channel>:<ts>` thread identifier. */
+export declare function resolveSlackChannelIdFromThreadId(threadId: string | undefined): string | undefined;
+/** Best-effort channel ID extraction from a raw Slack message payload. */
+export declare function resolveSlackChannelIdFromMessage(message: unknown): string | undefined;

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

@@ -0,0 +1 @@
+export declare function normalizeSlackEmojiName(value: string): string | null;

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

@@ -0,0 +1,6 @@
+/** Extract Slack's stable API error code from Web API errors. */
+export declare function getSlackApiErrorCode(error: unknown): string | undefined;
+/** Convert Slack Web API error details into the repository's trace attributes. */
+export declare function getSlackErrorObservabilityAttributes(error: unknown): Record<string, string | number>;
+/** Report whether Slack rejected assistant title updates for stable auth reasons. */
+export declare function isSlackTitlePermissionError(error: unknown): boolean;