@cuylabs/channel-slack 0.9.0 → 0.10.0

package/dist/index.d.ts

@@ -3,6 +3,10 @@ export { ExtractSlackMessageTextOptions, RawSlackActionTokenPayload, RawSlackApp
 export { S as SlackApprovalRequest, a as SlackEventInteractiveRequestHandler, b as SlackHumanInputRequest, c as SlackInteractiveMessage, d as SlackInteractiveMessageRef, e as SlackInteractiveRequest, f as SlackInteractiveRequestBaseContext, g as SlackInteractiveRequestContext, h as SlackInteractiveRequestHandler, i as SlackInteractiveRequestKind, j as SlackInteractiveResponder } from './interactive-CbKYkkc_.js';
 export { RegisterSlackTurnCancelActionOptions, SLACK_TURN_CANCEL_ACTION_ID, SlackTurnCancelActionContext, SlackTurnCancelActionHandler, SlackTurnCancelButtonValue, SlackTurnCancelMessage, SlackTurnCancelMessageOptions, createSlackTurnCancelMessage, decodeSlackTurnCancelButtonValue, encodeSlackTurnCancelButtonValue, registerSlackTurnCancelAction, resolveSlackTurnCancelActionId } from './turn-controls/index.js';
 export { InMemorySlackThreadParticipationStateStoreOptions, PostgresSlackMessagePolicyPruneResult, PostgresSlackMessagePolicyStateStore, PostgresSlackMessagePolicyStateStoreOptions, PostgresSlackThreadParticipationStateStore, PostgresSlackThreadParticipationStateStoreOptions, SlackAsyncMessagePolicyConfig, SlackAsyncMessagePolicyResolver, SlackChannelMessagePolicy, SlackMentionedThreadState, SlackMessagePolicyAcceptReason, SlackMessagePolicyAcceptedDecision, SlackMessagePolicyConfig, SlackMessagePolicyDecision, SlackMessagePolicyPostgresClient, SlackMessagePolicyRejectReason, SlackMessagePolicyRejectedDecision, SlackMessagePolicyResolver, SlackMessagePolicyStateContext, SlackMessagePolicyStateStore, SlackQuietThreadRejectedDecision, SlackSyncMessagePolicyStateStore, SlackThreadAwareMessagePolicyConfig, SlackThreadAwareMessagePolicyDecision, SlackThreadAwareMessagePolicyResolver, SlackThreadParticipationEligibility, SlackThreadParticipationEligibilityOptions, SlackThreadParticipationMode, SlackThreadParticipationPostgresClient, SlackThreadParticipationPruneResult, SlackThreadParticipationReactivation, SlackThreadParticipationState, SlackThreadParticipationStateContext, SlackThreadParticipationStateStore, SlackThreadReplyPolicy, createAsyncSlackMessagePolicyResolver, createAsyncSlackThreadAwareMessagePolicyResolver, createInMemorySlackMessagePolicyStateStore, createInMemorySlackThreadParticipationStateStore, createPostgresSlackMessagePolicyStateStore, createPostgresSlackThreadParticipationStateStore, createSlackMessagePolicyMessageKey, createSlackMessagePolicyResolver, createSlackMessagePolicyThreadKey, initializePostgresSlackMessagePolicyState, initializePostgresSlackThreadParticipationState, prunePostgresSlackMessagePolicyState, prunePostgresSlackThreadParticipationState, resolveSlackThreadParticipationEligibility, shouldRegisterSlackPassiveChannelMessages } from './policy/index.js';
+export { SlackEventBridgeOptions, SlackFinalResponseArtifactContext, SlackFinalResponseArtifactDeliveryMode, SlackFinalResponseArtifactPublisher, SlackFinalResponseArtifactResult, SlackTurnApprovalRequestEvent, SlackTurnApprovalResolvedEvent, SlackTurnCompleteEvent, SlackTurnErrorEvent, SlackTurnEvent, SlackTurnEventBase, SlackTurnHumanInputRequestEvent, SlackTurnHumanInputResolvedEvent, SlackTurnReasoningEndEvent, SlackTurnReasoningStartEvent, SlackTurnSource, SlackTurnSourceChatOptions, SlackTurnStatus, SlackTurnStatusEvent, SlackTurnSubagentCompleteEvent, SlackTurnSubagentErrorEvent, SlackTurnSubagentEventBase, SlackTurnSubagentEventEvent, SlackTurnSubagentStartEvent, SlackTurnTextDeltaEvent, SlackTurnTextEndEvent, SlackTurnTextStartEvent, SlackTurnToolErrorEvent, SlackTurnToolResultEvent, SlackTurnToolStartEvent, UnsupportedSlackInteractiveRequestError, bridgeSlackTurnEventsToSlack, resolveSlackEventBridgeOptions } from './runtime/index.js';
 export { L as Logger } from './logging-Bl3HfcC8.js';
 import '@slack/types';
 import '@slack/bolt';
+import './types-C8nkPuD4.js';
+import './types-Cywfj8Mj.js';
+import './responses/index.js';

package/dist/index.js

@@ -15,6 +15,11 @@ import {
   resolveSlackThreadParticipationEligibility,
   shouldRegisterSlackPassiveChannelMessages
 } from "./chunk-DNVSH7H5.js";
+import {
+  UnsupportedSlackInteractiveRequestError,
+  bridgeSlackTurnEventsToSlack,
+  resolveSlackEventBridgeOptions
+} from "./chunk-IAQXQESO.js";
 import {
   currentSlackTurnContext,
   formatSlackAttributedFollowUp,
@@ -50,6 +55,8 @@ import {
 } from "./chunk-FPCE5V5Y.js";
 export {
   SLACK_TURN_CANCEL_ACTION_ID,
+  UnsupportedSlackInteractiveRequestError,
+  bridgeSlackTurnEventsToSlack,
   createAsyncSlackMessagePolicyResolver,
   createAsyncSlackThreadAwareMessagePolicyResolver,
   createInMemorySlackMessagePolicyStateStore,
@@ -80,6 +87,7 @@ export {
   prunePostgresSlackThreadParticipationState,
   registerSlackTurnCancelAction,
   resolveSlackChannelType,
+  resolveSlackEventBridgeOptions,
   resolveSlackMessageFormatter,
   resolveSlackThreadParticipationEligibility,
   resolveSlackTurnCancelActionId,

package/dist/interactive/index.d.ts

@@ -1,96 +1,9 @@
-import { g as SlackInteractiveRequestContext } from '../interactive-CbKYkkc_.js';
-export { c as SlackInteractiveMessage, d as SlackInteractiveMessageRef, f as SlackInteractiveRequestBaseContext, i as SlackInteractiveRequestKind, j as SlackInteractiveResponder } from '../interactive-CbKYkkc_.js';
+import { c as SlackInteractiveApprovalRequest, S as SlackInteractiveActionIds, e as SlackInteractiveHumanInputRequest, l as SlackInteractiveResolution, i as SlackInteractiveRequestRecord, k as SlackInteractiveRequestStore } from '../types-Cywfj8Mj.js';
+export { a as SlackInteractiveActor, b as SlackInteractiveApprovalAction, d as SlackInteractiveHumanInputOption, f as SlackInteractiveHumanInputResponse, g as SlackInteractiveMessageTarget, h as SlackInteractiveRequestHandler, j as SlackInteractiveRequestStatus, m as SlackInteractiveStoredRequest } from '../types-Cywfj8Mj.js';
 import { View } from '@slack/types';
+export { c as SlackInteractiveMessage, d as SlackInteractiveMessageRef, f as SlackInteractiveRequestBaseContext, g as SlackInteractiveRequestContext, i as SlackInteractiveRequestKind, j as SlackInteractiveResponder } from '../interactive-CbKYkkc_.js';
 import '../activity-ByrD9Ftr.js';
 
-type SlackInteractiveRequestStatus = "pending" | "resolved";
-type SlackInteractiveApprovalAction = "allow" | "deny" | "remember";
-type SlackInteractiveHumanInputResponse = {
-    kind: "text";
-    text: string;
-} | {
-    kind: "confirm";
-    confirmed: boolean;
-    text: string;
-} | {
-    kind: "choice";
-    selected: string[];
-    text: string;
-};
-interface SlackInteractiveApprovalRequest {
-    id: string;
-    tool: string;
-    args: unknown;
-    description: string;
-    risk: string;
-    rememberScopes?: string[];
-    defaultRememberScope?: string;
-}
-interface SlackInteractiveHumanInputOption {
-    label: string;
-    value?: string;
-    description?: string;
-}
-interface SlackInteractiveHumanInputRequest {
-    id: string;
-    kind: "text" | "confirm" | "choice";
-    title: string;
-    question: string;
-    options?: SlackInteractiveHumanInputOption[];
-    allowMultiple?: boolean;
-    placeholder?: string;
-    confirmLabel?: string;
-    denyLabel?: string;
-}
-type SlackInteractiveStoredRequest = SlackInteractiveApprovalRequest | SlackInteractiveHumanInputRequest;
-type SlackInteractiveResolution = {
-    kind: "approval";
-    action: SlackInteractiveApprovalAction;
-    feedback?: string;
-    rememberScope?: string;
-} | {
-    kind: "human-input";
-    response: SlackInteractiveHumanInputResponse;
-};
-interface SlackInteractiveMessageTarget {
-    channel: string;
-    ts: string;
-    threadTs?: string;
-    userId: string;
-    teamId?: string;
-}
-interface SlackInteractiveRequestRecord {
-    id: string;
-    kind: SlackInteractiveResolution["kind"];
-    request: SlackInteractiveStoredRequest;
-    status: SlackInteractiveRequestStatus;
-    createdAt: string;
-    updatedAt: string;
-    target?: SlackInteractiveMessageTarget;
-    resolution?: SlackInteractiveResolution;
-}
-interface SlackInteractiveRequestStore {
-    get(requestId: string): Promise<SlackInteractiveRequestRecord | undefined>;
-    upsert(record: SlackInteractiveRequestRecord): Promise<SlackInteractiveRequestRecord>;
-    attachTarget(requestId: string, target: SlackInteractiveMessageTarget): Promise<SlackInteractiveRequestRecord | undefined>;
-    resolve(requestId: string, resolution: SlackInteractiveResolution): Promise<SlackInteractiveRequestRecord | undefined>;
-    delete(requestId: string): Promise<void>;
-}
-interface SlackInteractiveActionIds {
-    approvalAllow: string;
-    approvalDeny: string;
-    approvalRemember: string;
-    humanConfirm: string;
-    humanDeny: string;
-    humanOpen: string;
-    humanSubmit: string;
-}
-interface SlackInteractiveActor {
-    userId: string;
-    teamId?: string;
-}
-type SlackInteractiveRequestHandler = (context: SlackInteractiveRequestContext) => boolean | void | Promise<boolean | void>;
-
 declare function buildApprovalRequestMessage(request: SlackInteractiveApprovalRequest, actionIds: SlackInteractiveActionIds): {
     text: string;
     blocks: unknown[];
@@ -151,4 +64,4 @@ declare function prunePostgresSlackInteractiveRequestStore({ client, pruneBatchS
     tableName?: string;
 }): Promise<PostgresSlackInteractiveRequestPruneResult>;
 
-export { type PostgresSlackInteractiveRequestPruneResult, type PostgresSlackInteractiveRequestStore, type PostgresSlackInteractiveRequestStoreOptions, type SlackInteractiveActionIds, type SlackInteractiveActor, type SlackInteractiveApprovalAction, type SlackInteractiveApprovalRequest, type SlackInteractiveHumanInputOption, type SlackInteractiveHumanInputRequest, type SlackInteractiveHumanInputResponse, type SlackInteractiveMessageTarget, type SlackInteractivePostgresClient, SlackInteractiveRequestContext, type SlackInteractiveRequestHandler, type SlackInteractiveRequestRecord, type SlackInteractiveRequestStatus, type SlackInteractiveRequestStore, type SlackInteractiveResolution, type SlackInteractiveStoredRequest, buildApprovalRequestMessage, buildHumanInputModal, buildHumanInputRequestMessage, buildResolvedMessage, cloneRecord, createInMemorySlackInteractiveRequestStore, createPostgresSlackInteractiveRequestStore, decodeActionValue, encodeActionValue, initializePostgresSlackInteractiveRequestStore, nowIso, prunePostgresSlackInteractiveRequestStore };
+export { type PostgresSlackInteractiveRequestPruneResult, type PostgresSlackInteractiveRequestStore, type PostgresSlackInteractiveRequestStoreOptions, SlackInteractiveActionIds, SlackInteractiveApprovalRequest, SlackInteractiveHumanInputRequest, type SlackInteractivePostgresClient, SlackInteractiveRequestRecord, SlackInteractiveRequestStore, SlackInteractiveResolution, buildApprovalRequestMessage, buildHumanInputModal, buildHumanInputRequestMessage, buildResolvedMessage, cloneRecord, createInMemorySlackInteractiveRequestStore, createPostgresSlackInteractiveRequestStore, decodeActionValue, encodeActionValue, initializePostgresSlackInteractiveRequestStore, nowIso, prunePostgresSlackInteractiveRequestStore };

package/dist/runtime/index.d.ts

@@ -0,0 +1,260 @@
+import { d as SlackArtifactClient, g as SlackArtifactPublication } from '../types-C8nkPuD4.js';
+import { c as SlackInteractiveApprovalRequest, e as SlackInteractiveHumanInputRequest } from '../types-Cywfj8Mj.js';
+import { a as SlackEventInteractiveRequestHandler } from '../interactive-CbKYkkc_.js';
+import { SlackResponseSink } from '../responses/index.js';
+import '../activity-ByrD9Ftr.js';
+
+interface SlackTurnSourceChatOptions {
+    abort?: AbortSignal;
+    system?: string;
+}
+interface SlackTurnSource {
+    chat(sessionId: string, message: string, options?: SlackTurnSourceChatOptions): AsyncGenerator<SlackTurnEvent>;
+}
+interface SlackFinalResponseArtifactContext {
+    text: string;
+    formattedText: string;
+    client: SlackArtifactClient;
+    channelId: string;
+    threadTs?: string;
+}
+interface SlackFinalResponseArtifactResult {
+    publication: SlackArtifactPublication;
+}
+type SlackFinalResponseArtifactDeliveryMode = "supplemental" | "replace";
+type SlackFinalResponseArtifactPublisher = (context: SlackFinalResponseArtifactContext) => Promise<SlackFinalResponseArtifactResult | undefined>;
+type SlackTurnStatus = "thinking" | "reasoning" | "calling-tool" | "waiting-approval" | "waiting-input" | "processing" | "error" | string;
+interface SlackTurnEventBase {
+    type: string;
+    [key: string]: unknown;
+}
+interface SlackTurnTextStartEvent extends SlackTurnEventBase {
+    type: "text-start";
+}
+interface SlackTurnTextDeltaEvent extends SlackTurnEventBase {
+    type: "text-delta";
+    text: string;
+}
+interface SlackTurnTextEndEvent extends SlackTurnEventBase {
+    type: "text-end";
+}
+interface SlackTurnReasoningStartEvent extends SlackTurnEventBase {
+    type: "reasoning-start";
+}
+interface SlackTurnReasoningEndEvent extends SlackTurnEventBase {
+    type: "reasoning-end";
+}
+interface SlackTurnToolStartEvent extends SlackTurnEventBase {
+    type: "tool-start";
+    toolCallId: string;
+    toolName: string;
+    input?: unknown;
+}
+interface SlackTurnToolResultEvent extends SlackTurnEventBase {
+    type: "tool-result";
+    toolCallId: string;
+    toolName: string;
+    result?: unknown;
+}
+interface SlackTurnToolErrorEvent extends SlackTurnEventBase {
+    type: "tool-error";
+    toolCallId: string;
+    toolName: string;
+    error: string;
+}
+interface SlackTurnSubagentEventBase extends SlackTurnEventBase {
+    dispatchId: string;
+    role: string;
+    title?: string;
+    parentDispatchId?: string;
+    agentPath?: string;
+    depth?: number;
+}
+interface SlackTurnSubagentStartEvent extends SlackTurnSubagentEventBase {
+    type: "subagent-start";
+}
+interface SlackTurnSubagentEventEvent extends SlackTurnSubagentEventBase {
+    type: "subagent-event";
+    event: SlackTurnEvent;
+}
+interface SlackTurnSubagentCompleteEvent extends SlackTurnSubagentEventBase {
+    type: "subagent-complete";
+    output?: unknown;
+}
+interface SlackTurnSubagentErrorEvent extends SlackTurnSubagentEventBase {
+    type: "subagent-error";
+    error: string;
+}
+interface SlackTurnStatusEvent extends SlackTurnEventBase {
+    type: "status";
+    status: SlackTurnStatus;
+}
+interface SlackTurnCompleteEvent extends SlackTurnEventBase {
+    type: "complete";
+    output?: string;
+}
+interface SlackTurnErrorEvent extends SlackTurnEventBase {
+    type: "error";
+    error: unknown;
+}
+interface SlackTurnApprovalRequestEvent extends SlackTurnEventBase {
+    type: "approval-request";
+    request: SlackInteractiveApprovalRequest;
+}
+interface SlackTurnApprovalResolvedEvent extends SlackTurnEventBase {
+    type: "approval-resolved";
+}
+interface SlackTurnHumanInputRequestEvent extends SlackTurnEventBase {
+    type: "human-input-request";
+    request: SlackInteractiveHumanInputRequest;
+}
+interface SlackTurnHumanInputResolvedEvent extends SlackTurnEventBase {
+    type: "human-input-resolved";
+}
+type SlackTurnEvent = SlackTurnTextStartEvent | SlackTurnTextDeltaEvent | SlackTurnTextEndEvent | SlackTurnReasoningStartEvent | SlackTurnReasoningEndEvent | SlackTurnToolStartEvent | SlackTurnToolResultEvent | SlackTurnToolErrorEvent | SlackTurnSubagentStartEvent | SlackTurnSubagentEventEvent | SlackTurnSubagentCompleteEvent | SlackTurnSubagentErrorEvent | SlackTurnStatusEvent | SlackTurnCompleteEvent | SlackTurnErrorEvent | SlackTurnApprovalRequestEvent | SlackTurnApprovalResolvedEvent | SlackTurnHumanInputRequestEvent | SlackTurnHumanInputResolvedEvent;
+
+/**
+ * Event-bridge configuration. The bridge is mode-aware (progressive,
+ * accumulate, chat-stream) and these options control formatting, status
+ * propagation, interactive-request handling, and chat-stream finalization.
+ */
+
+type ApprovalRequest = SlackTurnApprovalRequestEvent["request"];
+type HumanInputRequest = SlackTurnHumanInputRequestEvent["request"];
+interface SlackEventBridgeOptions {
+    showReasoning: boolean;
+    /** Render root-agent tool rows/status updates. */
+    showToolUsage: boolean;
+    /** Render subagent child tool rows in the parent Slack task timeline. */
+    showSubagentToolUsage: boolean;
+    /** Include full subagent completion output in the subagent task row. */
+    showSubagentResultInTask: boolean;
+    formatToolTitle?: (toolName: string) => string;
+    formatToolUpdate: (toolName: string) => string;
+    formatToolDetails?: (event: SlackTurnToolStartEvent) => string | undefined;
+    /**
+     * Format the completed tool output shown in Slack task rows.
+     *
+     * Return `undefined` to use the default generic formatter. Return `null` to
+     * intentionally omit task-row output for this tool result.
+     */
+    formatToolResultOutput?: (event: SlackTurnToolResultEvent) => string | null | undefined;
+    formatToolError: (toolName: string, error: string) => string;
+    formatReasoningUpdate: () => string;
+    formatMessageText: (text: string) => string;
+    streamingMode: "progressive" | "accumulate" | "chat-stream";
+    progressiveUpdateThreshold: number;
+    progressiveUpdateIntervalMs: number;
+    chatStreamBufferSize: number;
+    /**
+     * Maximum number of Slack task-update chunks the bridge will append to a
+     * single chat stream. Task rows are a bounded UI projection, not a durable
+     * event log.
+     */
+    maxTaskUpdates: number;
+    /**
+     * Maximum cumulative characters from task titles/details/output that the
+     * bridge will append to one chat stream.
+     */
+    maxTaskUpdateTextChars: number;
+    /**
+     * Maximum characters for a single task details/output field.
+     */
+    maxTaskUpdateFieldChars: number;
+    interactiveMode: "message-and-error" | "ignore";
+    handleInteractiveRequest?: SlackEventInteractiveRequestHandler;
+    formatApprovalRequired: (request: ApprovalRequest) => string;
+    formatHumanInputRequired: (request: HumanInputRequest) => string;
+    /**
+     * Optional hook called whenever the bridge's status label changes — used by
+     * the assistant bridge to update the assistant pane's status line via
+     * `assistant.threads.setStatus`. Errors are swallowed by the caller.
+     */
+    onStatusChange?: (label: string, event: SlackTurnEvent | undefined) => void | Promise<void>;
+    /**
+     * Optional final-args passthrough for `chatStream.stop(...)`. When the
+     * bridge stops the chat stream on `complete`, these args (e.g. final
+     * `blocks` for a feedback widget) are merged into the `stop` call. The
+     * existing `markdown_text` final-text fallback always wins on text fields.
+     */
+    chatStreamFinalArgs?: {
+        blocks?: unknown[];
+    } & Record<string, unknown>;
+    /**
+     * Optional post-processing hook for publishing a rich artifact from the final
+     * accumulated response, such as a Slack Canvas for long answers.
+     */
+    publishFinalResponseArtifact?: SlackFinalResponseArtifactPublisher;
+    /**
+     * Controls whether artifact publication is additive or becomes the primary
+     * final-answer surface.
+     *
+     * - `supplemental`: finalize the Slack text normally, then publish artifact.
+     * - `replace`: publish artifact first and use a compact Slack final message.
+     *
+     * @default "supplemental"
+     */
+    finalResponseArtifactMode?: SlackFinalResponseArtifactDeliveryMode;
+    /**
+     * When replacement mode is active, continue streaming text up to this many
+     * raw characters, then suppress further text deltas and publish the full
+     * answer as an artifact at completion. This preserves normal short-answer
+     * streaming without flooding Slack for long answers.
+     *
+     * @default 4000
+     */
+    finalResponseArtifactStreamThreshold?: number;
+    /**
+     * Notice appended when replacement mode suppresses the remaining text stream.
+     */
+    formatFinalResponseArtifactContinuationNotice?: (context: Pick<SlackFinalResponseArtifactContext, "text" | "formattedText">) => string;
+    /**
+     * Final compact message used when an artifact replaces the full Slack text.
+     */
+    formatFinalResponseArtifactMessage?: (result: SlackFinalResponseArtifactResult, context: SlackFinalResponseArtifactContext) => string;
+    /**
+     * Called when `publishFinalResponseArtifact` throws. Errors from this hook
+     * are swallowed so artifact publication cannot break a completed turn.
+     */
+    onFinalResponseArtifactError?: (error: unknown, context: SlackFinalResponseArtifactContext) => void | Promise<void>;
+}
+declare function resolveSlackEventBridgeOptions(partial: Partial<SlackEventBridgeOptions>): SlackEventBridgeOptions;
+
+/**
+ * Event bridge — maps a runtime-neutral `SlackTurnEvent` stream to a Slack
+ * conversation via a `SlackResponseSink`.
+ *
+ * | Mode           | Behaviour                                              |
+ * |----------------|--------------------------------------------------------|
+ * | `progressive`  | Posts a placeholder, updates it as text accumulates.   |
+ * | `accumulate`   | Collects the full response then posts it in one shot.  |
+ * | `chat-stream`  | Uses Slack's native `chat.startStream` + append + stop |
+ *
+ * The three modes share enough state (full-response accumulator, status
+ * label, last-update offset) that they live in one function. Per-mode
+ * branches are clearly labelled inside the event loop.
+ */
+
+/**
+ * Stream runtime-neutral turn events to a Slack conversation via
+ * `SlackResponseSink`.
+ *
+ * @returns The full accumulated response text.
+ */
+declare function bridgeSlackTurnEventsToSlack(events: AsyncGenerator<SlackTurnEvent>, sink: SlackResponseSink, options: SlackEventBridgeOptions): Promise<string>;
+
+/**
+ * Interactive-request error type raised when an `approval-request` or
+ * `human-input-request` event reaches the Slack transport in a mode that
+ * does not support in-channel resolution.
+ *
+ * Hosts can catch this error to fall back to message-and-error mode, or install
+ * `createSlackInteractiveController` to render and resolve requests in Slack.
+ */
+declare class UnsupportedSlackInteractiveRequestError extends Error {
+    readonly kind: "approval" | "human-input";
+    readonly requestId: string;
+    constructor(kind: "approval" | "human-input", requestId: string, message: string);
+}
+
+export { type SlackEventBridgeOptions, type SlackFinalResponseArtifactContext, type SlackFinalResponseArtifactDeliveryMode, type SlackFinalResponseArtifactPublisher, type SlackFinalResponseArtifactResult, type SlackTurnApprovalRequestEvent, type SlackTurnApprovalResolvedEvent, type SlackTurnCompleteEvent, type SlackTurnErrorEvent, type SlackTurnEvent, type SlackTurnEventBase, type SlackTurnHumanInputRequestEvent, type SlackTurnHumanInputResolvedEvent, type SlackTurnReasoningEndEvent, type SlackTurnReasoningStartEvent, type SlackTurnSource, type SlackTurnSourceChatOptions, type SlackTurnStatus, type SlackTurnStatusEvent, type SlackTurnSubagentCompleteEvent, type SlackTurnSubagentErrorEvent, type SlackTurnSubagentEventBase, type SlackTurnSubagentEventEvent, type SlackTurnSubagentStartEvent, type SlackTurnTextDeltaEvent, type SlackTurnTextEndEvent, type SlackTurnTextStartEvent, type SlackTurnToolErrorEvent, type SlackTurnToolResultEvent, type SlackTurnToolStartEvent, UnsupportedSlackInteractiveRequestError, bridgeSlackTurnEventsToSlack, resolveSlackEventBridgeOptions };

package/dist/runtime/index.js

@@ -0,0 +1,10 @@
+import {
+  UnsupportedSlackInteractiveRequestError,
+  bridgeSlackTurnEventsToSlack,
+  resolveSlackEventBridgeOptions
+} from "../chunk-IAQXQESO.js";
+export {
+  UnsupportedSlackInteractiveRequestError,
+  bridgeSlackTurnEventsToSlack,
+  resolveSlackEventBridgeOptions
+};

package/dist/types-Cywfj8Mj.d.ts

@@ -0,0 +1,91 @@
+import { g as SlackInteractiveRequestContext } from './interactive-CbKYkkc_.js';
+
+type SlackInteractiveRequestStatus = "pending" | "resolved";
+type SlackInteractiveApprovalAction = "allow" | "deny" | "remember";
+type SlackInteractiveHumanInputResponse = {
+    kind: "text";
+    text: string;
+} | {
+    kind: "confirm";
+    confirmed: boolean;
+    text: string;
+} | {
+    kind: "choice";
+    selected: string[];
+    text: string;
+};
+interface SlackInteractiveApprovalRequest {
+    id: string;
+    tool: string;
+    args: unknown;
+    description: string;
+    risk: string;
+    rememberScopes?: string[];
+    defaultRememberScope?: string;
+}
+interface SlackInteractiveHumanInputOption {
+    label: string;
+    value?: string;
+    description?: string;
+}
+interface SlackInteractiveHumanInputRequest {
+    id: string;
+    kind: "text" | "confirm" | "choice";
+    title: string;
+    question: string;
+    options?: SlackInteractiveHumanInputOption[];
+    allowMultiple?: boolean;
+    placeholder?: string;
+    confirmLabel?: string;
+    denyLabel?: string;
+}
+type SlackInteractiveStoredRequest = SlackInteractiveApprovalRequest | SlackInteractiveHumanInputRequest;
+type SlackInteractiveResolution = {
+    kind: "approval";
+    action: SlackInteractiveApprovalAction;
+    feedback?: string;
+    rememberScope?: string;
+} | {
+    kind: "human-input";
+    response: SlackInteractiveHumanInputResponse;
+};
+interface SlackInteractiveMessageTarget {
+    channel: string;
+    ts: string;
+    threadTs?: string;
+    userId: string;
+    teamId?: string;
+}
+interface SlackInteractiveRequestRecord {
+    id: string;
+    kind: SlackInteractiveResolution["kind"];
+    request: SlackInteractiveStoredRequest;
+    status: SlackInteractiveRequestStatus;
+    createdAt: string;
+    updatedAt: string;
+    target?: SlackInteractiveMessageTarget;
+    resolution?: SlackInteractiveResolution;
+}
+interface SlackInteractiveRequestStore {
+    get(requestId: string): Promise<SlackInteractiveRequestRecord | undefined>;
+    upsert(record: SlackInteractiveRequestRecord): Promise<SlackInteractiveRequestRecord>;
+    attachTarget(requestId: string, target: SlackInteractiveMessageTarget): Promise<SlackInteractiveRequestRecord | undefined>;
+    resolve(requestId: string, resolution: SlackInteractiveResolution): Promise<SlackInteractiveRequestRecord | undefined>;
+    delete(requestId: string): Promise<void>;
+}
+interface SlackInteractiveActionIds {
+    approvalAllow: string;
+    approvalDeny: string;
+    approvalRemember: string;
+    humanConfirm: string;
+    humanDeny: string;
+    humanOpen: string;
+    humanSubmit: string;
+}
+interface SlackInteractiveActor {
+    userId: string;
+    teamId?: string;
+}
+type SlackInteractiveRequestHandler = (context: SlackInteractiveRequestContext) => boolean | void | Promise<boolean | void>;
+
+export type { SlackInteractiveActionIds as S, SlackInteractiveActor as a, SlackInteractiveApprovalAction as b, SlackInteractiveApprovalRequest as c, SlackInteractiveHumanInputOption as d, SlackInteractiveHumanInputRequest as e, SlackInteractiveHumanInputResponse as f, SlackInteractiveMessageTarget as g, SlackInteractiveRequestHandler as h, SlackInteractiveRequestRecord as i, SlackInteractiveRequestStatus as j, SlackInteractiveRequestStore as k, SlackInteractiveResolution as l, SlackInteractiveStoredRequest as m };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cuylabs/channel-slack",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Agent-runtime-agnostic Slack channel primitives for AI agents",
   "type": "module",
   "main": "./dist/index.js",
@@ -71,6 +71,11 @@
       "import": "./dist/responses/index.js",
       "default": "./dist/responses/index.js"
     },
+    "./runtime": {
+      "types": "./dist/runtime/index.d.ts",
+      "import": "./dist/runtime/index.js",
+      "default": "./dist/runtime/index.js"
+    },
     "./setup": {
       "types": "./dist/setup/index.d.ts",
       "import": "./dist/setup/index.js",
@@ -163,9 +168,9 @@
     "node": ">=20"
   },
   "scripts": {
-    "build": "tsup src/index.ts src/app-home.ts src/artifacts/index.ts src/core.ts src/assistant/index.ts src/auth/index.ts src/diagnostics/index.ts src/entrypoints/index.ts src/feedback/index.ts src/history/index.ts src/interactive/index.ts src/policy/index.ts src/responses/index.ts src/setup/index.ts src/targets/index.ts src/turn-controls/index.ts src/transports/index.ts src/transports/http/index.ts src/transports/socket/index.ts src/users/index.ts src/views/index.ts --format esm --dts --clean",
+    "build": "tsup src/index.ts src/app-home.ts src/artifacts/index.ts src/core.ts src/assistant/index.ts src/auth/index.ts src/diagnostics/index.ts src/entrypoints/index.ts src/feedback/index.ts src/history/index.ts src/interactive/index.ts src/policy/index.ts src/responses/index.ts src/runtime/index.ts src/setup/index.ts src/targets/index.ts src/turn-controls/index.ts src/transports/index.ts src/transports/http/index.ts src/transports/socket/index.ts src/users/index.ts src/views/index.ts --format esm --dts --clean",
     "clean": "rm -rf dist",
-    "dev": "tsup src/index.ts src/app-home.ts src/artifacts/index.ts src/core.ts src/assistant/index.ts src/auth/index.ts src/diagnostics/index.ts src/entrypoints/index.ts src/feedback/index.ts src/history/index.ts src/interactive/index.ts src/policy/index.ts src/responses/index.ts src/setup/index.ts src/targets/index.ts src/turn-controls/index.ts src/transports/index.ts src/transports/http/index.ts src/transports/socket/index.ts src/users/index.ts src/views/index.ts --format esm --dts --watch",
+    "dev": "tsup src/index.ts src/app-home.ts src/artifacts/index.ts src/core.ts src/assistant/index.ts src/auth/index.ts src/diagnostics/index.ts src/entrypoints/index.ts src/feedback/index.ts src/history/index.ts src/interactive/index.ts src/policy/index.ts src/responses/index.ts src/runtime/index.ts src/setup/index.ts src/targets/index.ts src/turn-controls/index.ts src/transports/index.ts src/transports/http/index.ts src/transports/socket/index.ts src/users/index.ts src/views/index.ts --format esm --dts --watch",
     "lint": "eslint \"src/**/*.{ts,tsx}\" \"tests/**/*.{ts,tsx}\" --max-warnings=0",
     "test": "vitest run",
     "test:watch": "vitest",