@sentry/junior 0.53.0 → 0.55.0

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;

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

@@ -0,0 +1,42 @@
+import type { TurnThinkingSelection } from "@/chat/services/turn-thinking-level";
+import type { AgentTurnUsage } from "@/chat/usage";
+interface SlackMrkdwnTextObject {
+    text: string;
+    type: "mrkdwn";
+}
+/** Slack-flavored Markdown block — accepts a standard Markdown subset and Slack renders it natively. */
+interface SlackMarkdownBlock {
+    text: string;
+    type: "markdown";
+}
+interface SlackSectionBlock {
+    text: SlackMrkdwnTextObject;
+    type: "section";
+}
+interface SlackContextBlock {
+    elements: SlackMrkdwnTextObject[];
+    type: "context";
+}
+export type SlackMessageBlock = SlackMarkdownBlock | SlackSectionBlock | SlackContextBlock;
+interface SlackReplyFooterItem {
+    label: string;
+    url?: string;
+    value: string;
+}
+export interface SlackReplyFooter {
+    items: SlackReplyFooterItem[];
+}
+/**
+ * Build a compact footer for the finalized Slack reply.
+ *
+ * This is reply metadata, not part of the in-flight assistant loading state.
+ */
+export declare function buildSlackReplyFooter(args: {
+    conversationId?: string;
+    durationMs?: number;
+    thinkingLevel?: TurnThinkingSelection["thinkingLevel"];
+    usage?: AgentTurnUsage;
+}): SlackReplyFooter | undefined;
+/** Build Slack blocks for a reply chunk using the Slack-flavored markdown block for the body. */
+export declare function buildSlackReplyBlocks(text: string, footer: SlackReplyFooter | undefined): SlackMessageBlock[] | undefined;
+export {};

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/legacy-attachments.d.ts

@@ -0,0 +1,4 @@
+/** Render legacy Slack attachment fields so attachment-only messages still carry context. */
+export declare function renderSlackLegacyAttachmentText(input: unknown): string;
+/** Append legacy Slack attachment text to the message text used by routing and replies. */
+export declare function appendSlackLegacyAttachmentText(baseText: string | undefined, rawMessageOrAttachments: unknown): string;

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

@@ -0,0 +1,6 @@
+import type { Message } from "chat";
+/**
+ * Preserve the native Slack message timestamp when a synthetic message ID is
+ * used for routing or deduplication.
+ */
+export declare function getSlackMessageTs(message: Pick<Message, "id" | "raw">): string;

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

@@ -0,0 +1,12 @@
+/** Insert blank lines between content blocks so Slack renders them with visual separation. */
+export declare function ensureBlockSpacing(text: string): string;
+/**
+ * Render model-authored markdown into Slack-friendly `mrkdwn`.
+ *
+ * Slack reply delivery owns chunking and continuation markers separately.
+ * This helper only normalizes text into the repository's canonical Slack
+ * rendering form.
+ */
+export declare function renderSlackMrkdwn(text: string): string;
+/** Normalize assistant status text before handing it to Slack. */
+export declare function normalizeSlackStatusText(text: string): string;

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

@@ -0,0 +1,57 @@
+import type { SlackMessageBlock } from "@/chat/slack/footer";
+/** Post Slack `mrkdwn` text to a conversation or thread via the shared outbound boundary. */
+export declare function postSlackMessage(input: {
+    blocks?: SlackMessageBlock[];
+    channelId: string;
+    text: string;
+    threadTs?: string;
+    includePermalink?: boolean;
+}): Promise<{
+    ts: string;
+    permalink?: string;
+}>;
+/** Delete a previously posted Slack message through the shared outbound boundary. */
+export declare function deleteSlackMessage(input: {
+    channelId: string;
+    timestamp: string;
+}): Promise<void>;
+/**
+ * Post an ephemeral Slack message. Delivery is best-effort on Slack's side, but
+ * request validation and Web API behavior are centralized here.
+ */
+export declare function postSlackEphemeralMessage(input: {
+    channelId: string;
+    userId: string;
+    text: string;
+    threadTs?: string;
+}): Promise<{
+    messageTs?: string;
+}>;
+/** Upload files into a Slack thread via the shared outbound file boundary. */
+export declare function uploadFilesToThread(input: {
+    channelId: string;
+    threadTs: string;
+    files: Array<{
+        data: Buffer;
+        filename: string;
+    }>;
+}): Promise<void>;
+/** Add a reaction to a Slack message, treating `already_reacted` as idempotent success. */
+export declare function addReactionToMessage(input: {
+    channelId: string;
+    timestamp: string;
+    emoji: string;
+}): Promise<{
+    ok: true;
+}>;
+/** Remove a reaction from a Slack message, treating `no_reaction` as idempotent success. */
+export declare function removeReactionFromMessage(input: {
+    channelId: string;
+    timestamp: string;
+    emoji: string;
+}): Promise<{
+    ok: true;
+}>;
+export declare const slackOutboundPolicy: {
+    maxMessageTextChars: number;
+};

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

@@ -0,0 +1,54 @@
+import type { FileUpload, PostableMessage } from "chat";
+/** Return the first continuation-safe chunk plus any remaining text. */
+export declare function takeSlackContinuationPrefix(text: string, options?: {
+    forceSplit?: boolean;
+    maxChars?: number;
+    maxLines?: number;
+}): {
+    prefix: string;
+    renderedPrefix: string;
+    rest: string;
+};
+/**
+ * Take the largest Slack-safe inline prefix from `text` under the configured
+ * character and line budgets. Returns the consumed prefix plus remaining text.
+ */
+export declare function takeSlackInlinePrefix(text: string, options?: {
+    maxChars?: number;
+    maxLines?: number;
+}): {
+    prefix: string;
+    rest: string;
+};
+/**
+ * Split a normalized Slack reply into multiple inline-safe thread messages.
+ *
+ * Replies split across more than two messages receive explicit continuation
+ * markers on non-final chunks. When
+ * `interrupted` is true, the final chunk receives an interruption marker.
+ */
+export declare function splitSlackReplyText(text: string, options?: {
+    interrupted?: boolean;
+}): string[];
+/** Return the marker added to non-final overflow chunks. */
+export declare function getSlackContinuationMarker(): string;
+/** Return the marker added when a visible reply ended mid-execution. */
+export declare function getSlackInterruptionMarker(): string;
+/**
+ * Return true when `text` already fits the repository's inline Slack reply
+ * budget without needing continuation messages.
+ */
+export declare function fitsSlackInlineBudget(text: string): boolean;
+/**
+ * Reserve enough inline budget for a continuation suffix on the current chunk.
+ */
+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;
+export declare const slackOutputPolicy: {
+    maxInlineChars: number;
+    maxInlineLines: number;
+};

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

@@ -0,0 +1,33 @@
+import type { FileUpload } from "chat";
+import type { AssistantReply } from "@/chat/respond";
+import { type SlackReplyFooter } from "@/chat/slack/footer";
+export type PlannedSlackReplyStage = "thread_reply" | "thread_reply_continuation" | "thread_reply_files_followup";
+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.
+ */
+export declare function planSlackReplyPosts(args: {
+    reply: AssistantReply;
+}): PlannedSlackReplyPost[];
+/**
+ * Deliver planned Slack reply posts over raw Slack Web API calls for resume and
+ * callback handlers that do not have a Chat SDK thread object.
+ */
+export declare function postSlackApiReplyPosts(args: {
+    beforePost?: () => Promise<void>;
+    footer?: SlackReplyFooter;
+    channelId: string;
+    fileUploadFailureMode?: "best_effort" | "strict";
+    onPostError?: (context: {
+        error: unknown;
+        messageTs?: string;
+        stage: PlannedSlackReplyStage;
+    }) => Promise<void> | void;
+    threadTs?: string;
+    posts: PlannedSlackReplyPost[];
+}): Promise<string | undefined>;

package/dist/chat/slack/status-format.d.ts

@@ -0,0 +1,2 @@
+/** Truncate a status string to fit Slack's 50-char assistant status limit. */
+export declare function truncateStatusText(text: string): string;

package/dist/chat/slack/turn-continuation-notice.d.ts

@@ -0,0 +1,8 @@
+import { type SlackMessageBlock } from "@/chat/slack/footer";
+/** Build the Slack timeout-continuation acknowledgement with correlation-only metadata. */
+export declare function buildSlackTurnContinuationNotice(args: {
+    conversationId?: string;
+}): {
+    blocks?: SlackMessageBlock[];
+    text: string;
+};

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

@@ -0,0 +1,8 @@
+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>;
+export {};

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

@@ -0,0 +1,39 @@
+/** Normalized Slack user profile with custom fields from the Slack workspace. */
+export interface SlackUserProfile {
+    id: string;
+    team_id?: string;
+    name?: string;
+    real_name?: string;
+    display_name?: string;
+    title?: string;
+    email?: string;
+    status_text?: string;
+    status_emoji?: string;
+    is_bot: boolean;
+    is_deleted: boolean;
+    timezone?: string;
+    profile_fields?: Array<{
+        id: string;
+        label?: string;
+        value?: string;
+        alt?: string;
+    }>;
+}
+/** Look up a Slack user by ID, returning the full profile including custom fields. */
+export declare function lookupSlackUserProfile(userId: string): Promise<SlackUserProfile>;
+/** Look up a Slack user by email. Returns null when no user matches. */
+export declare function lookupSlackUserByEmail(email: string): Promise<SlackUserProfile | null>;
+export interface SlackUserSearchResult {
+    users: SlackUserProfile[];
+    searched_pages: number;
+    searched_user_count: number;
+    truncated: boolean;
+}
+/** Search workspace users by name with bounded pagination through `users.list`. */
+export declare function searchSlackUsers(options: {
+    query: string;
+    limit?: number;
+    maxPages?: number;
+    includeDeleted?: boolean;
+    includeBots?: boolean;
+}): Promise<SlackUserSearchResult>;

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;