@sentry/junior 0.53.0 → 0.55.0

package/dist/build/copy-build-content.d.ts

@@ -0,0 +1,4 @@
+/** Copy app directory and plugin manifests into the server output. */
+export declare function copyAppAndPluginContent(cwd: string, serverRoot: string, packageNames?: unknown): void;
+/** Copy extra file patterns into server output for files the bundler cannot trace. */
+export declare function copyIncludedFiles(cwd: string, serverRoot: string, patterns?: unknown): void;

package/dist/build/glob-to-regex.d.ts

@@ -0,0 +1,2 @@
+/** Convert a simple file glob (supporting `*` wildcards) into a RegExp. */
+export declare function globToRegex(pattern: string): RegExp;

package/dist/build/rolldown-workarounds.d.ts

@@ -0,0 +1,14 @@
+import type { Nitro } from "nitro/types";
+/**
+ * Override rolldown's treeshake config so that module side effects survive
+ * bundling.
+ *
+ * pi-ai registers API providers via a top-level side-effect in
+ * register-builtins.js. Nitro's default moduleSideEffects whitelist only
+ * includes unenv polyfills, so rolldown tree-shakes the registration call
+ * and the apiProviderRegistry Map stays empty at runtime.
+ *
+ * TODO(upstream): Track https://github.com/nitrojs/nitro/issues/XXXX for
+ * native moduleSideEffects configuration support.
+ */
+export declare function applyRolldownTreeshakeWorkaround(nitro: Nitro): void;

package/dist/build/virtual-config.d.ts

@@ -0,0 +1,4 @@
+import type { Nitro } from "nitro/types";
+import type { PluginConfig } from "@/chat/plugins/types";
+/** Inject a virtual module so createApp() can read the plugin list at runtime. */
+export declare function injectVirtualConfig(nitro: Nitro, plugins?: PluginConfig): void;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/chat/app/factory.d.ts

@@ -0,0 +1,10 @@
+import type { SlackAdapter } from "@chat-adapter/slack";
+import { type AssistantLifecycleEvent, type SlackTurnRuntime } from "@/chat/runtime/slack-runtime";
+import type { JuniorRuntimeServiceOverrides } from "@/chat/app/services";
+import { type PreparedTurnState } from "@/chat/runtime/turn-preparation";
+export interface CreateSlackRuntimeOptions {
+    getSlackAdapter: () => SlackAdapter;
+    now?: () => number;
+    services?: JuniorRuntimeServiceOverrides;
+}
+export declare function createSlackRuntime(options: CreateSlackRuntimeOptions): SlackTurnRuntime<PreparedTurnState, AssistantLifecycleEvent>;

package/dist/chat/app/production.d.ts

@@ -0,0 +1,6 @@
+import type { SlackAdapter } from "@chat-adapter/slack";
+import { JuniorChat } from "@/chat/ingress/junior-chat";
+/** Return the lazily initialized production chat app. */
+export declare function getProductionBot(): JuniorChat<{
+    slack: SlackAdapter;
+}>;

package/dist/chat/app/services.d.ts

@@ -0,0 +1,17 @@
+import { type ConversationMemoryDeps, type ConversationMemoryService } from "@/chat/services/conversation-memory";
+import { type SubscribedReplyPolicy, type SubscribedReplyPolicyDeps } from "@/chat/services/subscribed-reply-policy";
+import type { ReplyExecutorServices } from "@/chat/runtime/reply-executor";
+import { type VisionContextDeps, type VisionContextService } from "@/chat/services/vision-context";
+export interface JuniorRuntimeServices {
+    conversationMemory: ConversationMemoryService;
+    replyExecutor: ReplyExecutorServices;
+    subscribedReplyPolicy: SubscribedReplyPolicy;
+    visionContext: VisionContextService;
+}
+export interface JuniorRuntimeServiceOverrides {
+    conversationMemory?: Partial<ConversationMemoryDeps>;
+    replyExecutor?: Partial<Omit<ReplyExecutorServices, "generateThreadTitle">>;
+    subscribedReplyPolicy?: Partial<SubscribedReplyPolicyDeps>;
+    visionContext?: Partial<VisionContextDeps>;
+}
+export declare function createJuniorRuntimeServices(overrides?: JuniorRuntimeServiceOverrides): JuniorRuntimeServices;

package/dist/chat/capabilities/catalog.d.ts

@@ -0,0 +1,16 @@
+export interface CapabilityProviderTargetDefinition {
+    type: string;
+    configKey: string;
+    commandFlags?: string[];
+}
+export interface CapabilityProviderDefinition {
+    provider: string;
+    capabilities: string[];
+    configKeys: string[];
+    target?: CapabilityProviderTargetDefinition;
+}
+export declare function getCapabilityProvider(capability: string): CapabilityProviderDefinition | undefined;
+export declare function isKnownCapability(capability: string): boolean;
+export declare function listCapabilityProviders(): CapabilityProviderDefinition[];
+/** Log the capability catalog contents once at startup. */
+export declare function logCapabilityCatalogLoadedOnce(): void;

package/dist/chat/capabilities/factory.d.ts

@@ -0,0 +1,10 @@
+import type { CredentialLease } from "@/chat/credentials/broker";
+import type { UserTokenStore } from "@/chat/credentials/user-token-store";
+/** Create the user token store used by OAuth-backed credential brokers. */
+export declare function createUserTokenStore(): UserTokenStore;
+/** Issue one provider credential lease for host-side sandbox egress proxying. */
+export declare function issueProviderCredentialLease(input: {
+    provider: string;
+    requesterId: string;
+    reason: string;
+}): Promise<CredentialLease>;

package/dist/chat/capabilities/jr-rpc-command.d.ts

@@ -0,0 +1,26 @@
+import type { ChannelConfigurationService } from "@/chat/configuration/types";
+import type { Skill } from "@/chat/skills";
+type JrRpcDeps = {
+    activeSkill: Skill | null;
+    channelConfiguration?: ChannelConfigurationService;
+    requesterId?: string;
+    onConfigurationValueChanged?: (key: string, value: unknown | undefined) => void;
+};
+export declare function maybeExecuteJrRpcCustomCommand(command: string, deps: JrRpcDeps): Promise<{
+    handled: false;
+} | {
+    handled: true;
+    result: {
+        ok: boolean;
+        command: string;
+        cwd: string;
+        exit_code: number;
+        signal: null;
+        timed_out: boolean;
+        stdout: string;
+        stderr: string;
+        stdout_truncated: boolean;
+        stderr_truncated: boolean;
+    };
+}>;
+export {};

package/dist/chat/capabilities/router.d.ts

@@ -0,0 +1,19 @@
+import type { CredentialBroker, CredentialLease } from "@/chat/credentials/broker";
+export interface CredentialRouter {
+    issue(input: {
+        provider: string;
+        reason: string;
+        requesterId?: string;
+    }): Promise<CredentialLease>;
+}
+export declare class ProviderCredentialRouter implements CredentialRouter {
+    private readonly brokersByProvider;
+    constructor(input: {
+        brokersByProvider: Record<string, CredentialBroker>;
+    });
+    issue(input: {
+        provider: string;
+        reason: string;
+        requesterId?: string;
+    }): Promise<CredentialLease>;
+}

package/dist/chat/coerce.d.ts

@@ -0,0 +1,6 @@
+/** Narrow an unknown value to a non-empty string, or undefined. */
+export declare function toOptionalString(value: unknown): string | undefined;
+/** Narrow an unknown value to a finite number, or undefined. */
+export declare function toOptionalNumber(value: unknown): number | undefined;
+/** Type-guard: true when value is a non-null object (usable as Record). */
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/dist/chat/config.d.ts

@@ -0,0 +1,47 @@
+declare const ADVISOR_THINKING_LEVELS: readonly ["minimal", "low", "medium", "high", "xhigh"];
+export type AdvisorThinkingLevel = (typeof ADVISOR_THINKING_LEVELS)[number];
+export interface BotConfig {
+    advisor: AdvisorConfig;
+    fastModelId: string;
+    loadingMessages: string[];
+    modelId: string;
+    visionModelId?: string;
+    turnTimeoutMs: number;
+    userName: string;
+}
+export interface AdvisorConfig {
+    modelId: string;
+    thinkingLevel: AdvisorThinkingLevel;
+}
+export interface ChatConfig {
+    bot: BotConfig;
+    functionMaxDurationSeconds: number;
+    slack: {
+        botToken?: string;
+        clientId?: string;
+        clientSecret?: string;
+        signingSecret?: string;
+    };
+    state: {
+        adapter: "memory" | "redis";
+        keyPrefix?: string;
+        redisUrl?: string;
+    };
+}
+/** Parse all chat configuration from environment variables. */
+export declare function readChatConfig(env?: NodeJS.ProcessEnv): ChatConfig;
+/** Return the chat configuration (parsed once at startup). */
+export declare function getChatConfig(): ChatConfig;
+/** Bot configuration derived from environment at module load. */
+export declare const botConfig: BotConfig;
+export declare function getSlackBotToken(): string | undefined;
+export declare function getSlackSigningSecret(): string | undefined;
+export declare function getSlackClientId(): string | undefined;
+export declare function getSlackClientSecret(): string | undefined;
+export declare function hasRedisConfig(): boolean;
+export interface RuntimeMetadata {
+    version?: string;
+}
+/** Return runtime metadata (version from deploy environment). */
+export declare function getRuntimeMetadata(): RuntimeMetadata;
+export {};

package/dist/chat/configuration/defaults.d.ts

@@ -0,0 +1,4 @@
+/** Store install-wide config defaults; keys must be registered plugin config keys. */
+export declare function setConfigDefaults(defaults: Record<string, unknown> | undefined): void;
+/** Return the install-wide configuration defaults (empty object when none set). */
+export declare function getConfigDefaults(): Record<string, unknown>;

package/dist/chat/configuration/service.d.ts

@@ -0,0 +1,2 @@
+import type { ChannelConfigurationService, ChannelConfigurationStorage } from "@/chat/configuration/types";
+export declare function createChannelConfigurationService(storage: ChannelConfigurationStorage): ChannelConfigurationService;

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

@@ -0,0 +1,37 @@
+export type ConfigScope = "conversation";
+export interface ConfigEntry {
+    key: string;
+    value: unknown;
+    scope: ConfigScope;
+    updatedAt: string;
+    updatedBy?: string;
+    source?: string;
+    expiresAt?: string;
+}
+export interface ChannelConfigState {
+    schemaVersion: 1;
+    entries: Record<string, ConfigEntry>;
+}
+export interface ChannelConfigurationStorage {
+    load: () => Promise<unknown | null>;
+    save: (state: ChannelConfigState) => Promise<void>;
+}
+export interface ChannelConfigurationService {
+    get: (key: string) => Promise<ConfigEntry | undefined>;
+    set: (input: {
+        key: string;
+        value: unknown;
+        updatedBy?: string;
+        source?: string;
+        expiresAt?: string;
+    }) => Promise<ConfigEntry>;
+    unset: (key: string) => Promise<boolean>;
+    list: (options?: {
+        prefix?: string;
+    }) => Promise<ConfigEntry[]>;
+    resolve: (key: string) => Promise<unknown | undefined>;
+    resolveValues: (options?: {
+        keys?: string[];
+        prefix?: string;
+    }) => Promise<Record<string, unknown>>;
+}

package/dist/chat/configuration/validation.d.ts

@@ -0,0 +1,2 @@
+export declare function validateConfigKey(key: string): string | undefined;
+export declare function validateConfigValue(value: unknown): string | undefined;

package/dist/chat/credentials/broker.d.ts

@@ -0,0 +1,22 @@
+export declare class CredentialUnavailableError extends Error {
+    readonly provider: string;
+    constructor(provider: string, message: string);
+}
+export type CredentialHeaderTransform = {
+    domain: string;
+    headers: Record<string, string>;
+};
+export interface CredentialLease {
+    id: string;
+    provider: string;
+    env: Record<string, string>;
+    headerTransforms?: CredentialHeaderTransform[];
+    expiresAt: string;
+    metadata?: Record<string, string>;
+}
+export interface CredentialBroker {
+    issue(input: {
+        reason: string;
+        requesterId?: string;
+    }): Promise<CredentialLease>;
+}

package/dist/chat/credentials/header-transforms.d.ts

@@ -0,0 +1,3 @@
+import type { CredentialHeaderTransform } from "@/chat/credentials/broker";
+/** Merge transforms by domain so later transforms override earlier headers. */
+export declare function mergeHeaderTransforms(transforms: CredentialHeaderTransform[]): CredentialHeaderTransform[];

package/dist/chat/credentials/oauth-scope.d.ts

@@ -0,0 +1,4 @@
+/** Normalize OAuth scope strings so persisted grants can be compared reliably. */
+export declare function normalizeOAuthScope(scope?: string): string | undefined;
+/** Return whether the stored grant still satisfies the provider's current scope contract. */
+export declare function hasRequiredOAuthScope(storedScope?: string, requiredScope?: string): boolean;

package/dist/chat/credentials/state-adapter-token-store.d.ts

@@ -0,0 +1,9 @@
+import type { StateAdapter } from "chat";
+import type { StoredTokens, UserTokenStore } from "@/chat/credentials/user-token-store";
+export declare class StateAdapterTokenStore implements UserTokenStore {
+    private readonly state;
+    constructor(stateAdapter: StateAdapter);
+    get(userId: string, provider: string): Promise<StoredTokens | undefined>;
+    set(userId: string, provider: string, tokens: StoredTokens): Promise<void>;
+    delete(userId: string, provider: string): Promise<void>;
+}

package/dist/chat/credentials/unlink-provider.d.ts

@@ -0,0 +1,2 @@
+import type { UserTokenStore } from "@/chat/credentials/user-token-store";
+export declare function unlinkProvider(userId: string, provider: string, userTokenStore: UserTokenStore): Promise<void>;

package/dist/chat/credentials/user-token-store.d.ts

@@ -0,0 +1,11 @@
+export interface StoredTokens {
+    accessToken: string;
+    refreshToken: string;
+    expiresAt?: number;
+    scope?: string;
+}
+export interface UserTokenStore {
+    get(userId: string, provider: string): Promise<StoredTokens | undefined>;
+    set(userId: string, provider: string, tokens: StoredTokens): Promise<void>;
+    delete(userId: string, provider: string): Promise<void>;
+}

package/dist/chat/discovery.d.ts

@@ -0,0 +1,47 @@
+/** Check whether a path exists and is a directory. */
+export declare function isDirectory(targetPath: string): boolean;
+/** Check whether a path exists and is a regular file. */
+export declare function isFile(targetPath: string): boolean;
+export interface DiscoverNodeModulesDirsOptions {
+    candidateDirs?: string[];
+}
+/** Discover node_modules directories reachable from the current working directory. */
+export declare function discoverNodeModulesDirs(cwd?: string, options?: DiscoverNodeModulesDirsOptions): string[];
+export interface DiscoverProjectRootsOptions {
+    nodeModulesDirs?: string[];
+}
+/** Discover project root directories by walking up from cwd and checking node_modules parents. */
+export declare function discoverProjectRoots(cwd?: string, options?: DiscoverProjectRootsOptions): string[];
+/** Return the resolved app home directory for the current working directory. */
+export declare function homeDir(): string;
+export interface ResolveHomeDirOptions {
+    projectRoots?: string[];
+}
+/** Resolve the app home directory by scoring candidate `app/` directories. */
+export declare function resolveHomeDir(cwd?: string, options?: ResolveHomeDirOptions): string;
+/** Return the data directory (same as homeDir). */
+export declare function dataDir(): string;
+/** Return the path to the SOUL.md file. */
+export declare function soulPath(): string;
+/** Return the path to the WORLD.md file. */
+export declare function worldPath(): string;
+/** Return the path to the DESCRIPTION.md file. */
+export declare function descriptionPath(): string;
+/** Return the skills directory path. */
+export declare function skillsDir(): string;
+/** Return the plugins directory path. */
+export declare function pluginsDir(): string;
+/** Return all unique data root directories. */
+export declare function dataRoots(): string[];
+/** Return all unique skill root directories. */
+export declare function skillRoots(): string[];
+/** Return all unique plugin root directories. */
+export declare function pluginRoots(): string[];
+/** Return candidate paths where SOUL.md might be found. */
+export declare function soulPathCandidates(): string[];
+/** Return candidate paths where WORLD.md might be found. */
+export declare function worldPathCandidates(): string[];
+/** Return candidate paths where DESCRIPTION.md might be found. */
+export declare function descriptionPathCandidates(): string[];
+/** List non-reserved .md files in the app root for sandbox reference syncing. */
+export declare function listReferenceFiles(): string[];

package/dist/chat/ingress/junior-chat.d.ts

@@ -0,0 +1,26 @@
+import { Chat, type ActionEvent, type Adapter, type AppHomeOpenedEvent, type AssistantContextChangedEvent, type AssistantThreadStartedEvent, type Message, type ModalCloseEvent, type ReactionEvent, type SlashCommandEvent, type WebhookOptions } from "chat";
+export declare class JuniorChat<TAdapters extends Record<string, Adapter> = Record<string, Adapter>> extends Chat<TAdapters> {
+    /**
+     * Normalize Slack thread IDs before the SDK's concurrency queue.
+     *
+     * Slack DM roots can arrive with an empty thread timestamp, while
+     * later replies include the root timestamp. Resolve factories before
+     * delegating so the lock/state/subscription key is canonicalized before
+     * the SDK computes its per-thread queue key.
+     */
+    processMessage(adapter: Adapter, threadId: string, messageOrFactory: Message | (() => Promise<Message>), options?: WebhookOptions): Promise<void>;
+    processReaction(event: Omit<ReactionEvent, "adapter" | "thread"> & {
+        adapter?: Adapter;
+    }, options?: WebhookOptions): void;
+    processAction(event: Omit<ActionEvent, "thread" | "openModal"> & {
+        adapter: Adapter;
+    }, options: WebhookOptions | undefined): Promise<void>;
+    processModalClose(event: Omit<ModalCloseEvent, "relatedThread" | "relatedMessage" | "relatedChannel">, contextId?: string, options?: WebhookOptions): void;
+    processSlashCommand(event: Omit<SlashCommandEvent, "channel" | "openModal"> & {
+        adapter: Adapter;
+        channelId: string;
+    }, options: WebhookOptions | undefined): void;
+    processAssistantThreadStarted(event: AssistantThreadStartedEvent, options?: WebhookOptions): void;
+    processAssistantContextChanged(event: AssistantContextChangedEvent, options?: WebhookOptions): void;
+    processAppHomeOpened(event: AppHomeOpenedEvent, options?: WebhookOptions): void;
+}

package/dist/chat/ingress/message-changed.d.ts

@@ -0,0 +1,50 @@
+import { Message, type Adapter } from "chat";
+/**
+ * Parsed result from a Slack `message_changed` event that contains a newly
+ * added bot @mention. Returns `null` when the event does not qualify.
+ */
+export interface MessageChangedMention {
+    /** Slack thread ID in `slack:<channel>:<thread_ts>` format. */
+    threadId: string;
+    /** Synthesized Message to pass to `bot.processMessage`. */
+    message: Message;
+}
+interface SlackMessageChangedEvent {
+    type: "event_callback";
+    team_id?: string;
+    event: {
+        type: "message";
+        subtype: "message_changed";
+        channel: string;
+        message: {
+            files?: SlackEditedMessageFile[];
+            source_team?: string;
+            text?: string;
+            ts: string;
+            thread_ts?: string;
+            user?: string;
+            user_team?: string;
+        };
+        previous_message: {
+            text?: string;
+        };
+    };
+}
+interface SlackEditedMessageFile {
+    mimetype?: string;
+    name?: string;
+    original_h?: number;
+    original_w?: number;
+    size?: number;
+    url_private?: string;
+    url_private_download?: string;
+}
+export declare function isMessageChangedEnvelope(value: unknown): value is SlackMessageChangedEvent;
+/**
+ * Inspect a raw parsed Slack webhook body and extract a synthesized mention
+ * event when a `message_changed` edit newly adds the bot's @mention.
+ *
+ * Returns `null` when the payload is not a qualifying `message_changed` event.
+ */
+export declare function extractMessageChangedMention(body: unknown, botUserId: string, adapter: Adapter): MessageChangedMention | null;
+export {};

package/dist/chat/ingress/message-router.d.ts

@@ -0,0 +1,9 @@
+import type { ThreadMessageKind } from "@/chat/queue/thread-message-dispatcher";
+/** Derive canonical Slack thread IDs from the raw event payload. */
+export declare function normalizeIncomingSlackThreadId(threadId: string, message: unknown): string;
+/** Classify an incoming message as a mention or subscribed message. */
+export declare function determineThreadMessageKind(args: {
+    isDirectMessage: boolean;
+    isMention: boolean;
+    isSubscribed: boolean;
+}): ThreadMessageKind | undefined;

package/dist/chat/ingress/slash-command.d.ts

@@ -0,0 +1,3 @@
+import type { SlashCommandEvent } from "chat";
+/** Route `/jr link` and `/jr unlink` slash commands to the appropriate OAuth flow. */
+export declare function handleSlashCommand(event: SlashCommandEvent): Promise<void>;

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

@@ -0,0 +1,9 @@
+export { runWithWorkspaceTeamId } from "@/chat/slack/workspace-context";
+/**
+ * Return true when a Slack event's author is from an external workspace.
+ *
+ * In Slack Connect shared channels the inner event carries `user_team`
+ * (the author's home workspace). When it differs from the outer payload's
+ * `team_id` the author is a Slack Connect participant, not a local member.
+ */
+export declare function isExternalSlackUser(raw: Record<string, unknown> | undefined): boolean;

package/dist/chat/interruption-marker.d.ts

@@ -0,0 +1,2 @@
+/** Return the marker added when a visible reply ended mid-execution. */
+export declare function getInterruptionMarker(): string;