@opengeni/api-router 0.30.1 → 1.0.0

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

@@ -0,0 +1,24 @@
+import { type Session } from "@opengeni/contracts";
+import type { SlackHomeBlock } from "./slack-bot.js";
+export type SlackAppHomeOpenedEvent = {
+    eventId: string;
+    slackTeamId: string;
+    slackUserId: string;
+    viewHash: string | null;
+};
+export declare function slackAppHomeOpenedEvent(payload: unknown): SlackAppHomeOpenedEvent | null;
+/** URL-only App Home buttons are acknowledged but never become Slack commands. */
+export declare function isSlackAppHomeLinkAction(payload: unknown): boolean;
+export declare function buildSlackAppHomeBlocks(input: {
+    sessions: readonly Session[];
+    workspaceUrl: string | null;
+    sessionUrl: (sessionId: string) => string | null;
+    nowMs?: number;
+}): SlackHomeBlock[];
+export declare function buildSlackAppHomeAccessBlocks(input: {
+    title: string;
+    message: string;
+    actionLabel?: string;
+    actionUrl?: string | null;
+}): SlackHomeBlock[];
+export declare function escapeSlackMrkdwn(value: string): string;

package/dist/integrations/slack-bot.d.ts

@@ -1,9 +1,10 @@
 import { type Settings } from "@opengeni/config";
-import { OPENGENI_SLACK_BOT_CREDENTIAL_LABEL, OPENGENI_SLACK_BOT_CREDENTIAL_ROLE, type AccessGrant, type ConnectionMetadata, type OpenGeniSlackBotConnectionMetadata } from "@opengeni/contracts";
+import { OPENGENI_SLACK_BOT_CREDENTIAL_LABEL, OPENGENI_SLACK_BOT_CREDENTIAL_ROLE, type AccessGrant, type ConnectionMetadata, type OpenGeniSlackBotDisplayName, type OpenGeniSlackBotConnectionMetadata } from "@opengeni/contracts";
 import { type Database } from "@opengeni/db";
 import { type FetchLike } from "@opengeni/network";
 import { HTTPException } from "hono/http-exception";
 export declare const SLACK_REACTION_IMAGE_MAX_BYTES: number;
+export declare const SLACK_MCP_IMAGE_MAX_BYTES: number;
 declare const SLACK_REACTION_CONTEXT_CHECKPOINT_VERSION = 1;
 type SlackPayload = Record<string, unknown> & {
     ok?: unknown;
@@ -34,12 +35,16 @@ export type DownloadedSlackReactionImage = Readonly<{
     contentType: "image/png" | "image/jpeg" | "image/webp";
     bytes: Uint8Array;
 }>;
+export type ExchangedOpenGeniSlackAuthorization = Readonly<{
+    accessToken: string;
+    appId: string;
+}>;
 export declare function exchangeOpenGeniSlackAuthorizationCode(input: {
     code: string;
     clientId: string;
     clientSecret: string;
     redirectUri: string;
-}, fetchImpl?: FetchLike): Promise<string>;
+}, fetchImpl?: FetchLike): Promise<ExchangedOpenGeniSlackAuthorization>;
 export type SlackBotReceipt = {
     credentialRole: typeof OPENGENI_SLACK_BOT_CREDENTIAL_ROLE;
     credentialLabel: typeof OPENGENI_SLACK_BOT_CREDENTIAL_LABEL;
@@ -71,10 +76,69 @@ export type SlackMessageBlock = {
         };
         style?: "primary" | "danger";
     }>;
+} | {
+    type: "context";
+    block_id?: string;
+    elements: Array<{
+        type: "mrkdwn" | "plain_text";
+        text: string;
+        emoji?: boolean;
+    }>;
 } | {
     type: "divider";
 };
-type SlackBotOperation = "channels.list" | "channel_history.read" | "thread_replies.read" | "users.list" | "files.list" | "file.info" | "file.content.read" | "message.post" | "message.update" | "message.delete";
+export type SlackHomeBlock = {
+    type: "header";
+    block_id?: string;
+    text: {
+        type: "plain_text";
+        text: string;
+        emoji?: boolean;
+    };
+} | {
+    type: "section";
+    block_id?: string;
+    text: {
+        type: "mrkdwn" | "plain_text";
+        text: string;
+        emoji?: boolean;
+    };
+    accessory?: {
+        type: "button";
+        action_id: string;
+        text: {
+            type: "plain_text";
+            text: string;
+            emoji?: boolean;
+        };
+        url: string;
+    };
+} | {
+    type: "context";
+    block_id?: string;
+    elements: Array<{
+        type: "mrkdwn" | "plain_text";
+        text: string;
+        emoji?: boolean;
+    }>;
+} | {
+    type: "actions";
+    block_id: string;
+    elements: Array<{
+        type: "button";
+        action_id: string;
+        text: {
+            type: "plain_text";
+            text: string;
+            emoji?: boolean;
+        };
+        url: string;
+        style?: "primary" | "danger";
+    }>;
+} | {
+    type: "divider";
+};
+type SlackBotOperation = "channels.list" | "search.context" | "channel_history.read" | "thread_replies.read" | "users.list" | "files.list" | "file.info" | "file.content.read" | "file.upload" | "home.publish" | "message.post" | "message.update" | "message.delete";
 type SlackBotContext = {
     accountId: string;
     workspaceId: string;
@@ -82,6 +146,7 @@ type SlackBotContext = {
     sessionId?: string | null;
     scheduledTaskId?: string | null;
 };
+type SlackProviderAuthorization = () => Promise<boolean | void>;
 export type SlackReactionContextCheckpointBinding = {
     inboxId: string;
     accountId: string;
@@ -125,6 +190,33 @@ export declare class SlackBotProviderError extends Error {
     readonly retryAfterMs: number | null;
     constructor(code: string, retryAfterMs?: number | null);
 }
+export declare function slackHistoryRateLimited(error: unknown): error is SlackBotProviderError;
+/**
+ * The post or update ledger already binds this operation id to different
+ * request bytes. Raised from the durable claim, before any Slack write, so a
+ * caller that knows an earlier release wrote other bytes for the same operation
+ * may retry once with those bytes.
+ */
+export declare class SlackBotOperationConflictError extends Error {
+    constructor(kind: "post" | "update" | "delete");
+}
+/** Only Slack's one-time HTTPS upload endpoint may receive retained bytes. */
+export declare function slackFileUploadUrl(value: string): URL;
+/** A channel listing alone is not proof of delivery to the requested thread. */
+export declare function slackFileSharedToThread(value: unknown, input: {
+    fileId: string;
+    channelId: string;
+    threadTimestamp: string;
+    botUserId: string;
+}): boolean;
+export declare function authorizeSlackSharedImageRead(channel: {
+    isArchived: boolean;
+    isShared: boolean;
+    isExternallyShared: boolean;
+    isOrgShared: boolean;
+    isPendingExternallyShared: boolean;
+    isMpim: boolean;
+}, authorizeSharedRead: (() => Promise<void>) | undefined): Promise<void>;
 export type SlackBotCredentialVerificationFailureReason = "scope_mismatch" | "identity_mismatch";
 export declare class SlackBotCredentialVerificationError extends HTTPException {
     readonly failureReason: SlackBotCredentialVerificationFailureReason;
@@ -132,11 +224,14 @@ export declare class SlackBotCredentialVerificationError extends HTTPException {
 }
 /**
  * Validates a write-only xoxb credential before it can enter encrypted storage.
- * Slack does not expose the app's display_information name to this scope set;
- * users.info provides the authoritative installed bot display name, while the
- * documented manifest fixes the app name itself to the same exact value.
+ * The OAuth exchange's app_id is the immutable app authority. Slack bot profile
+ * names are mutable presentation data and may lag manifest/App Home changes, so
+ * they must not decide whether a credential belongs to this installation.
  */
-export declare function verifyOpenGeniSlackBotCredential(token: string, fetchImpl?: FetchLike, now?: Date): Promise<VerifiedOpenGeniSlackBot>;
+export declare function verifyOpenGeniSlackBotCredential(token: string, expected: Readonly<{
+    appId: string;
+    displayName: OpenGeniSlackBotDisplayName;
+}>, fetchImpl?: FetchLike, now?: Date): Promise<VerifiedOpenGeniSlackBot>;
 export declare function resolveSlackBotConnectionForTool(input: {
     db: Database;
     grant: AccessGrant;
@@ -147,6 +242,73 @@ export declare function resolveSlackBotConnectionForTool(input: {
     metadata: OpenGeniSlackBotConnectionMetadata;
     context: SlackBotContext;
 }>;
+/**
+ * The one destination a scheduled run may post to as the OpenGeni bot: the
+ * channel a person chose on the task, through the bot connection frozen on the
+ * run's session. The agent never supplies a channel. Every call re-reads the
+ * task, so a person clearing or changing the channel takes effect at once.
+ */
+export declare function resolveScheduledSlackBotPostTarget(input: {
+    db: Database;
+    grant: AccessGrant;
+    sessionId: string | null;
+}): Promise<Awaited<ReturnType<typeof resolveSlackBotConnectionForTool>> & {
+    scheduledTaskId: string;
+    channelId: string;
+}>;
+/**
+ * Save one message for the task's channel without sending it. The returned id
+ * is server-owned and becomes the Slack post operation id, so retrying the
+ * send can never post the same message twice.
+ */
+export declare function prepareScheduledSlackBotPost(input: {
+    db: Database;
+    grant: AccessGrant;
+    sessionId: string | null;
+    text: string;
+    threadTimestamp?: string | undefined;
+}): Promise<{
+    messageId: string;
+    identity: "workspace_bot";
+    channelId: string;
+    threadTimestamp: string | null;
+    text: string;
+    sent: boolean;
+}>;
+/**
+ * Send a message this run prepared, exactly as saved. The destination must
+ * still be the task's channel and the bot connection unchanged; otherwise the
+ * send is refused rather than redirected.
+ */
+export declare function sendScheduledSlackBotPost(input: {
+    db: Database;
+    settings: Settings;
+    grant: AccessGrant;
+    sessionId: string | null;
+    messageId: string;
+    slackFetch?: typeof fetch;
+    authorizeProviderRequest?: SlackProviderAuthorization;
+}): Promise<{
+    channelId: string;
+    timestamp: string;
+    threadTimestamp: string | null;
+    receipt: SlackBotReceipt;
+}>;
+/**
+ * Check, with the bot's token, that a person's chosen task channel is one the
+ * bot is a member of, active, and not shared with another organization.
+ */
+export declare function verifyScheduledTaskSlackChannel(deps: {
+    db: Database;
+    settings: Settings;
+    slackFetch?: typeof fetch;
+}, input: {
+    accountId: string;
+    workspaceId: string;
+    subjectId: string;
+    connectionId: string;
+    channelId: string;
+}): Promise<void>;
 export declare class OpenGeniSlackBotClient {
     private readonly db;
     private readonly settings;
@@ -154,8 +316,12 @@ export declare class OpenGeniSlackBotClient {
     private readonly metadata;
     private readonly context;
     private readonly fetchImpl;
+    private readonly authorizeProviderRequest?;
     private readonly resolveCredential;
-    constructor(db: Database, settings: Settings, connection: ConnectionMetadata, metadata: OpenGeniSlackBotConnectionMetadata, context: SlackBotContext, fetchImpl?: FetchLike);
+    private readonly rateLimit;
+    constructor(db: Database, settings: Settings, connection: ConnectionMetadata, metadata: OpenGeniSlackBotConnectionMetadata, context: SlackBotContext, fetchImpl?: FetchLike, authorizeProviderRequest?: SlackProviderAuthorization | undefined);
+    private historyPageLimit;
+    private postReconciliationPageLimit;
     listChannels(input?: {
         limit?: number;
         cursor?: string;
@@ -167,6 +333,7 @@ export declare class OpenGeniSlackBotClient {
             isMember: boolean;
             isDirectMessage: boolean;
             isMpim: boolean;
+            userId: string | null;
             isArchived: boolean;
             isShared: boolean;
             isExternallyShared: boolean;
@@ -190,6 +357,7 @@ export declare class OpenGeniSlackBotClient {
         isMember: boolean;
         isDirectMessage: boolean;
         isMpim: boolean;
+        userId: string | null;
         isArchived: boolean;
         isShared: boolean;
         isExternallyShared: boolean;
@@ -202,6 +370,64 @@ export declare class OpenGeniSlackBotClient {
         purpose: string;
         numMembers: number | null;
     }>;
+    /** Server-only upload preparation; the temporary URL never enters a tool result. */
+    allocateFileUpload(input: {
+        channelId: string;
+        privateRecipientSlackUserId?: string;
+        filename: string;
+        sizeBytes: number;
+    }): Promise<{
+        fileId: string;
+        uploadUrl: URL;
+    } & {
+        receipt: SlackBotReceipt;
+    }>;
+    transferFileUpload(input: {
+        channelId: string;
+        privateRecipientSlackUserId?: string;
+        uploadUrl: URL;
+        bytes: Uint8Array;
+    }): Promise<{
+        uploaded: boolean;
+    } & {
+        receipt: SlackBotReceipt;
+    }>;
+    completeFileUpload(input: {
+        channelId: string;
+        privateRecipientSlackUserId?: string;
+        threadTimestamp: string;
+        fileId: string;
+        title: string;
+    }): Promise<{
+        fileId: string;
+    } & {
+        receipt: SlackBotReceipt;
+    }>;
+    reconcileFileUpload(input: {
+        channelId: string;
+        privateRecipientSlackUserId?: string;
+        threadTimestamp: string;
+        fileId: string;
+    }): Promise<{
+        shared: boolean;
+    } & {
+        receipt: SlackBotReceipt;
+    }>;
+    private requireFileUploadScope;
+    /**
+     * Replace one Slack user's private App Home view. `views.publish` is a
+     * naturally convergent replace operation: Slack event retries may safely
+     * repeat the exact bounded view without creating duplicate provider state.
+     */
+    publishHomeView(input: {
+        userId: string;
+        blocks: SlackHomeBlock[];
+        hash?: string | null;
+    }): Promise<{
+        viewId: string;
+    } & {
+        receipt: SlackBotReceipt;
+    }>;
     slackTaskPolicyFacts(channelId: string, userId: string): Promise<({
         conversation: {
             id: string;
@@ -210,6 +436,7 @@ export declare class OpenGeniSlackBotClient {
             isMember: boolean;
             isDirectMessage: boolean;
             isMpim: boolean;
+            userId: string | null;
             isArchived: boolean;
             isShared: boolean;
             isExternallyShared: boolean;
@@ -231,6 +458,7 @@ export declare class OpenGeniSlackBotClient {
             isMember: boolean;
             isDirectMessage: boolean;
             isMpim: boolean;
+            userId: string | null;
             isArchived: boolean;
             isShared: boolean;
             isExternallyShared: boolean;
@@ -267,6 +495,7 @@ export declare class OpenGeniSlackBotClient {
             isMember: boolean;
             isDirectMessage: boolean;
             isMpim: boolean;
+            userId: string | null;
             isArchived: boolean;
             isShared: boolean;
             isExternallyShared: boolean;
@@ -318,6 +547,7 @@ export declare class OpenGeniSlackBotClient {
             isMember: boolean;
             isDirectMessage: boolean;
             isMpim: boolean;
+            userId: string | null;
             isArchived: boolean;
             isShared: boolean;
             isExternallyShared: boolean;
@@ -358,7 +588,6 @@ export declare class OpenGeniSlackBotClient {
         messageTimestamp: string;
         checkpoint: unknown | null;
         checkpointBinding: SlackReactionContextCheckpointBinding;
-        saveCheckpoint: (checkpoint: SlackReactionContextCheckpoint) => Promise<void>;
     }): Promise<{
         channel: {
             id: string;
@@ -367,6 +596,7 @@ export declare class OpenGeniSlackBotClient {
             isMember: boolean;
             isDirectMessage: boolean;
             isMpim: boolean;
+            userId: string | null;
             isArchived: boolean;
             isShared: boolean;
             isExternallyShared: boolean;
@@ -417,6 +647,7 @@ export declare class OpenGeniSlackBotClient {
             }[];
         }[];
         truncated: boolean;
+        contextUnavailable?: boolean;
     } & {
         receipt: SlackBotReceipt;
     }>;
@@ -433,9 +664,10 @@ export declare class OpenGeniSlackBotClient {
             name: string;
             title: string;
         }[];
+        authorizeSharedRead?: () => Promise<void>;
     }): Promise<PreparedSlackReactionImage[]>;
     /** Download and fully validate one previously authorized Slack image. */
-    downloadReactionImage(input: PreparedSlackReactionImage): Promise<DownloadedSlackReactionImage>;
+    downloadReactionImage(input: PreparedSlackReactionImage, authorizeSharedRead?: () => Promise<void>): Promise<DownloadedSlackReactionImage>;
     listUsers(input?: {
         limit?: number;
         cursor?: string;
@@ -452,6 +684,64 @@ export declare class OpenGeniSlackBotClient {
     } & {
         receipt: SlackBotReceipt;
     }>;
+    /**
+     * Public search in a trusted Slack interaction through Real-time Search
+     * (`assistant.search.context`) under the bot identity. Unlisted deployments
+     * cannot use this API; approved deployments also need Slack's action token.
+     *
+     * The bot never carries private-search authority: `channel_types` is pinned
+     * to `public_channel` server-side regardless of caller input, so private
+     * channels, DMs, and MPIMs remain reachable only through a member's personal
+     * hosted-MCP grant. An install predating the search scopes fails closed with
+     * a reinstall hint instead of leaking Slack's `missing_scope` error.
+     */
+    searchContext(input: {
+        query: string;
+        /** Server-owned Slack interaction token, never an agent tool argument. */
+        actionToken?: string;
+        contentTypes?: readonly ("messages" | "files" | "channels")[];
+        includeBots?: boolean;
+        /** UNIX seconds bounds on message timestamps. */
+        before?: number;
+        after?: number;
+        sort?: "score" | "timestamp";
+        sortDir?: "asc" | "desc";
+        cursor?: string;
+        limit?: number;
+    }): Promise<{
+        messages: {
+            channelId: string;
+            channelName: string;
+            ts: string;
+            authorUserId: string;
+            authorName: string;
+            isAuthorBot: boolean;
+            content: string;
+            permalink: string | null;
+        }[];
+        files: {
+            id: string;
+            title: string;
+            filetype: string;
+            authorUserId: string;
+            authorName: string;
+            dateCreated: number | null;
+            dateUpdated: number | null;
+            content: string;
+            permalink: string | null;
+        }[];
+        channels: {
+            name: string;
+            topic: string;
+            purpose: string;
+            creatorUserId: string;
+            dateCreated: number | null;
+            permalink: string | null;
+        }[];
+        nextCursor: string | null;
+    } & {
+        receipt: SlackBotReceipt;
+    }>;
     listFiles(input: {
         channelId: string;
         limit?: number;
@@ -464,6 +754,7 @@ export declare class OpenGeniSlackBotClient {
             isMember: boolean;
             isDirectMessage: boolean;
             isMpim: boolean;
+            userId: string | null;
             isArchived: boolean;
             isShared: boolean;
             isExternallyShared: boolean;
@@ -503,6 +794,7 @@ export declare class OpenGeniSlackBotClient {
             isMember: boolean;
             isDirectMessage: boolean;
             isMpim: boolean;
+            userId: string | null;
             isArchived: boolean;
             isShared: boolean;
             isExternallyShared: boolean;
@@ -534,7 +826,51 @@ export declare class OpenGeniSlackBotClient {
         fileId: string;
         parentFileId?: string;
         offset?: number;
-    }): Promise<{
+    }): Promise<({
+        channel: {
+            id: string;
+            name: string;
+            isPrivate: boolean;
+            isMember: boolean;
+            isDirectMessage: boolean;
+            isMpim: boolean;
+            userId: string | null;
+            isArchived: boolean;
+            isShared: boolean;
+            isExternallyShared: boolean;
+            isOrgShared: boolean;
+            isPendingExternallyShared: boolean;
+            contextTeamId: string | null;
+            connectedTeamIds: string[] | null;
+            sharedTeamIds: string[] | null;
+            topic: string;
+            purpose: string;
+            numMembers: number | null;
+        };
+        file: {
+            id: string;
+            name: string;
+            title: string;
+            mimetype: string;
+            filetype: string;
+            mode: string;
+            size: number | null;
+            originatingHuddleId: string;
+            huddleTranscriptFileId: string;
+        };
+        image: Readonly<{
+            fileId: string;
+            filename: string;
+            contentType: "image/png" | "image/jpeg" | "image/webp";
+            bytes: Uint8Array;
+        }>;
+        contentType?: never;
+        offset?: never;
+        content?: never;
+        nextOffset?: never;
+        truncated?: never;
+    } | {
+        image?: never;
         channel: {
             id: string;
             name: string;
@@ -542,6 +878,7 @@ export declare class OpenGeniSlackBotClient {
             isMember: boolean;
             isDirectMessage: boolean;
             isMpim: boolean;
+            userId: string | null;
             isArchived: boolean;
             isShared: boolean;
             isExternallyShared: boolean;
@@ -570,7 +907,7 @@ export declare class OpenGeniSlackBotClient {
         content: string;
         nextOffset: number | null;
         truncated: boolean;
-    } & {
+    }) & {
         receipt: SlackBotReceipt;
     }>;
     /**
@@ -637,15 +974,19 @@ export declare class OpenGeniSlackBotClient {
     private recordAudit;
     private auditMetadata;
 }
+/** Full decode guards the model image block against header-only or corrupt files. */
+export declare function validateSlackMcpImage(bytes: Uint8Array): Promise<void>;
 export declare function createOpenGeniSlackBotClient(deps: {
     db: Database;
     settings: Settings;
     slackFetch?: typeof fetch;
+    authorizeProviderRequest?: SlackProviderAuthorization;
 }, resolved: Awaited<ReturnType<typeof resolveSlackBotConnectionForTool>>): OpenGeniSlackBotClient;
 export declare function createOpenGeniSlackBotInteractionClient(deps: {
     db: Database;
     settings: Settings;
     slackFetch?: typeof fetch;
+    authorizeProviderRequest?: SlackProviderAuthorization;
 }, input: {
     accountId: string;
     workspaceId: string;
@@ -653,6 +994,12 @@ export declare function createOpenGeniSlackBotInteractionClient(deps: {
     subjectId: string;
     sessionId?: string | null;
 }): Promise<OpenGeniSlackBotClient>;
+/** A private route needs live provider proof of the exact linked requester's bot IM. */
+export declare function assertSlackPrivateTaskRecipient(channel: {
+    isDirectMessage: boolean;
+    isMpim: boolean;
+    userId: string | null;
+}, slackUserId: string): void;
 export declare function sniffSlackReactionImageMime(bytes: Uint8Array): "image/png" | "image/jpeg" | "image/webp" | null;
 export declare function resolveSlackFilesListPage(input: {
     channelId: string;
@@ -665,4 +1012,12 @@ export declare function createSlackFilesListCursor(input: {
     page: number;
 }, context: SlackFilesCursorContext): string;
 export declare function nextSlackFilesListPage(payload: SlackPayload, requested: SlackFilesListPage, returnedFileCount: number): number | null;
+/**
+ * Slack action IDs are unique within a block. Keep the logical card untouched
+ * for the durable request digest, and partition repeated actions only on the
+ * provider wire. In particular, a legacy invalid_blocks receipt can retry with
+ * its original operation ID and digest; completed/uncertain posts keep their
+ * existing replay/reconciliation path. Values and action IDs remain exact.
+ */
+export declare function slackMessageWireBlocks(blocks: SlackMessageBlock[] | undefined): SlackMessageBlock[] | undefined;
 export {};

package/dist/integrations/slack-file-upload-flow.d.ts

@@ -0,0 +1,62 @@
+/** Durability port: checkpoints must be lease-fenced before any provider write. */
+export type SlackFileUploadPhase = "pending" | "uploading" | "uploaded" | "completing" | "outcome_unknown" | "completed";
+export type SlackFileUploadState = {
+    phase: SlackFileUploadPhase;
+    slackFileId: string | null;
+};
+export type SlackFileUploadProvider = {
+    allocateFileUpload(input: {
+        channelId: string;
+        privateRecipientSlackUserId?: string;
+        filename: string;
+        sizeBytes: number;
+    }): Promise<{
+        fileId: string;
+        uploadUrl: URL;
+    }>;
+    transferFileUpload(input: {
+        channelId: string;
+        privateRecipientSlackUserId?: string;
+        uploadUrl: URL;
+        bytes: Uint8Array;
+    }): Promise<unknown>;
+    completeFileUpload(input: {
+        channelId: string;
+        privateRecipientSlackUserId?: string;
+        threadTimestamp: string;
+        fileId: string;
+        title: string;
+    }): Promise<unknown>;
+    reconcileFileUpload(input: {
+        channelId: string;
+        privateRecipientSlackUserId?: string;
+        threadTimestamp: string;
+        fileId: string;
+    }): Promise<{
+        shared: boolean;
+    }>;
+};
+export declare class SlackFileUploadClaimLostError extends Error {
+    constructor();
+}
+export declare class SlackFileUploadOutcomeUnknownError extends Error {
+    constructor();
+}
+/** No automatic retries. An uncertain completion is reconciled, never resent. */
+export declare function runSlackFileUpload(input: {
+    state: SlackFileUploadState;
+    provider: SlackFileUploadProvider;
+    checkpoint: (update: {
+        expectedPhase: SlackFileUploadPhase;
+        phase: SlackFileUploadPhase;
+        slackFileId?: string;
+    }) => Promise<boolean>;
+    channelId: string;
+    privateRecipientSlackUserId?: string;
+    threadTimestamp: string;
+    filename: string;
+    bytes: Uint8Array;
+}): Promise<{
+    slackFileId: string;
+    replayed: boolean;
+}>;

package/dist/integrations/slack-install.d.ts

@@ -0,0 +1,20 @@
+import { ExternalActorContinuation } from "@opengeni/contracts/external-identities";
+import { type ApiRouteDeps } from "@opengeni/core";
+export declare function requireOpenGeniSlackOAuthSettings(settings: ApiRouteDeps["settings"]): {
+    clientId: string;
+    clientSecret: string;
+};
+/** Only authenticated route admission may invoke this workspace-bot starter.
+ * Hosted personal Slack MCP deliberately uses its own OAuth profile. */
+export declare function startSlackBotInstall(deps: ApiRouteDeps, input: {
+    accountId: string;
+    workspaceId: string;
+    subjectId: string;
+    requestUrl: string;
+    connectionId?: string;
+    connectAttemptId?: string;
+    externalContinuation?: ExternalActorContinuation;
+}): Promise<{
+    authorizationUrl: string;
+    expiresAt: string;
+}>;