@cuylabs/channel-slack-agent-core 0.6.0 → 0.8.0

package/dist/{chunk-J6CW2RGO.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/{chunk-QEJ7TAZJ.js → chunk-YSDFYHPC.js}

@@ -1,9 +1,9 @@
 import {
   installSlackAgentAppSurface
-} from "./chunk-P7KK5GQG.js";
+} from "./chunk-6T6N4MRK.js";
 import {
   createSlackAssistantBridge
-} from "./chunk-ZDVD46RT.js";
+} from "./chunk-7YZWCSML.js";
 
 // src/socket.ts
 import { createSlackSocketBoltApp } from "@cuylabs/channel-slack/transports/socket";

package/dist/express-assistant.d.ts

@@ -3,13 +3,15 @@ import { Application } from 'express';
 import { App, ExpressReceiver } from '@slack/bolt';
 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-Uf-qmQKN.js';
+import { C as CreateSlackAssistantBridgeOptions, d as SlackAssistantFeedbackConfig, S as SlackAssistantBridge } from './options-C7-VXmhD.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,9 +1,9 @@
 import {
   mountSlackAssistantAgent
-} from "./chunk-5NQYLOAW.js";
-import "./chunk-ZDVD46RT.js";
+} from "./chunk-2R7B7NJR.js";
+import "./chunk-7YZWCSML.js";
 import "./chunk-ELR6MQD7.js";
-import "./chunk-NOVWLAVP.js";
+import "./chunk-TMADMHBN.js";
 export {
   mountSlackAssistantAgent
 };

package/dist/express.d.ts

@@ -2,11 +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 { 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,8 +1,8 @@
 import {
   mountSlackAgent
-} from "./chunk-VCXPNQRB.js";
-import "./chunk-TIQGJ52F.js";
-import "./chunk-NOVWLAVP.js";
+} from "./chunk-TCNJY7QA.js";
+import "./chunk-FQWFB54C.js";
+import "./chunk-TMADMHBN.js";
 export {
   mountSlackAgent
 };

package/dist/history/index.d.ts

@@ -4,14 +4,18 @@ import { MountSlackAgentAppTurnRequestContext } from '../app-surface.js';
 import { a as SlackContextFragmentPayload } from '../context-fragments-CQEDcjYR.js';
 import '@slack/bolt';
 import '@slack/web-api';
-import '../options-Uf-qmQKN.js';
+import '../options-C7-VXmhD.js';
 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/feedback';
 import '@cuylabs/channel-slack/assistant';
-import '../types-BqRzb_Cd.js';
+import '../types-CRWzJB5G.js';
 import '../types-Crpil4kb.js';
+import '../types-CiwGU6zC.js';
+import '@cuylabs/channel-slack/views';
 
 interface SlackAgentTurnHistoryOptions {
     enabled: boolean;

package/dist/index.d.ts

@@ -1,16 +1,19 @@
 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 { SlackChatStream, SlackResponseSink, SlackStreamChunk, SlackStreamTaskStatus, UnsupportedSlackInteractiveRequestError, bridgeAgentEventsToSlack } from './shared/index.js';
-export { S as SlackEventBridgeOptions, r as resolveSlackEventBridgeOptions } from './options-C7OYeNR-.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 { 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 { 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-Uf-qmQKN.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-C7-VXmhD.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 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/index.js';
+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';
@@ -20,10 +23,13 @@ export { CreateSlackMcpServerConfigOptions, SLACK_MCP_URL, createSlackMcpServerC
 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';

package/dist/index.js

@@ -1,3 +1,6 @@
+import {
+  createSlackFinalResponseArtifactPublisher
+} from "./chunk-NNCVHQC4.js";
 import {
   emptySlackAgentTurnHistoryContextResult,
   loadSlackAgentTurnHistoryContext
@@ -9,11 +12,14 @@ import {
   buildResolvedMessage,
   cloneRecord,
   createInMemorySlackInteractiveRequestStore,
+  createPostgresSlackInteractiveRequestStore,
   createSlackInteractiveController,
   decodeActionValue,
   encodeActionValue,
-  nowIso
-} from "./chunk-J6CW2RGO.js";
+  initializePostgresSlackInteractiveRequestStore,
+  nowIso,
+  prunePostgresSlackInteractiveRequestStore
+} from "./chunk-X7ILLZZP.js";
 import {
   DEFAULT_SLACK_CONTEXT_FRAGMENT_KEY,
   createSlackContextFragmentMiddleware
@@ -37,15 +43,20 @@ import {
   shouldInspectSlackTurnStatusVisibility,
   shouldQueueSlackAgentEvent
 } from "./chunk-C7VSW4ZM.js";
+import {
+  createSlackAgentViewWorkflowController,
+  extractSlackAgentViewStateValues,
+  readSlackAgentViewStateValue
+} from "./chunk-C7CHMYV6.js";
 import {
   mountSlackAgentApp
-} from "./chunk-FNT4TXNQ.js";
+} from "./chunk-236WN6JD.js";
 import {
   mountSlackAssistantAgent
-} from "./chunk-5NQYLOAW.js";
+} from "./chunk-2R7B7NJR.js";
 import {
   mountSlackAgent
-} from "./chunk-VCXPNQRB.js";
+} from "./chunk-TCNJY7QA.js";
 import {
   SLACK_MCP_URL,
   createSlackMcpServerConfig
@@ -53,24 +64,24 @@ import {
 import {
   mountSlackAgentAppSocket,
   mountSlackAssistantAgentSocket
-} from "./chunk-QEJ7TAZJ.js";
-import "./chunk-P7KK5GQG.js";
+} from "./chunk-YSDFYHPC.js";
+import "./chunk-6T6N4MRK.js";
 import {
   createSlackAssistantBridge,
   createSlackAssistantThreadContextStore,
   parseSlackMessageActivityFromMessageEvent,
   resolveAssistantSessionId
-} from "./chunk-ZDVD46RT.js";
+} from "./chunk-7YZWCSML.js";
 import "./chunk-ELR6MQD7.js";
 import {
   createSlackChannelAdapter,
   createSlackSessionMap
-} from "./chunk-TIQGJ52F.js";
+} from "./chunk-FQWFB54C.js";
 import {
   UnsupportedSlackInteractiveRequestError,
   bridgeAgentEventsToSlack,
   resolveSlackEventBridgeOptions
-} from "./chunk-NOVWLAVP.js";
+} from "./chunk-TMADMHBN.js";
 export {
   DEFAULT_SLACK_CONTEXT_FRAGMENT_KEY,
   SLACK_MCP_URL,
@@ -83,10 +94,13 @@ export {
   cloneRecord,
   coalesceSlackAgentEvents,
   createInMemorySlackInteractiveRequestStore,
+  createPostgresSlackInteractiveRequestStore,
+  createSlackAgentViewWorkflowController,
   createSlackAssistantBridge,
   createSlackAssistantThreadContextStore,
   createSlackChannelAdapter,
   createSlackContextFragmentMiddleware,
+  createSlackFinalResponseArtifactPublisher,
   createSlackInteractiveController,
   createSlackMcpServerConfig,
   createSlackSessionMap,
@@ -94,8 +108,10 @@ export {
   decodeActionValue,
   emptySlackAgentTurnHistoryContextResult,
   encodeActionValue,
+  extractSlackAgentViewStateValues,
   formatDefaultSlackSubagentCompletionMessage,
   immediateSlackTextResponse,
+  initializePostgresSlackInteractiveRequestStore,
   inspectSlackTurnStatusVisibility,
   isAbortLikeError,
   isRunningAgentTurnError,
@@ -111,6 +127,8 @@ export {
   mountSlackAssistantAgentSocket,
   nowIso,
   parseSlackMessageActivityFromMessageEvent,
+  prunePostgresSlackInteractiveRequestStore,
+  readSlackAgentViewStateValue,
   recordSlackTurnActivity,
   resolveAssistantSessionId,
   resolveSlackEventBridgeOptions,