@cuylabs/channel-slack-agent-core 0.9.0 → 0.11.0

package/README.md

@@ -3,12 +3,12 @@
 Slack adapter for `@cuylabs/agent-core`, built on
 `@cuylabs/channel-slack`.
 
-Use this package when an Agent Core application needs ready-to-mount Slack
-surfaces for Express Events API, Socket Mode, Slack Assistant, app mentions,
-DMs, feedback, approvals, or human input.
+Use this package when an Agent Core application needs Agent Core-specific Slack
+bindings: event mapping, source adaptation, context fragments, history helpers,
+MCP token bridging, or approval/human-input controller binding.
 
-Generic Slack mechanics such as parsing, policy, history, setup, auth, targets,
-users, entrypoints, artifacts, interactive stores/builders, response sinks, and
+Generic Slack mechanics, mounts, Assistant rendering, classic message routing,
+feedback, artifacts, interactive stores/builders, response sinks, and
 transports live in `@cuylabs/channel-slack`.
 
 ## Install
@@ -33,10 +33,11 @@ without injecting its own client.
 Socket Mode:
 
 ```typescript
-import { mountSlackAssistantAgentSocket } from "@cuylabs/channel-slack-agent-core";
+import { mountSlackAppSocket } from "@cuylabs/channel-slack/socket";
+import { adaptAgentTurnSourceToSlackTurnSource } from "@cuylabs/channel-slack-agent-core";
 
-await mountSlackAssistantAgentSocket({
-  source: agent,
+await mountSlackAppSocket({
+  source: adaptAgentTurnSourceToSlackTurnSource(agent),
   appToken: process.env.SLACK_APP_TOKEN,
   botToken: process.env.SLACK_BOT_TOKEN,
 });
@@ -45,9 +46,11 @@ await mountSlackAssistantAgentSocket({
 Express Events API:
 
 ```typescript
-import { mountSlackAgent } from "@cuylabs/channel-slack-agent-core";
+import { mountSlackApp } from "@cuylabs/channel-slack/app";
+import { adaptAgentTurnSourceToSlackTurnSource } from "@cuylabs/channel-slack-agent-core";
 
-await mountSlackAgent(agent, {
+await mountSlackApp({
+  source: adaptAgentTurnSourceToSlackTurnSource(agent),
   botToken: process.env.SLACK_BOT_TOKEN,
   signingSecret: process.env.SLACK_SIGNING_SECRET,
 });

package/dist/chunk-U6RC4SXN.js

@@ -0,0 +1,331 @@
+// src/shared/context-fragments.ts
+import {
+  currentSlackTurnContext
+} from "@cuylabs/channel-slack/core";
+var DEFAULT_SLACK_CONTEXT_FRAGMENT_KEY = "slackContextFragment";
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isPayload(value) {
+  return isRecord(value) && typeof value.content === "string";
+}
+function resolveContextBagValue(slack, key) {
+  const value = slack.context?.[key];
+  if (typeof value === "string") {
+    return value;
+  }
+  if (isPayload(value)) {
+    return value;
+  }
+  return void 0;
+}
+function resolveDedupeKey(options, context) {
+  return typeof options.dedupeKey === "function" ? options.dedupeKey(context) : options.dedupeKey;
+}
+function resolveMetadata(options, context) {
+  return typeof options.metadata === "function" ? options.metadata(context) : options.metadata;
+}
+function normalizeFragment(resolved, options, context) {
+  const payload = typeof resolved === "string" ? { content: resolved } : isPayload(resolved) ? resolved : void 0;
+  if (!payload) {
+    return resolved;
+  }
+  if (payload.content.trim().length === 0) {
+    return void 0;
+  }
+  const dedupeKey = payload.dedupeKey ?? resolveDedupeKey(options, context);
+  const metadata = payload.metadata ?? resolveMetadata(options, context);
+  const maxChars = payload.maxChars ?? options.maxChars;
+  return {
+    kind: payload.kind ?? options.kind ?? "slack-context",
+    content: payload.content,
+    role: payload.role ?? options.role ?? "user",
+    placement: payload.placement ?? options.placement ?? "after-latest-user",
+    lifetime: payload.lifetime ?? options.lifetime ?? "turn",
+    source: payload.source ?? options.source ?? "slack",
+    title: payload.title ?? options.title ?? "Slack Context",
+    budgetBehavior: payload.budgetBehavior ?? options.budgetBehavior ?? "droppable",
+    ...maxChars !== void 0 ? { maxChars } : {},
+    ...dedupeKey ? { dedupeKey } : {},
+    ...metadata ? { metadata } : {}
+  };
+}
+function createSlackContextFragmentMiddleware(options = {}) {
+  const contextKey = options.contextKey ?? DEFAULT_SLACK_CONTEXT_FRAGMENT_KEY;
+  return {
+    name: options.name ?? "slack-context-fragment",
+    async contextFragments(step) {
+      const slack = currentSlackTurnContext();
+      if (!slack) {
+        return void 0;
+      }
+      const context = { slack, step };
+      const resolved = options.resolve ? await options.resolve(context) : resolveContextBagValue(slack, contextKey);
+      if (resolved === void 0) {
+        return void 0;
+      }
+      return normalizeFragment(resolved, options, context);
+    }
+  };
+}
+
+// src/shared/event-bridge/agent-event-mapper.ts
+function mapAgentEventToSlackTurnEvent(event) {
+  switch (event.type) {
+    case "text-start":
+    case "text-delta":
+    case "text-end":
+    case "reasoning-start":
+    case "reasoning-end":
+    case "tool-start":
+    case "tool-result":
+    case "tool-error":
+    case "subagent-start":
+    case "subagent-complete":
+    case "subagent-error":
+    case "status":
+    case "complete":
+    case "error":
+    case "approval-request":
+    case "approval-resolved":
+    case "human-input-request":
+    case "human-input-resolved":
+      return { ...event };
+    case "subagent-event":
+      return {
+        ...event,
+        event: mapAgentEventToSlackTurnEvent(event.event)
+      };
+    case "reasoning-delta":
+    case "step-start":
+    case "step-finish":
+    case "turn-boundary":
+    case "message":
+    case "computer-call":
+    case "computer-result":
+    case "intervention-applied":
+    case "follow-up-queued":
+    case "doom-loop":
+    case "context-overflow":
+    case "context-compaction":
+    case "turn-summary":
+    case "retry":
+      return mapIgnoredAgentEvent(event);
+    default:
+      return mapIgnoredAgentEvent(event);
+  }
+}
+function mapIgnoredAgentEvent(event) {
+  return { ...event };
+}
+
+// src/shared/event-bridge/options-adapter.ts
+function mapAgentSlackEventBridgeOptionsToRuntimeOptions(options) {
+  return {
+    showReasoning: options.showReasoning,
+    showToolUsage: options.showToolUsage,
+    showSubagentToolUsage: options.showSubagentToolUsage,
+    showSubagentResultInTask: options.showSubagentResultInTask,
+    ...options.formatToolTitle ? { formatToolTitle: options.formatToolTitle } : {},
+    formatToolUpdate: options.formatToolUpdate,
+    ...options.formatToolDetails ? {
+      formatToolDetails: (event) => options.formatToolDetails?.(
+        event
+      )
+    } : {},
+    ...options.formatToolResultOutput ? {
+      formatToolResultOutput: (event) => options.formatToolResultOutput?.(
+        event
+      )
+    } : {},
+    formatToolError: options.formatToolError,
+    formatReasoningUpdate: options.formatReasoningUpdate,
+    formatMessageText: options.formatMessageText,
+    streamingMode: options.streamingMode,
+    progressiveUpdateThreshold: options.progressiveUpdateThreshold,
+    progressiveUpdateIntervalMs: options.progressiveUpdateIntervalMs,
+    chatStreamBufferSize: options.chatStreamBufferSize,
+    maxTaskUpdates: options.maxTaskUpdates,
+    maxTaskUpdateTextChars: options.maxTaskUpdateTextChars,
+    maxTaskUpdateFieldChars: options.maxTaskUpdateFieldChars,
+    interactiveMode: options.interactiveMode,
+    ...options.handleInteractiveRequest ? {
+      handleInteractiveRequest: (context) => options.handleInteractiveRequest?.(
+        context
+      )
+    } : {},
+    formatApprovalRequired: (request) => options.formatApprovalRequired(request),
+    formatHumanInputRequired: (request) => options.formatHumanInputRequired(request),
+    ...options.onStatusChange ? {
+      onStatusChange: (label, event) => options.onStatusChange?.(
+        label,
+        event
+      )
+    } : {},
+    ...options.chatStreamFinalArgs ? { chatStreamFinalArgs: options.chatStreamFinalArgs } : {},
+    ...options.publishFinalResponseArtifact ? { publishFinalResponseArtifact: options.publishFinalResponseArtifact } : {},
+    ...options.finalResponseArtifactMode ? { finalResponseArtifactMode: options.finalResponseArtifactMode } : {},
+    ...options.finalResponseArtifactStreamThreshold ? {
+      finalResponseArtifactStreamThreshold: options.finalResponseArtifactStreamThreshold
+    } : {},
+    ...options.formatFinalResponseArtifactContinuationNotice ? {
+      formatFinalResponseArtifactContinuationNotice: options.formatFinalResponseArtifactContinuationNotice
+    } : {},
+    ...options.formatFinalResponseArtifactMessage ? {
+      formatFinalResponseArtifactMessage: options.formatFinalResponseArtifactMessage
+    } : {},
+    ...options.onFinalResponseArtifactError ? { onFinalResponseArtifactError: options.onFinalResponseArtifactError } : {}
+  };
+}
+
+// src/shared/event-bridge/bridge.ts
+import {
+  bridgeSlackTurnEventsToSlack
+} from "@cuylabs/channel-slack/runtime";
+async function bridgeAgentEventsToSlack(events, sink, options) {
+  return bridgeSlackTurnEventsToSlack(
+    toSlackTurnEvents(events),
+    sink,
+    mapAgentSlackEventBridgeOptionsToRuntimeOptions(options)
+  );
+}
+async function* toSlackTurnEvents(events) {
+  for await (const event of events) {
+    yield mapAgentEventToSlackTurnEvent(event);
+  }
+}
+
+// src/shared/event-bridge/options.ts
+var DEFAULT_OPTIONS = {
+  showReasoning: false,
+  showToolUsage: true,
+  showSubagentToolUsage: false,
+  showSubagentResultInTask: false,
+  formatToolTitle: (toolName) => toolName,
+  formatToolUpdate: (toolName) => `\u{1F50D} Using tool: ${toolName}...`,
+  formatToolError: (toolName, _error) => `\u26A0\uFE0F Tool ${toolName} encountered an error`,
+  formatReasoningUpdate: () => "Thinking...",
+  formatMessageText: (text) => text,
+  streamingMode: "progressive",
+  progressiveUpdateThreshold: 150,
+  progressiveUpdateIntervalMs: 3e3,
+  chatStreamBufferSize: 256,
+  maxTaskUpdates: 200,
+  maxTaskUpdateTextChars: 2e4,
+  maxTaskUpdateFieldChars: 500,
+  interactiveMode: "message-and-error",
+  formatApprovalRequired: (request) => `This turn requires approval for "${request.tool}", but in-channel approval is not configured for this Slack host.`,
+  formatHumanInputRequired: (request) => `This turn is waiting for input: ${request.title}. In-channel human input is not configured for this Slack host.`,
+  finalResponseArtifactMode: "supplemental",
+  finalResponseArtifactStreamThreshold: 4e3,
+  formatFinalResponseArtifactContinuationNotice: () => "\n\nFull response is long. I will publish the complete answer as a Slack artifact when it finishes.",
+  formatFinalResponseArtifactMessage: (result) => {
+    const title = result.publication.artifact.title.trim() || "Agent response";
+    if (result.publication.method === "canvas") {
+      return `I created a Slack Canvas for the full response: ${title}`;
+    }
+    if (result.publication.method === "file") {
+      return `I uploaded the full response as a file: ${title}`;
+    }
+    return `I published the full response as a Slack artifact: ${title}`;
+  }
+};
+function resolveSlackEventBridgeOptions(partial) {
+  return {
+    showReasoning: partial.showReasoning ?? DEFAULT_OPTIONS.showReasoning,
+    showToolUsage: partial.showToolUsage ?? DEFAULT_OPTIONS.showToolUsage,
+    showSubagentToolUsage: partial.showSubagentToolUsage ?? DEFAULT_OPTIONS.showSubagentToolUsage,
+    showSubagentResultInTask: partial.showSubagentResultInTask ?? DEFAULT_OPTIONS.showSubagentResultInTask,
+    formatToolTitle: partial.formatToolTitle ?? DEFAULT_OPTIONS.formatToolTitle,
+    formatToolUpdate: partial.formatToolUpdate ?? DEFAULT_OPTIONS.formatToolUpdate,
+    ...partial.formatToolDetails ? { formatToolDetails: partial.formatToolDetails } : {},
+    ...partial.formatToolResultOutput ? { formatToolResultOutput: partial.formatToolResultOutput } : {},
+    formatToolError: partial.formatToolError ?? DEFAULT_OPTIONS.formatToolError,
+    formatReasoningUpdate: partial.formatReasoningUpdate ?? DEFAULT_OPTIONS.formatReasoningUpdate,
+    formatMessageText: partial.formatMessageText ?? DEFAULT_OPTIONS.formatMessageText,
+    streamingMode: partial.streamingMode ?? DEFAULT_OPTIONS.streamingMode,
+    progressiveUpdateThreshold: partial.progressiveUpdateThreshold ?? DEFAULT_OPTIONS.progressiveUpdateThreshold,
+    progressiveUpdateIntervalMs: partial.progressiveUpdateIntervalMs ?? DEFAULT_OPTIONS.progressiveUpdateIntervalMs,
+    chatStreamBufferSize: partial.chatStreamBufferSize ?? DEFAULT_OPTIONS.chatStreamBufferSize,
+    maxTaskUpdates: resolveNonNegativeInteger(
+      partial.maxTaskUpdates,
+      DEFAULT_OPTIONS.maxTaskUpdates
+    ),
+    maxTaskUpdateTextChars: resolveNonNegativeInteger(
+      partial.maxTaskUpdateTextChars,
+      DEFAULT_OPTIONS.maxTaskUpdateTextChars
+    ),
+    maxTaskUpdateFieldChars: resolveNonNegativeInteger(
+      partial.maxTaskUpdateFieldChars,
+      DEFAULT_OPTIONS.maxTaskUpdateFieldChars
+    ),
+    interactiveMode: partial.interactiveMode ?? DEFAULT_OPTIONS.interactiveMode,
+    ...partial.handleInteractiveRequest ? { handleInteractiveRequest: partial.handleInteractiveRequest } : {},
+    formatApprovalRequired: partial.formatApprovalRequired ?? DEFAULT_OPTIONS.formatApprovalRequired,
+    formatHumanInputRequired: partial.formatHumanInputRequired ?? DEFAULT_OPTIONS.formatHumanInputRequired,
+    ...partial.onStatusChange ? { onStatusChange: partial.onStatusChange } : {},
+    ...partial.chatStreamFinalArgs ? { chatStreamFinalArgs: partial.chatStreamFinalArgs } : {},
+    ...partial.publishFinalResponseArtifact ? { publishFinalResponseArtifact: partial.publishFinalResponseArtifact } : {},
+    finalResponseArtifactMode: partial.finalResponseArtifactMode ?? DEFAULT_OPTIONS.finalResponseArtifactMode,
+    finalResponseArtifactStreamThreshold: resolvePositiveInteger(
+      partial.finalResponseArtifactStreamThreshold,
+      DEFAULT_OPTIONS.finalResponseArtifactStreamThreshold ?? 4e3
+    ),
+    formatFinalResponseArtifactContinuationNotice: partial.formatFinalResponseArtifactContinuationNotice ?? DEFAULT_OPTIONS.formatFinalResponseArtifactContinuationNotice,
+    formatFinalResponseArtifactMessage: partial.formatFinalResponseArtifactMessage ?? DEFAULT_OPTIONS.formatFinalResponseArtifactMessage,
+    ...partial.onFinalResponseArtifactError ? { onFinalResponseArtifactError: partial.onFinalResponseArtifactError } : {}
+  };
+}
+function resolveNonNegativeInteger(value, fallback) {
+  if (value === void 0) {
+    return fallback;
+  }
+  if (!Number.isFinite(value) || value < 0) {
+    return fallback;
+  }
+  return Math.floor(value);
+}
+function resolvePositiveInteger(value, fallback) {
+  if (value === void 0) {
+    return fallback;
+  }
+  if (!Number.isFinite(value) || value < 1) {
+    return fallback;
+  }
+  return Math.floor(value);
+}
+
+// src/shared/event-bridge/interactive.ts
+var UnsupportedSlackInteractiveRequestError = class extends Error {
+  kind;
+  requestId;
+  constructor(kind, requestId, message) {
+    super(message);
+    this.name = "UnsupportedSlackInteractiveRequestError";
+    this.kind = kind;
+    this.requestId = requestId;
+  }
+};
+
+// src/shared/event-bridge/turn-source.ts
+function adaptAgentTurnSourceToSlackTurnSource(source) {
+  return {
+    async *chat(sessionId, message, options) {
+      const events = source.chat(sessionId, message, options);
+      for await (const event of events) {
+        yield mapAgentEventToSlackTurnEvent(event);
+      }
+    }
+  };
+}
+
+export {
+  DEFAULT_SLACK_CONTEXT_FRAGMENT_KEY,
+  createSlackContextFragmentMiddleware,
+  mapAgentEventToSlackTurnEvent,
+  mapAgentSlackEventBridgeOptionsToRuntimeOptions,
+  bridgeAgentEventsToSlack,
+  resolveSlackEventBridgeOptions,
+  UnsupportedSlackInteractiveRequestError,
+  adaptAgentTurnSourceToSlackTurnSource
+};

package/dist/history/index.d.ts

@@ -1,23 +1,13 @@
 import { Logger } from '@cuylabs/agent-core';
 import { SlackHistoryUnavailable, SlackSupplementalHistoryVisibilityMode } from '@cuylabs/channel-slack/history';
-import { MountSlackAgentAppTurnRequestContext } from '../app-surface.js';
+import { SlackTurnRequestContext, SlackAssistantUtilities } from '@cuylabs/channel-slack/core';
+import { WebClient } from '@slack/web-api';
 import { a as SlackContextFragmentPayload } from '../context-fragments-CQEDcjYR.js';
-import '@slack/bolt';
-import '@slack/web-api';
-import '../options-ByNm2o89.js';
-import '@cuylabs/channel-slack/core';
-import '../interactive-BigrPKnu.js';
-import '@cuylabs/channel-slack/interactive';
-import '../options-CGUfVStV.js';
-import '../artifacts/index.js';
-import '@cuylabs/channel-slack/artifacts';
-import '@cuylabs/channel-slack/feedback';
-import '@cuylabs/channel-slack/assistant';
-import '../types-BeGPexio.js';
-import '../types-Bz4OYEAV.js';
-import '../types-CiwGU6zC.js';
-import '@cuylabs/channel-slack/views';
 
+interface SlackAgentHistoryTurnRequestContext extends SlackTurnRequestContext {
+    assistant?: SlackAssistantUtilities;
+    client?: WebClient;
+}
 interface SlackAgentTurnHistoryOptions {
     enabled: boolean;
     limit: number;
@@ -40,7 +30,7 @@ interface LoadSlackAgentTurnHistoryContextOptions {
     logger?: Pick<Logger, "debug" | "info" | "warn">;
     originChannelId?: string;
     profileResolver?: SlackAgentTurnHistoryProfileResolver;
-    request: MountSlackAgentAppTurnRequestContext;
+    request: SlackAgentHistoryTurnRequestContext;
 }
 type SlackAgentTurnHistoryContextResult = {
     fragment?: SlackContextFragmentPayload;

package/dist/index.d.ts

@@ -1,40 +1,17 @@
 export { D as DEFAULT_SLACK_CONTEXT_FRAGMENT_KEY, S as SlackContextFragmentMiddlewareOptions, a as SlackContextFragmentPayload, b as SlackContextFragmentResolver, c as SlackContextFragmentResolverContext, d as createSlackContextFragmentMiddleware } from './context-fragments-CQEDcjYR.js';
-export { UnsupportedSlackInteractiveRequestError, bridgeAgentEventsToSlack } from './shared/index.js';
-export { S as SlackEventBridgeOptions, r as resolveSlackEventBridgeOptions } from './options-CGUfVStV.js';
+export { SlackEventBridgeOptions, UnsupportedSlackInteractiveRequestError, adaptAgentTurnSourceToSlackTurnSource, bridgeAgentEventsToSlack, mapAgentEventToSlackTurnEvent, mapAgentSlackEventBridgeOptionsToRuntimeOptions, resolveSlackEventBridgeOptions } from './shared/index.js';
 export { S as SlackApprovalRequest, a as SlackEventInteractiveRequestHandler, b as SlackHumanInputRequest, c as SlackInteractiveRequest, d as SlackInteractiveRequestBaseContext, e as SlackInteractiveRequestContext, f as SlackInteractiveRequestHandler } from './interactive-BigrPKnu.js';
-export { c as createSlackChannelAdapter } from './adapter-vbqtraAr.js';
-export { S as SlackChannelAdapter, a as SlackChannelOptions, b as SlackSessionStrategy, c as SlackStreamingMode, d as SlackToolStartEvent } from './types-BeGPexio.js';
-export { SlackSessionMap, createSlackSessionMap } from './adapter/index.js';
-export { createSlackAssistantBridge } from './assistant/index.js';
-export { A as AssistantLifecycleArgs, a as AssistantThreadStartedArgs, C as CreateSlackAssistantBridgeOptions, M as MaybePromise, S as SlackAssistantBridge, b as SlackAssistantCancelControlOptions, c as SlackAssistantCancelControlVisibleWhen, d as SlackAssistantFeedbackConfig, e as SlackAssistantSessionStrategy, f as SlackAssistantStatusContext, g as SlackAssistantThreadContextStoreLike, h as SlackAssistantThreadStartedContext, i as SlackAssistantTurnCancelContext, j as SlackAssistantTurnControlsOptions, k as SlackAssistantTurnPreparation, l as SlackAssistantUserMessageContext, r as resolveAssistantSessionId } from './options-ByNm2o89.js';
-export { ParsedAssistantUserMessage, createSlackAssistantThreadContextStore, parseSlackMessageActivityFromMessageEvent } from '@cuylabs/channel-slack/assistant';
-export { CreateSlackFinalResponseArtifactPublisherOptions, SlackFinalResponseArtifactContext, SlackFinalResponseArtifactDeliveryMode, SlackFinalResponseArtifactPublisher, SlackFinalResponseArtifactResult, SlackFinalResponseArtifactValueResolver, createSlackFinalResponseArtifactPublisher } from './artifacts/index.js';
 export { LoadSlackAgentTurnHistoryContextOptions, SlackAgentTurnHistoryContextResult, SlackAgentTurnHistoryOptions, SlackAgentTurnHistoryProfileResolver, emptySlackAgentTurnHistoryContextResult, loadSlackAgentTurnHistoryContext } from './history/index.js';
-export { S as SlackInteractiveApprovalRequest, a as SlackInteractiveController, b as SlackInteractiveControllerOptions, c as SlackInteractiveHumanInputRequest, d as SlackInteractivePendingWaiter, e as SlackInteractivePostedMessage, f as SlackInteractiveRequestWaitOptions, g as SlackInteractiveResolution } from './types-Bz4OYEAV.js';
-export { createSlackInteractiveController } from './interactive/index.js';
-export { createSlackAgentViewWorkflowController } from './views/index.js';
-export { C as CreateSlackAgentViewWorkflowControllerOptions, S as SlackAgentViewStateValue, a as SlackAgentViewStateValues, b as SlackAgentViewWorkflow, c as SlackAgentViewWorkflowContext, d as SlackAgentViewWorkflowController, e as SlackAgentViewWorkflowDefinition, f as extractSlackAgentViewStateValues, r as readSlackAgentViewStateValue } from './types-CiwGU6zC.js';
+export { SlackInteractiveApprovalRequest, SlackInteractiveController, SlackInteractiveControllerOptions, SlackInteractiveHumanInputRequest, SlackInteractivePendingWaiter, SlackInteractivePostedMessage, SlackInteractiveRequestWaitOptions, SlackInteractiveResolution, createSlackInteractiveController } from './interactive/index.js';
 export { InspectSlackTurnStatusVisibilityOptions, ResolvedSlackTurnStatusVisibilityOptions, RouteSlackAgentEventOptions, SlackActiveToolCall, SlackAgentEventQueue, SlackAgentEventQueueState, SlackSubagentCompletionMessage, SlackSubagentCompletionMessageFormatterOptions, SlackSubagentCompletionNotifierOptions, SlackSubagentCompletionPoster, SlackSubagentCompletionRun, SlackSubagentCompletionSlackContext, SlackSubagentCompletionTurnContext, SlackTurnActivityState, SlackTurnPhase, SlackTurnStatusVisibilityOptions, SlackTurnStatusVisibilityState, SlackTurnStatusVisibilityWarning, SlackTypedApprovalAction, coalesceSlackAgentEvents, createSlackSubagentCompletionNotifier, formatDefaultSlackSubagentCompletionMessage, immediateSlackTextResponse, inspectSlackTurnStatusVisibility, isAbortLikeError, isRunningAgentTurnError, isSlackCancelMessage, isSlackSubagentTerminalEvent, isSlackTerminalTurnPhase, isSlackWaitingForHumanTurnPhase, recordSlackTurnActivity, resolveSlackTurnStatusVisibilityOptions, resolveSlackTypedApprovalAction, routeSlackAgentEvent, shouldInspectSlackTurnStatusVisibility, shouldQueueSlackAgentEvent } from './source/index.js';
-export { MountSlackAgentOptions, MountSlackAgentResult, mountSlackAgent } from './express.js';
-export { MountSlackAssistantAgentOptions, MountSlackAssistantAgentResult, mountSlackAssistantAgent } from './express-assistant.js';
-export { MountSlackAgentAppSocketOptions, MountSlackAgentAppSocketResult, MountSlackAssistantAgentSocketOptions, MountSlackAssistantAgentSocketResult, mountSlackAgentAppSocket, mountSlackAssistantAgentSocket } from './socket.js';
-export { MountSlackAgentAppOptions, MountSlackAgentAppResult, mountSlackAgentApp } from './app.js';
 export { CreateSlackMcpServerConfigOptions, SLACK_MCP_URL, createSlackMcpServerConfig } from './mcp.js';
-export { MountSlackAgentAppTurnRequestContext } from './app-surface.js';
 import '@cuylabs/agent-core';
 import '@cuylabs/channel-slack/core';
 import '@cuylabs/channel-slack/responses';
+import '@cuylabs/channel-slack/runtime';
 import '@cuylabs/channel-slack/interactive';
-import '@slack/bolt';
-import '@slack/web-api';
-import '@cuylabs/channel-slack/feedback';
-import '@cuylabs/channel-slack/artifacts';
 import '@cuylabs/channel-slack/history';
-import '@cuylabs/channel-slack/views';
+import '@slack/web-api';
+import '@slack/bolt';
 import '@cuylabs/agent-core/dispatch';
-import 'node:http';
-import 'express';
-import '@cuylabs/channel-slack/transports/http';
-import '@cuylabs/channel-slack/auth';
-import '@cuylabs/channel-slack/transports/socket';
 import '@cuylabs/agent-core/mcp';

package/dist/index.js

@@ -1,6 +1,7 @@
 import {
-  createSlackFinalResponseArtifactPublisher
-} from "./chunk-NNCVHQC4.js";
+  SLACK_MCP_URL,
+  createSlackMcpServerConfig
+} from "./chunk-RFHXERNL.js";
 import {
   emptySlackAgentTurnHistoryContextResult,
   loadSlackAgentTurnHistoryContext
@@ -10,8 +11,14 @@ import {
 } from "./chunk-OP27SSZU.js";
 import {
   DEFAULT_SLACK_CONTEXT_FRAGMENT_KEY,
-  createSlackContextFragmentMiddleware
-} from "./chunk-A2PLAVW6.js";
+  UnsupportedSlackInteractiveRequestError,
+  adaptAgentTurnSourceToSlackTurnSource,
+  bridgeAgentEventsToSlack,
+  createSlackContextFragmentMiddleware,
+  mapAgentEventToSlackTurnEvent,
+  mapAgentSlackEventBridgeOptionsToRuntimeOptions,
+  resolveSlackEventBridgeOptions
+} from "./chunk-U6RC4SXN.js";
 import {
   coalesceSlackAgentEvents,
   createSlackSubagentCompletionNotifier,
@@ -31,63 +38,18 @@ import {
   shouldInspectSlackTurnStatusVisibility,
   shouldQueueSlackAgentEvent
 } from "./chunk-C7VSW4ZM.js";
-import {
-  createSlackAgentViewWorkflowController,
-  extractSlackAgentViewStateValues,
-  readSlackAgentViewStateValue
-} from "./chunk-C7CHMYV6.js";
-import {
-  mountSlackAgentApp
-} from "./chunk-KAEZPS3U.js";
-import {
-  mountSlackAssistantAgent
-} from "./chunk-JU5R6JZG.js";
-import {
-  mountSlackAgent
-} from "./chunk-D4CSEAIF.js";
-import {
-  SLACK_MCP_URL,
-  createSlackMcpServerConfig
-} from "./chunk-RFHXERNL.js";
-import {
-  mountSlackAgentAppSocket,
-  mountSlackAssistantAgentSocket
-} from "./chunk-HHXAXSG6.js";
-import "./chunk-GKZRDNEB.js";
-import {
-  createSlackAssistantBridge,
-  createSlackAssistantThreadContextStore,
-  parseSlackMessageActivityFromMessageEvent,
-  resolveAssistantSessionId
-} from "./chunk-FJP6ZFUB.js";
-import "./chunk-ELR6MQD7.js";
-import {
-  createSlackChannelAdapter,
-  createSlackSessionMap
-} from "./chunk-XA7U3GRN.js";
-import {
-  UnsupportedSlackInteractiveRequestError,
-  bridgeAgentEventsToSlack,
-  resolveSlackEventBridgeOptions
-} from "./chunk-VBGQD6JT.js";
 export {
   DEFAULT_SLACK_CONTEXT_FRAGMENT_KEY,
   SLACK_MCP_URL,
   UnsupportedSlackInteractiveRequestError,
+  adaptAgentTurnSourceToSlackTurnSource,
   bridgeAgentEventsToSlack,
   coalesceSlackAgentEvents,
-  createSlackAgentViewWorkflowController,
-  createSlackAssistantBridge,
-  createSlackAssistantThreadContextStore,
-  createSlackChannelAdapter,
   createSlackContextFragmentMiddleware,
-  createSlackFinalResponseArtifactPublisher,
   createSlackInteractiveController,
   createSlackMcpServerConfig,
-  createSlackSessionMap,
   createSlackSubagentCompletionNotifier,
   emptySlackAgentTurnHistoryContextResult,
-  extractSlackAgentViewStateValues,
   formatDefaultSlackSubagentCompletionMessage,
   immediateSlackTextResponse,
   inspectSlackTurnStatusVisibility,
@@ -98,15 +60,9 @@ export {
   isSlackTerminalTurnPhase,
   isSlackWaitingForHumanTurnPhase,
   loadSlackAgentTurnHistoryContext,
-  mountSlackAgent,
-  mountSlackAgentApp,
-  mountSlackAgentAppSocket,
-  mountSlackAssistantAgent,
-  mountSlackAssistantAgentSocket,
-  parseSlackMessageActivityFromMessageEvent,
-  readSlackAgentViewStateValue,
+  mapAgentEventToSlackTurnEvent,
+  mapAgentSlackEventBridgeOptionsToRuntimeOptions,
   recordSlackTurnActivity,
-  resolveAssistantSessionId,
   resolveSlackEventBridgeOptions,
   resolveSlackTurnStatusVisibilityOptions,
   resolveSlackTypedApprovalAction,

package/dist/interactive/index.d.ts

@@ -1,11 +1,90 @@
-import { b as SlackInteractiveControllerOptions, a as SlackInteractiveController } from '../types-Bz4OYEAV.js';
-export { S as SlackInteractiveApprovalRequest, c as SlackInteractiveHumanInputRequest, d as SlackInteractivePendingWaiter, e as SlackInteractivePostedMessage, f as SlackInteractiveRequestWaitOptions, g as SlackInteractiveResolution } from '../types-Bz4OYEAV.js';
-import '@cuylabs/agent-core';
-import '@cuylabs/channel-slack/interactive';
-import '@slack/bolt';
-import '../interactive-BigrPKnu.js';
+import { ApprovalRequest, ApprovalResolution, HumanInputRequest, HumanInputResponse, ApprovalAction, ApprovalRememberScope } from '@cuylabs/agent-core';
+import { SlackInteractiveActionIds, SlackInteractiveRequestStore, SlackInteractiveRequestRecord, SlackInteractiveActor, SlackInteractiveHumanInputRequest as SlackInteractiveHumanInputRequest$1, SlackInteractiveMessageRef } from '@cuylabs/channel-slack/interactive';
+import { App } from '@slack/bolt';
+import { e as SlackInteractiveRequestContext } from '../interactive-BigrPKnu.js';
 import '@cuylabs/channel-slack/core';
 
+type SlackInteractiveApprovalRequest = ApprovalRequest;
+type SlackInteractiveHumanInputRequest = SlackInteractiveHumanInputRequest$1 & Partial<Pick<HumanInputRequest, "sessionId" | "timestamp" | "toolCallId">>;
+type SlackInteractiveResolution = {
+    kind: "approval";
+    action: ApprovalAction;
+    feedback?: string;
+    rememberScope?: ApprovalRememberScope;
+} | {
+    kind: "human-input";
+    response: HumanInputResponse;
+};
+interface SlackInteractiveRequestWaitOptions {
+    /**
+     * Abort waiting for this request. The controller removes its local waiter and
+     * deletes the pending store record when the signal fires.
+     */
+    signal?: AbortSignal;
+    /**
+     * Override the controller-level request timeout for this request. Use `0` to
+     * disable timeout cleanup for this request.
+     */
+    timeoutMs?: number;
+}
+interface SlackInteractiveControllerOptions {
+    store?: SlackInteractiveRequestStore;
+    /**
+     * Stable namespace for default Slack action IDs. Use this when installing
+     * multiple interactive controllers in the same Slack app.
+     *
+     * @default "agent_slack"
+     */
+    namespace?: string;
+    actionIds?: Partial<SlackInteractiveActionIds>;
+    /**
+     * Default timeout for local waiters and pending store records. This should
+     * usually match the agent-core approval/human-input timeout.
+     *
+     * @default 300000
+     */
+    requestTimeoutMs?: number;
+    /**
+     * Called on every successful Slack resolution after the local waiter, if
+     * present, is resolved. Use this to fan out decisions to agent-server or
+     * another runtime that owns the turn.
+     */
+    onResolve?: (requestId: string, resolution: SlackInteractiveResolution) => void | Promise<void>;
+    /**
+     * Authorization hook for approving/responding to pending requests.
+     *
+     * Defaults to the original Slack requester only. Return `true` for delegated
+     * approvers, channel owners, or admin policy checks.
+     */
+    authorize?: (record: SlackInteractiveRequestRecord, actor: SlackInteractiveActor) => boolean | Promise<boolean>;
+}
+interface SlackInteractiveController {
+    readonly actionIds: SlackInteractiveActionIds;
+    readonly store: SlackInteractiveRequestStore;
+    approval: {
+        onRequest(request: ApprovalRequest, options?: SlackInteractiveRequestWaitOptions): Promise<ApprovalResolution>;
+    };
+    humanInput: {
+        onRequest(request: HumanInputRequest, options?: SlackInteractiveRequestWaitOptions): Promise<HumanInputResponse>;
+    };
+    /** Reject one pending in-process waiter and delete its pending store record. */
+    cancel(requestId: string, reason?: string): Promise<boolean>;
+    /** Shutdown helper: cancel every pending request created by this controller. */
+    cancelAll(reason?: string): Promise<void>;
+    handleInteractiveRequest(context: SlackInteractiveRequestContext): Promise<boolean>;
+    install(app: App): void;
+}
+type SlackInteractivePendingWaiter = {
+    resolve: (resolution: SlackInteractiveResolution) => void;
+    reject: (error: Error) => void;
+    cleanup: () => void;
+};
+interface SlackInteractivePostedMessage {
+    text: string;
+    blocks: unknown[];
+    ref: SlackInteractiveMessageRef;
+}
+
 declare function createSlackInteractiveController(options?: SlackInteractiveControllerOptions): SlackInteractiveController;
 
-export { SlackInteractiveController, SlackInteractiveControllerOptions, createSlackInteractiveController };
+export { type SlackInteractiveApprovalRequest, type SlackInteractiveController, type SlackInteractiveControllerOptions, type SlackInteractiveHumanInputRequest, type SlackInteractivePendingWaiter, type SlackInteractivePostedMessage, type SlackInteractiveRequestWaitOptions, type SlackInteractiveResolution, createSlackInteractiveController };