@cuylabs/channel-slack-agent-core 0.5.1 → 0.7.0

package/dist/{chunk-IXY3BXU5.js → chunk-X7ILLZZP.js}

@@ -70,6 +70,358 @@ function cloneResolution(resolution) {
   return structuredClone(resolution);
 }
 
+// src/interactive/postgres-store.ts
+var DEFAULT_TABLE = "channel_slack_interactive_requests";
+var DEFAULT_RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
+var DEFAULT_PRUNE_BATCH_SIZE = 1e3;
+var DEFAULT_PRUNE_INTERVAL_MS = 6 * 60 * 60 * 1e3;
+function createPostgresSlackInteractiveRequestStore({
+  client,
+  connectionString,
+  ensureSchema = true,
+  onPruneError,
+  pruneBatchSize = DEFAULT_PRUNE_BATCH_SIZE,
+  pruneIntervalMs = DEFAULT_PRUNE_INTERVAL_MS,
+  retentionMs = DEFAULT_RETENTION_MS,
+  schema,
+  tableName = DEFAULT_TABLE
+}) {
+  let activeClient = client;
+  let ownsClient = false;
+  let initialized;
+  let pruneTimer;
+  async function getClient() {
+    if (activeClient) {
+      return activeClient;
+    }
+    if (!connectionString) {
+      throw new Error(
+        "connectionString is required when a Postgres Slack interactive request client is not provided"
+      );
+    }
+    const Pool = await importPostgresPoolConstructor();
+    activeClient = new Pool({ connectionString });
+    ownsClient = true;
+    return activeClient;
+  }
+  async function ensureInitialized() {
+    const currentClient = await getClient();
+    initialized ??= initializePostgresSlackInteractiveRequestStore({
+      client: currentClient,
+      ensureSchema,
+      schema,
+      tableName
+    });
+    await initialized;
+    startPruneTimer();
+    return currentClient;
+  }
+  function startPruneTimer() {
+    if (pruneTimer || pruneIntervalMs <= 0) {
+      return;
+    }
+    pruneTimer = setInterval(() => {
+      void prune().catch((error) => {
+        onPruneError?.(error);
+      });
+    }, pruneIntervalMs);
+    pruneTimer.unref?.();
+  }
+  async function prune() {
+    const currentClient = await ensureInitialized();
+    return prunePostgresSlackInteractiveRequestStore({
+      client: currentClient,
+      pruneBatchSize,
+      retentionMs,
+      schema,
+      tableName
+    });
+  }
+  return {
+    async get(requestId) {
+      const currentClient = await ensureInitialized();
+      const result = await currentClient.query(
+        `SELECT * FROM ${qualifiedTableName({
+          schema,
+          tableName
+        })} WHERE id = $1::text LIMIT 1`,
+        [requestId]
+      );
+      return rowToRecord(result.rows[0]);
+    },
+    async upsert(record) {
+      const currentClient = await ensureInitialized();
+      const result = await currentClient.query(
+        `INSERT INTO ${qualifiedTableName({
+          schema,
+          tableName
+        })} (
+          id,
+          kind,
+          request,
+          status,
+          created_at,
+          updated_at,
+          target,
+          resolution
+        )
+        VALUES (
+          $1::text,
+          $2::text,
+          $3::jsonb,
+          $4::text,
+          $5::timestamptz,
+          $6::timestamptz,
+          $7::jsonb,
+          $8::jsonb
+        )
+        ON CONFLICT (id) DO UPDATE SET
+          kind = CASE
+            WHEN ${qualifiedTableName({ schema, tableName })}.status = 'resolved'
+              THEN ${qualifiedTableName({ schema, tableName })}.kind
+            ELSE EXCLUDED.kind
+          END,
+          request = CASE
+            WHEN ${qualifiedTableName({ schema, tableName })}.status = 'resolved'
+              THEN ${qualifiedTableName({ schema, tableName })}.request
+            ELSE EXCLUDED.request
+          END,
+          status = CASE
+            WHEN ${qualifiedTableName({ schema, tableName })}.status = 'resolved'
+              THEN ${qualifiedTableName({ schema, tableName })}.status
+            ELSE EXCLUDED.status
+          END,
+          target = CASE
+            WHEN ${qualifiedTableName({ schema, tableName })}.status = 'resolved'
+              THEN ${qualifiedTableName({ schema, tableName })}.target
+            ELSE COALESCE(EXCLUDED.target, ${qualifiedTableName({
+          schema,
+          tableName
+        })}.target)
+          END,
+          resolution = CASE
+            WHEN ${qualifiedTableName({ schema, tableName })}.status = 'resolved'
+              THEN ${qualifiedTableName({ schema, tableName })}.resolution
+            ELSE COALESCE(EXCLUDED.resolution, ${qualifiedTableName({
+          schema,
+          tableName
+        })}.resolution)
+          END,
+          updated_at = CASE
+            WHEN ${qualifiedTableName({ schema, tableName })}.status = 'resolved'
+              THEN ${qualifiedTableName({ schema, tableName })}.updated_at
+            ELSE now()
+          END
+        RETURNING *`,
+        [
+          record.id,
+          record.kind,
+          JSON.stringify(record.request),
+          record.status,
+          record.createdAt,
+          record.updatedAt,
+          record.target ? JSON.stringify(record.target) : null,
+          record.resolution ? JSON.stringify(record.resolution) : null
+        ]
+      );
+      return requireReturnedRecord(result.rows[0], record.id);
+    },
+    async attachTarget(requestId, target) {
+      const currentClient = await ensureInitialized();
+      const result = await currentClient.query(
+        `UPDATE ${qualifiedTableName({ schema, tableName })}
+        SET target = $2::jsonb, updated_at = now()
+        WHERE id = $1::text
+        RETURNING *`,
+        [requestId, JSON.stringify(target)]
+      );
+      return rowToRecord(result.rows[0]);
+    },
+    async resolve(requestId, resolution) {
+      const currentClient = await ensureInitialized();
+      const result = await currentClient.query(
+        `UPDATE ${qualifiedTableName({ schema, tableName })}
+        SET status = 'resolved',
+          resolution = $2::jsonb,
+          updated_at = now()
+        WHERE id = $1::text AND status <> 'resolved'
+        RETURNING *`,
+        [requestId, JSON.stringify(resolution)]
+      );
+      const resolved = rowToRecord(result.rows[0]);
+      if (resolved) {
+        return resolved;
+      }
+      const existing = await currentClient.query(
+        `SELECT * FROM ${qualifiedTableName({
+          schema,
+          tableName
+        })} WHERE id = $1::text LIMIT 1`,
+        [requestId]
+      );
+      return rowToRecord(existing.rows[0]);
+    },
+    async delete(requestId) {
+      const currentClient = await ensureInitialized();
+      await currentClient.query(
+        `DELETE FROM ${qualifiedTableName({
+          schema,
+          tableName
+        })} WHERE id = $1::text`,
+        [requestId]
+      );
+    },
+    prune,
+    async close() {
+      if (pruneTimer) {
+        clearInterval(pruneTimer);
+        pruneTimer = void 0;
+      }
+      if (ownsClient) {
+        await activeClient?.end?.();
+      }
+    }
+  };
+}
+async function initializePostgresSlackInteractiveRequestStore({
+  client,
+  ensureSchema = true,
+  schema,
+  tableName = DEFAULT_TABLE
+}) {
+  if (schema && ensureSchema) {
+    await client.query(
+      `CREATE SCHEMA IF NOT EXISTS ${quoteIdentifier(schema)}`
+    );
+  }
+  const table = qualifiedTableName({ schema, tableName });
+  await client.query(`
+    CREATE TABLE IF NOT EXISTS ${table} (
+      id text PRIMARY KEY,
+      kind text NOT NULL CHECK (kind IN ('approval', 'human-input')),
+      request jsonb NOT NULL,
+      status text NOT NULL CHECK (status IN ('pending', 'resolved')),
+      target jsonb,
+      resolution jsonb,
+      created_at timestamptz NOT NULL DEFAULT now(),
+      updated_at timestamptz NOT NULL DEFAULT now()
+    )
+  `);
+  const indexPrefix = interactiveIndexPrefix({ schema, tableName });
+  await client.query(
+    `CREATE INDEX IF NOT EXISTS ${quoteIdentifier(
+      `${indexPrefix}_status_updated_idx`
+    )} ON ${table} (status, updated_at DESC)`
+  );
+  await client.query(
+    `CREATE INDEX IF NOT EXISTS ${quoteIdentifier(
+      `${indexPrefix}_updated_idx`
+    )} ON ${table} (updated_at DESC)`
+  );
+}
+async function prunePostgresSlackInteractiveRequestStore({
+  client,
+  pruneBatchSize = DEFAULT_PRUNE_BATCH_SIZE,
+  retentionMs = DEFAULT_RETENTION_MS,
+  schema,
+  tableName = DEFAULT_TABLE
+}) {
+  if (retentionMs <= 0) {
+    return { deleted: 0 };
+  }
+  const batchSize = Math.max(1, Math.floor(pruneBatchSize));
+  const result = await client.query(
+    `WITH expired AS (
+      SELECT id
+      FROM ${qualifiedTableName({ schema, tableName })}
+      WHERE updated_at < now() - ($1::bigint * interval '1 millisecond')
+      ORDER BY updated_at ASC
+      LIMIT $2::integer
+    )
+    DELETE FROM ${qualifiedTableName({ schema, tableName })} target
+    USING expired
+    WHERE target.id = expired.id`,
+    [Math.max(1, Math.floor(retentionMs)), batchSize]
+  );
+  return { deleted: result.rowCount ?? 0 };
+}
+function rowToRecord(row) {
+  if (!row) return void 0;
+  return cloneRecord({
+    id: row.id,
+    kind: row.kind,
+    request: readJsonValue(
+      row.request
+    ),
+    status: row.status,
+    createdAt: toIsoString(row.created_at),
+    updatedAt: toIsoString(row.updated_at),
+    ...row.target ? {
+      target: readJsonValue(
+        row.target
+      )
+    } : {},
+    ...row.resolution ? {
+      resolution: readJsonValue(
+        row.resolution
+      )
+    } : {}
+  });
+}
+function requireReturnedRecord(row, requestId) {
+  const record = rowToRecord(row);
+  if (!record) {
+    throw new Error(
+      `Postgres Slack interactive request store did not return request ${requestId}.`
+    );
+  }
+  return record;
+}
+function readJsonValue(value) {
+  if (typeof value === "string") {
+    return JSON.parse(value);
+  }
+  return value;
+}
+function toIsoString(value) {
+  return value instanceof Date ? value.toISOString() : new Date(value).toISOString();
+}
+function qualifiedTableName({
+  schema,
+  tableName
+}) {
+  return schema ? `${quoteIdentifier(schema)}.${quoteIdentifier(tableName)}` : quoteIdentifier(tableName);
+}
+function quoteIdentifier(value) {
+  return `"${value.replace(/"/g, '""')}"`;
+}
+function interactiveIndexPrefix({
+  schema,
+  tableName
+}) {
+  const raw = [schema, tableName].filter(Boolean).join("_");
+  return raw.replace(/[^A-Za-z0-9_]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 40) || "channel_slack_interactive";
+}
+async function importPostgresPoolConstructor() {
+  const dynamicImport = new Function(
+    "specifier",
+    "return import(specifier)"
+  );
+  try {
+    const pg = await dynamicImport("pg");
+    return pg.Pool;
+  } catch (error) {
+    throw new Error(
+      `The "pg" package is required when using connectionString with createPostgresSlackInteractiveRequestStore. Install pg or pass a client. ${formatImportError(
+        error
+      )}`
+    );
+  }
+}
+function formatImportError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
 // src/interactive/blocks.ts
 var MAX_BLOCK_TEXT = 2800;
 function buildApprovalRequestMessage(request, actionIds) {
@@ -284,6 +636,7 @@ function escapeMrkdwn(value) {
 }
 
 // src/interactive/controller.ts
+import { openSlackModal } from "@cuylabs/channel-slack/views";
 var DEFAULT_NAMESPACE = "agent_slack";
 var DEFAULT_REQUEST_TIMEOUT_MS = 5 * 60 * 1e3;
 var installedActionIds = /* @__PURE__ */ new WeakMap();
@@ -501,8 +854,9 @@ function createSlackInteractiveController(options = {}) {
       );
       return;
     }
-    await actionArgs.client.views.open({
-      trigger_id: actionArgs.body.trigger_id,
+    await openSlackModal({
+      client: actionArgs.client,
+      triggerId: actionArgs.body.trigger_id,
       view: buildHumanInputModal(
         record.request,
         actionIds
@@ -679,6 +1033,9 @@ export {
   createInMemorySlackInteractiveRequestStore,
   nowIso,
   cloneRecord,
+  createPostgresSlackInteractiveRequestStore,
+  initializePostgresSlackInteractiveRequestStore,
+  prunePostgresSlackInteractiveRequestStore,
   buildApprovalRequestMessage,
   buildHumanInputRequestMessage,
   buildResolvedMessage,

package/dist/context-fragments-CQEDcjYR.d.ts

@@ -0,0 +1,30 @@
+import { AgentContextFragmentInput, AgentContextFragmentBuildContext, AgentContextFragmentKind, AgentContextFragmentRole, AgentContextFragmentPlacement, AgentContextFragmentLifetime, AgentContextFragmentBudgetBehavior, AgentMiddleware } from '@cuylabs/agent-core';
+import { SlackAmbientTurnContext } from '@cuylabs/channel-slack/core';
+
+declare const DEFAULT_SLACK_CONTEXT_FRAGMENT_KEY = "slackContextFragment";
+interface SlackContextFragmentPayload extends Partial<Pick<AgentContextFragmentInput, "budgetBehavior" | "dedupeKey" | "kind" | "lifetime" | "maxChars" | "metadata" | "placement" | "role" | "source" | "title">> {
+    content: string;
+}
+interface SlackContextFragmentResolverContext {
+    slack: Readonly<SlackAmbientTurnContext>;
+    step: AgentContextFragmentBuildContext;
+}
+type SlackContextFragmentResolver = (context: SlackContextFragmentResolverContext) => AgentContextFragmentInput | SlackContextFragmentPayload | string | undefined | Promise<AgentContextFragmentInput | SlackContextFragmentPayload | string | undefined>;
+interface SlackContextFragmentMiddlewareOptions {
+    name?: string;
+    contextKey?: string;
+    resolve?: SlackContextFragmentResolver;
+    kind?: AgentContextFragmentKind;
+    role?: AgentContextFragmentRole;
+    placement?: AgentContextFragmentPlacement;
+    lifetime?: AgentContextFragmentLifetime;
+    title?: string;
+    source?: string;
+    budgetBehavior?: AgentContextFragmentBudgetBehavior;
+    maxChars?: number;
+    dedupeKey?: string | ((context: SlackContextFragmentResolverContext) => string | undefined);
+    metadata?: Record<string, unknown> | ((context: SlackContextFragmentResolverContext) => Record<string, unknown> | undefined);
+}
+declare function createSlackContextFragmentMiddleware(options?: SlackContextFragmentMiddlewareOptions): AgentMiddleware;
+
+export { DEFAULT_SLACK_CONTEXT_FRAGMENT_KEY as D, type SlackContextFragmentMiddlewareOptions as S, type SlackContextFragmentPayload as a, type SlackContextFragmentResolver as b, type SlackContextFragmentResolverContext as c, createSlackContextFragmentMiddleware as d };

package/dist/express-assistant.d.ts

@@ -1,14 +1,17 @@
 import { Server } from 'node:http';
 import { Application } from 'express';
 import { App, ExpressReceiver } from '@slack/bolt';
-import { CreateSlackBoltAppOptions, SlackDirectAuthOptions, SlackDirectAuthMode } from '@cuylabs/channel-slack/bolt';
-import { C as CreateSlackAssistantBridgeOptions, b as SlackAssistantFeedbackConfig, S as SlackAssistantBridge } from './options-Uf-qmQKN.js';
+import { CreateSlackBoltAppOptions } from '@cuylabs/channel-slack/transports/http';
+import { SlackDirectAuthOptions, SlackDirectAuthMode } from '@cuylabs/channel-slack/auth';
+import { C as CreateSlackAssistantBridgeOptions, b as SlackAssistantFeedbackConfig, S as SlackAssistantBridge } from './options-CdqBABcM.js';
 import { SlackFeedbackHandler } from '@cuylabs/channel-slack/feedback';
 import '@cuylabs/agent-core';
 import '@slack/web-api';
 import '@cuylabs/channel-slack/core';
 import './interactive-o_NZb-Xg.js';
-import './options-C7OYeNR-.js';
+import './options-BcDReOJv.js';
+import './artifacts/index.js';
+import '@cuylabs/channel-slack/artifacts';
 import '@cuylabs/channel-slack/assistant';
 
 /**

package/dist/express-assistant.js

@@ -1,12 +1,9 @@
 import {
   mountSlackAssistantAgent
-} from "./chunk-JMLB7A2V.js";
-import "./chunk-BFUPAJON.js";
-import "./chunk-VHGV66M7.js";
-import "./chunk-GNXWTKQ6.js";
-import "./chunk-DHPD4XH5.js";
-import "./chunk-ANIZ5NT4.js";
-import "./chunk-I2KLQ2HA.js";
+} from "./chunk-DJPKRKGP.js";
+import "./chunk-MGBNGG4D.js";
+import "./chunk-ELR6MQD7.js";
+import "./chunk-TMADMHBN.js";
 export {
   mountSlackAssistantAgent
 };

package/dist/express.d.ts

@@ -2,10 +2,14 @@ import * as _slack_bolt from '@slack/bolt';
 import { Server } from 'node:http';
 import { AgentTurnSource } from '@cuylabs/agent-core';
 import { Application } from 'express';
-import { c as createSlackChannelAdapter } from './adapter-Cmd2C90g.js';
-import { a as SlackChannelOptions } from './types-BqRzb_Cd.js';
-import { CreateSlackBoltAppOptions, SlackDirectAuthOptions, SlackDirectAuthMode } from '@cuylabs/channel-slack/bolt';
+import { c as createSlackChannelAdapter } from './adapter-B3CI611y.js';
+import { a as SlackChannelOptions } from './types-CRWzJB5G.js';
+import { CreateSlackBoltAppOptions } from '@cuylabs/channel-slack/transports/http';
+import { SlackDirectAuthOptions, SlackDirectAuthMode } from '@cuylabs/channel-slack/auth';
 import '@cuylabs/channel-slack/core';
+import './options-BcDReOJv.js';
+import './artifacts/index.js';
+import '@cuylabs/channel-slack/artifacts';
 import './interactive-o_NZb-Xg.js';
 
 interface MountSlackAgentOptions extends Omit<SlackChannelOptions, "agent" | "source">, Omit<CreateSlackBoltAppOptions, "app" | "path" | "botToken" | "signingSecret" | "auth"> {

package/dist/express.js

@@ -1,11 +1,8 @@
 import {
   mountSlackAgent
-} from "./chunk-WO4BJMF3.js";
-import "./chunk-FDRQOG7Q.js";
-import "./chunk-GNXWTKQ6.js";
-import "./chunk-DHPD4XH5.js";
-import "./chunk-ANIZ5NT4.js";
-import "./chunk-I2KLQ2HA.js";
+} from "./chunk-TCNJY7QA.js";
+import "./chunk-FQWFB54C.js";
+import "./chunk-TMADMHBN.js";
 export {
   mountSlackAgent
 };

package/dist/feedback/index.d.ts

@@ -0,0 +1 @@
+export { RegisterSlackFeedbackOptions, SLACK_FEEDBACK_ACTION_ID, SlackFeedbackBlockOptions, SlackFeedbackButtonConfig, SlackFeedbackContext, SlackFeedbackContextBlock, SlackFeedbackHandler, SlackFeedbackVerdict, createSlackFeedbackBlock, registerSlackFeedbackAction } from '@cuylabs/channel-slack/feedback';

package/dist/feedback/index.js

@@ -0,0 +1,10 @@
+import {
+  SLACK_FEEDBACK_ACTION_ID,
+  createSlackFeedbackBlock,
+  registerSlackFeedbackAction
+} from "../chunk-ELR6MQD7.js";
+export {
+  SLACK_FEEDBACK_ACTION_ID,
+  createSlackFeedbackBlock,
+  registerSlackFeedbackAction
+};

package/dist/history/index.d.ts

@@ -0,0 +1,61 @@
+import { Logger } from '@cuylabs/agent-core';
+import { SlackHistoryUnavailable, SlackSupplementalHistoryVisibilityMode } from '@cuylabs/channel-slack/history';
+import { MountSlackAgentAppTurnRequestContext } from '../app-surface.js';
+import { a as SlackContextFragmentPayload } from '../context-fragments-CQEDcjYR.js';
+import '@slack/bolt';
+import '@slack/web-api';
+import '../options-CdqBABcM.js';
+import '@cuylabs/channel-slack/core';
+import '../interactive-o_NZb-Xg.js';
+import '../options-BcDReOJv.js';
+import '../artifacts/index.js';
+import '@cuylabs/channel-slack/artifacts';
+import '@cuylabs/channel-slack/feedback';
+import '@cuylabs/channel-slack/assistant';
+import '../types-CRWzJB5G.js';
+import '../types-Crpil4kb.js';
+import '../types-CiwGU6zC.js';
+import '@cuylabs/channel-slack/views';
+
+interface SlackAgentTurnHistoryOptions {
+    enabled: boolean;
+    limit: number;
+    maxCharacters: number;
+    unavailableNoteFormatter?: (issue: SlackHistoryUnavailable) => string | undefined;
+    visibilityAllowedUserIds?: readonly string[];
+    visibilityMode?: SlackSupplementalHistoryVisibilityMode;
+}
+interface SlackAgentTurnHistoryProfileResolver {
+    resolve(options: {
+        botToken?: string;
+        teamId?: string;
+        userId: string;
+    }): Promise<{
+        displayName?: string;
+    }>;
+}
+interface LoadSlackAgentTurnHistoryContextOptions {
+    history: SlackAgentTurnHistoryOptions;
+    logger?: Pick<Logger, "debug" | "info" | "warn">;
+    originChannelId?: string;
+    profileResolver?: SlackAgentTurnHistoryProfileResolver;
+    request: MountSlackAgentAppTurnRequestContext;
+}
+type SlackAgentTurnHistoryContextResult = {
+    fragment?: SlackContextFragmentPayload;
+    originChannelMessageCount: number;
+    originChannelUnavailableReason?: string;
+    originChannelVisibilityOmittedMessageCount: number;
+    prompt?: string;
+    threadMessageCount: number;
+    threadUnavailableReason?: string;
+    threadVisibilityOmittedMessageCount: number;
+    topLevelChannelMessageCount: number;
+    topLevelChannelUnavailableReason?: string;
+    topLevelChannelVisibilityOmittedMessageCount: number;
+    visibilityOmittedMessageCount: number;
+};
+declare function loadSlackAgentTurnHistoryContext({ history, logger, originChannelId: providedOriginChannelId, profileResolver, request, }: LoadSlackAgentTurnHistoryContextOptions): Promise<SlackAgentTurnHistoryContextResult>;
+declare function emptySlackAgentTurnHistoryContextResult(): SlackAgentTurnHistoryContextResult;
+
+export { type LoadSlackAgentTurnHistoryContextOptions, type SlackAgentTurnHistoryContextResult, type SlackAgentTurnHistoryOptions, type SlackAgentTurnHistoryProfileResolver, emptySlackAgentTurnHistoryContextResult, loadSlackAgentTurnHistoryContext };

package/dist/history/index.js

@@ -0,0 +1,8 @@
+import {
+  emptySlackAgentTurnHistoryContextResult,
+  loadSlackAgentTurnHistoryContext
+} from "../chunk-P7PFQ3SQ.js";
+export {
+  emptySlackAgentTurnHistoryContextResult,
+  loadSlackAgentTurnHistoryContext
+};

package/dist/index.d.ts

@@ -1,22 +1,20 @@
-export { ExtractSlackMessageTextOptions, RawSlackActionTokenPayload, RawSlackAppMentionPayload, RawSlackAssistantThreadPayload, RawSlackMessagePayload, SlackActivityInfo, SlackAmbientTurnContext, SlackAssistantStatusUpdate, SlackAssistantSuggestedPrompt, SlackAssistantSuggestedPrompts, SlackAssistantTaskDisplayMode, SlackAssistantThreadContext, SlackAssistantUtilities, SlackAuthContext, SlackChannelType, SlackChatStreamStartArgs, SlackMessageAuthorshipOptions, SlackMessageFormatter, SlackMessageFormattingOptions, SlackMessageTextPayload, SlackThreadStatusSetter, SlackTurnPreparation, SlackTurnRequestContext, SlackUserIdentity, currentSlackTurnContext, extractSlackActionToken, extractSlackAttachmentsText, extractSlackAuthContext, extractSlackBlocksText, extractSlackMessageText, extractSlackUserIdentity, formatSlackAttributedFollowUp, isProcessableMessage, markdownToSlackMrkdwn, parseSlackMentionActivity, parseSlackMessageActivity, resolveSlackChannelType, resolveSlackMessageFormatter, resolveThreadAwareSlackSessionId, runWithSlackTurnContext, stripLeadingMentions } from '@cuylabs/channel-slack/core';
+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 { SlackArtifactPublicationTarget, SlackChatStream, SlackResponseSink, SlackStreamChunk, SlackStreamTaskStatus, UnsupportedSlackInteractiveRequestError, bridgeAgentEventsToSlack } from './shared/index.js';
+export { S as SlackEventBridgeOptions, r as resolveSlackEventBridgeOptions } from './options-BcDReOJv.js';
 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-o_NZb-Xg.js';
-export { DEFAULT_SLACK_CONTEXT_FRAGMENT_KEY, SlackChatStream, SlackContextFragmentMiddlewareOptions, SlackContextFragmentPayload, SlackContextFragmentResolver, SlackContextFragmentResolverContext, SlackResponseSink, SlackStreamChunk, SlackStreamTaskStatus, UnsupportedSlackInteractiveRequestError, bridgeAgentEventsToSlack, createSlackContextFragmentMiddleware } from './shared.js';
-export { S as SlackEventBridgeOptions, r as resolveSlackEventBridgeOptions } from './options-C7OYeNR-.js';
-export * from '@cuylabs/channel-slack/bolt';
-export { c as createSlackChannelAdapter } from './adapter-Cmd2C90g.js';
-export { S as SlackChannelAdapter, a as SlackChannelOptions, b as SlackSessionStrategy, c as SlackStreamingMode, d as SlackToolStartEvent } from './types-BqRzb_Cd.js';
-export { SlackSessionMap, createSlackSessionMap } from './adapter.js';
-export { createSlackAssistantBridge } from './assistant.js';
-export { A as AssistantLifecycleArgs, a as AssistantThreadStartedArgs, C as CreateSlackAssistantBridgeOptions, M as MaybePromise, S as SlackAssistantBridge, b as SlackAssistantFeedbackConfig, c as SlackAssistantSessionStrategy, d as SlackAssistantStatusContext, e as SlackAssistantThreadContextStoreLike, f as SlackAssistantThreadStartedContext, g as SlackAssistantTurnPreparation, h as SlackAssistantUserMessageContext, r as resolveAssistantSessionId } from './options-Uf-qmQKN.js';
+export { c as createSlackChannelAdapter } from './adapter-B3CI611y.js';
+export { S as SlackChannelAdapter, a as SlackChannelOptions, b as SlackSessionStrategy, c as SlackStreamingMode, d as SlackToolStartEvent } from './types-CRWzJB5G.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 SlackAssistantFeedbackConfig, c as SlackAssistantSessionStrategy, d as SlackAssistantStatusContext, e as SlackAssistantThreadContextStoreLike, f as SlackAssistantThreadStartedContext, g as SlackAssistantTurnPreparation, h as SlackAssistantUserMessageContext, r as resolveAssistantSessionId } from './options-CdqBABcM.js';
 export { ParsedAssistantUserMessage, createSlackAssistantThreadContextStore, parseSlackMessageActivityFromMessageEvent } from '@cuylabs/channel-slack/assistant';
-export { CreateSlackSupplementalHistoryVisibilityPolicyOptions, FormatSlackHistoryForPromptOptions, LoadSlackTurnHistoryContextOptions, ReadSlackChannelHistoryOptions, ReadSlackThreadHistoryOptions, SlackAssistantSurfaceThreadRootNormalization, SlackAssistantSurfaceThreadRootNormalizationContext, SlackContextFragmentBudgetBehavior, SlackContextFragmentKind, SlackContextFragmentLifetime, SlackContextFragmentPlacement, SlackContextFragmentRole, SlackHistoryAuthorFormatter, SlackHistoryAuthorResolutionErrorContext, SlackHistoryAuthorResolver, SlackHistoryAuthorResolverContext, SlackHistoryContextSource, SlackHistoryMessage, SlackHistoryMessageRole, SlackHistoryPage, SlackHistoryReaderClient, SlackHistoryUnavailable, SlackSessionTranscriptInspector, SlackSupplementalHistoryInclusionDecision, SlackSupplementalHistoryInclusionReason, SlackSupplementalHistoryInclusionSource, SlackSupplementalHistoryPolicy, SlackSupplementalHistoryPolicyRequest, SlackSupplementalHistoryVisibilityContext, SlackSupplementalHistoryVisibilityDecision, SlackSupplementalHistoryVisibilityErrorContext, SlackSupplementalHistoryVisibilityMode, SlackSupplementalHistoryVisibilityPolicy, SlackTurnHistoryContextResult, createSlackSupplementalHistoryPolicy, createSlackSupplementalHistoryVisibilityPolicy, formatSlackHistoryForPrompt, loadSlackTurnHistoryContext, readSlackChannelHistory, readSlackThreadHistory } from '@cuylabs/channel-slack/history';
+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 SlackInteractiveActionIds, a as SlackInteractiveActor, b as SlackInteractiveApprovalRequest, c as SlackInteractiveController, d as SlackInteractiveControllerOptions, e as SlackInteractiveHumanInputRequest, f as SlackInteractiveMessageTarget, g as SlackInteractivePendingWaiter, h as SlackInteractivePostedMessage, i as SlackInteractiveRequestRecord, j as SlackInteractiveRequestStatus, k as SlackInteractiveRequestStore, l as SlackInteractiveRequestWaitOptions, m as SlackInteractiveResolution, n as SlackInteractiveStoredRequest } from './types-Crpil4kb.js';
-export { buildApprovalRequestMessage, buildHumanInputModal, buildHumanInputRequestMessage, buildResolvedMessage, cloneRecord, createInMemorySlackInteractiveRequestStore, createSlackInteractiveController, decodeActionValue, encodeActionValue, nowIso } from './interactive.js';
-export * from '@cuylabs/channel-slack/policy';
-export * from '@cuylabs/channel-slack/users';
-export * from '@cuylabs/channel-slack/diagnostics';
-export * from '@cuylabs/channel-slack/setup';
-export * from '@cuylabs/channel-slack/targets';
+export { PostgresSlackInteractiveRequestPruneResult, PostgresSlackInteractiveRequestStore, PostgresSlackInteractiveRequestStoreOptions, SlackInteractivePostgresClient, buildApprovalRequestMessage, buildHumanInputModal, buildHumanInputRequestMessage, buildResolvedMessage, cloneRecord, createInMemorySlackInteractiveRequestStore, createPostgresSlackInteractiveRequestStore, createSlackInteractiveController, decodeActionValue, encodeActionValue, initializePostgresSlackInteractiveRequestStore, nowIso, prunePostgresSlackInteractiveRequestStore } 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 { 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';
@@ -24,9 +22,18 @@ export { MountSlackAgentAppOptions, MountSlackAgentAppResult, mountSlackAgentApp
 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/artifacts';
 import '@slack/bolt';
 import '@slack/web-api';
 import '@cuylabs/channel-slack/feedback';
+import '@cuylabs/channel-slack/history';
+import '@slack/types';
+import '@cuylabs/channel-slack/views';
+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';