@cuylabs/channel-slack 0.5.0 → 0.6.0

package/README.md

@@ -1,16 +1,14 @@
 # @cuylabs/channel-slack
 
-Slack channel primitives for AI agents.
+Agent-runtime-agnostic Slack channel primitives.
 
-This package contains reusable Slack mechanics: activity parsing, message
-formatting, message admission policy, supplemental history, visibility filters,
-Socket Mode runtime guards, OAuth installation storage, setup inspection, and
-Slack API helpers. It intentionally does not create or run an agent.
+This package owns reusable Slack mechanics: event parsing, message admission,
+history loading, formatting, setup inspection, auth helpers, entrypoint
+normalization, artifact publishing, and HTTP or Socket Mode transport helpers.
+It does not create or run an agent, and it does not depend on an agent SDK.
 
-It is not an agent runtime adapter. Use `@cuylabs/channel-slack-agent-core` for
-the runtime-specific adapter. See
-[Channel Slack Boundary](docs/reference/channel-slack-boundary.md) for the
-package boundary.
+Runtime-specific adapters should compose these primitives with their own turn
+types, event streams, tools, prompts, and deployment policy.
 
 ## Install
 
@@ -18,48 +16,18 @@ package boundary.
 npm install @cuylabs/channel-slack
 ```
 
-Slack SDK packages are optional peers. Install the peers for the components you
+Slack SDK packages are optional peers. Install the peers for the features you
 use:
 
 ```bash
 npm install @slack/bolt @slack/web-api @slack/types express
 ```
 
-Postgres-backed helpers lazy-load `pg` when you pass a connection string. Install
-`pg` in applications that use those helpers without injecting their own client
-or pool.
+Postgres-backed helpers lazy-load `pg` when you pass a connection string.
+Install `pg` only when your application uses those helpers without injecting its
+own client or pool.
 
-## Import Map
-
-Prefer feature-specific imports so applications only couple to the Slack
-surface they need.
-
-| Import                               | Use for                                                                            |
-| ------------------------------------ | ---------------------------------------------------------------------------------- |
-| `@cuylabs/channel-slack/core`        | Activity parsing, formatting, sessions, turn context, shared types                 |
-| `@cuylabs/channel-slack/policy`      | Message admission, duplicate suppression, mentioned-thread state                   |
-| `@cuylabs/channel-slack/history`     | Slack history reading, prompt shaping, supplemental-history visibility             |
-| `@cuylabs/channel-slack/bolt`        | Bolt app factories, auth options, Socket Mode runtime helpers, installation stores |
-| `@cuylabs/channel-slack/setup`       | Required scopes/events/settings, generated manifests, setup inspection             |
-| `@cuylabs/channel-slack/diagnostics` | Slack token and scope checks                                                       |
-| `@cuylabs/channel-slack/users`       | User profile lookup and mention enrichment                                         |
-| `@cuylabs/channel-slack/targets`     | Human-friendly Slack channel/user target parsing and resolution                    |
-| `@cuylabs/channel-slack/feedback`    | Feedback Block Kit and action helpers                                              |
-
-The package root re-exports `core` and `policy` as a lightweight convenience.
-Use feature-specific imports for peer-backed helpers such as `bolt`,
-`diagnostics`, `setup`, and `users`. `@cuylabs/channel-slack/shared` remains as
-an alias of `core`.
-
-## Core Flow
-
-Most Slack agent adapters follow this flow:
-
-1. Parse a Slack event into `SlackActivityInfo`.
-2. Resolve whether the message should start or continue an agent turn.
-3. Optionally load model-visible Slack history for the turn.
-4. Run the product-owned agent.
-5. Format the response back to Slack.
+## Quick Start
 
 ```typescript
 import {
@@ -77,100 +45,21 @@ const policy = createSlackMessagePolicyResolver({
 const decision = policy.resolve(activity);
 if (!decision.accepted) return;
 
-const responseText = markdownToSlackMrkdwn("**Ready**");
+const modelInput = decision.text;
+const slackText = markdownToSlackMrkdwn("**Ready**");
 ```
 
-## Components
-
-### Core
-
-`core` is transport-neutral. It parses raw Slack message and app mention
-payloads, extracts model-facing text from Slack text, Block Kit, rich text, and
-attachments, formats Markdown to Slack mrkdwn, derives thread-aware session IDs,
-and carries request context.
-
-See [Activity](docs/concepts/activity.md).
-
-### Policy
-
-`policy` decides which Slack messages an adapter should process. It accepts DMs
-and direct mentions by default, can allow passive channel messages by channel or
-install scope, tracks mentioned threads, and suppresses duplicate Slack events.
-Use `createPostgresSlackMessagePolicyStateStore` when duplicate suppression and
-mentioned-thread state must survive restarts or coordinate across workers.
-
-See [Message Policy](docs/concepts/message-policy.md).
-
-### History
-
-`history` reads Slack thread/channel history, normalizes messages, formats prompt
-sections, reports expected Slack history access failures, and filters
-supplemental context before it reaches a model.
-
-See [Supplemental History](docs/concepts/supplemental-history.md).
-
-### Bolt
+Most adapters follow the same shape:
 
-`bolt` contains app factories for HTTP and Socket Mode, direct auth resolution,
-OAuth installation-store types, development installation stores, and Socket Mode
-process/runtime guards. It also exposes a Postgres advisory-lock helper for
-distributed Socket Mode single-instance coordination. It does not register agent
-handlers.
+1. Normalize the Slack payload.
+2. Decide whether it should become a turn.
+3. Optionally load model-visible Slack context.
+4. Run the application-owned runtime.
+5. Format the response for Slack.
 
-See [Bolt Runtime](docs/concepts/bolt-runtime.md).
+## Documentation
 
-### Setup
-
-`setup` turns feature selections into Slack scopes, bot events, settings,
-environment variables, and app manifests. It can also inspect a token against the
-requirements.
-
-See [Setup Requirements](docs/concepts/setup-requirements.md).
-
-## Recipes
-
-- [App mention handler](docs/recipes/app-mention-handler.md)
-- [Assistant thread handler](docs/recipes/assistant-thread-handler.md)
-- [Socket Mode app](docs/recipes/socket-mode-app.md)
-- [Generate a Slack manifest](docs/recipes/generate-slack-manifest.md)
-- [History visibility filter](docs/recipes/history-visibility.md)
-
-## Source Layout
-
-```text
-src/
-  core.ts                 public core entrypoint
-  shared/                 types, parsing, formatting, turn helpers
-  assistant/              Slack Assistant API helpers
-  bolt/                   Bolt app/auth/runtime helpers
-  diagnostics/            token and scope inspection
-  feedback/               feedback blocks and action parsing
-  history/
-    context/              turn-history loading component
-    reader.ts             Slack history API reader and prompt formatter
-    visibility-policy.ts  model-visible history filters
-    inclusion-policy.ts   direct-message supplemental-history inclusion policy
-  policy/
-    message/              message admission and state-store component
-  setup/                  scopes, events, manifests, setup inspection
-  targets/                channel/user target parsing and resolution
-  users/                  profile lookup and mention enrichment
-```
-
-## Development
-
-```bash
-pnpm --filter @cuylabs/channel-slack typecheck
-pnpm --filter @cuylabs/channel-slack test
-pnpm --filter @cuylabs/channel-slack build
-```
-
-Run workspace checks before publishing changes:
-
-```bash
-pnpm lint
-pnpm typecheck
-pnpm build
-pnpm test
-pnpm format:check
-```
+- [Package boundary](docs/reference/channel-slack-boundary.md)
+- [Exports and peer expectations](docs/reference/exports.md)
+- [Source layout](docs/reference/source-layout.md)
+- [Docs index](docs/README.md)

package/dist/app-home.d.ts

@@ -0,0 +1,23 @@
+import { App } from '@slack/bolt';
+import { HomeView } from '@slack/types';
+import { L as Logger } from './logging-Bl3HfcC8.js';
+
+interface SlackAppHomeOpenedEvent {
+    tab?: string;
+    user: string;
+    [key: string]: unknown;
+}
+interface SlackAppHomeOpenContext {
+    event: SlackAppHomeOpenedEvent;
+}
+interface InstallSlackAppHomeOptions {
+    boltApp: App;
+    buildView(context: SlackAppHomeOpenContext): HomeView | Promise<HomeView>;
+    logger?: Logger;
+}
+interface SlackAppHomeInstallation {
+    cancelAll(reason?: string): void;
+}
+declare function installSlackAppHome({ boltApp, buildView, logger, }: InstallSlackAppHomeOptions): SlackAppHomeInstallation;
+
+export { type InstallSlackAppHomeOptions, type SlackAppHomeInstallation, type SlackAppHomeOpenContext, type SlackAppHomeOpenedEvent, installSlackAppHome };

package/dist/app-home.js

@@ -0,0 +1,35 @@
+// src/app-home.ts
+function installSlackAppHome({
+  boltApp,
+  buildView,
+  logger
+}) {
+  boltApp.event("app_home_opened", async ({ event, client }) => {
+    const homeEvent = event;
+    try {
+      await client.views.publish({
+        user_id: homeEvent.user,
+        view: await buildView({ event: homeEvent })
+      });
+      logger?.debug?.("Slack App Home published", {
+        tab: homeEvent.tab,
+        userId: homeEvent.user
+      });
+    } catch (error) {
+      logger?.warn?.("Failed to publish Slack App Home", {
+        error: formatAppHomeError(error),
+        userId: homeEvent.user
+      });
+    }
+  });
+  return {
+    cancelAll() {
+    }
+  };
+}
+function formatAppHomeError(error) {
+  return error instanceof Error ? error.stack ?? error.message : String(error);
+}
+export {
+  installSlackAppHome
+};

package/dist/artifacts/index.d.ts

@@ -0,0 +1,135 @@
+type SlackArtifactPublishMethod = "message" | "file" | "canvas";
+type SlackArtifactBinaryData = string | Uint8Array | ArrayBuffer;
+interface SlackArtifactBase {
+    kind: string;
+    title: string;
+    summary?: string;
+    metadata?: Record<string, unknown>;
+}
+interface SlackTextArtifact extends SlackArtifactBase {
+    kind: "text";
+    text: string;
+    filename?: string;
+    mimeType?: string;
+    publishAs?: "message" | "file";
+}
+interface SlackFileArtifact extends SlackArtifactBase {
+    kind: "file";
+    filename: string;
+    data?: SlackArtifactBinaryData;
+    filePath?: string;
+    mimeType?: string;
+    initialComment?: string;
+}
+interface SlackImageArtifact extends SlackArtifactBase {
+    kind: "image";
+    filename: string;
+    altText: string;
+    data?: SlackArtifactBinaryData;
+    filePath?: string;
+    initialComment?: string;
+}
+interface SlackLinkArtifact extends SlackArtifactBase {
+    kind: "link";
+    url: string;
+}
+interface SlackCanvasArtifact extends SlackArtifactBase {
+    kind: "canvas";
+    markdown: string;
+    /**
+     * When set, updates an existing canvas instead of creating one.
+     */
+    canvasId?: string;
+    /**
+     * Create a channel canvas when a channel is available.
+     *
+     * @default true
+     */
+    channelCanvas?: boolean;
+}
+type SlackArtifact = SlackTextArtifact | SlackFileArtifact | SlackImageArtifact | SlackLinkArtifact | SlackCanvasArtifact;
+interface SlackArtifactPostMessageResponse {
+    ok?: boolean;
+    channel?: string;
+    ts?: string;
+    [key: string]: unknown;
+}
+interface SlackArtifactFileUploadResponse {
+    ok?: boolean;
+    file?: {
+        id?: string;
+        [key: string]: unknown;
+    };
+    files?: Array<{
+        id?: string;
+        [key: string]: unknown;
+    }>;
+    [key: string]: unknown;
+}
+interface SlackArtifactCanvasResponse {
+    ok?: boolean;
+    canvas_id?: string;
+    [key: string]: unknown;
+}
+interface SlackArtifactClient {
+    chat?: {
+        postMessage(args: Record<string, unknown>): Promise<SlackArtifactPostMessageResponse>;
+    };
+    files?: {
+        uploadV2(args: Record<string, unknown>): Promise<SlackArtifactFileUploadResponse>;
+    };
+    canvases?: {
+        create(args?: Record<string, unknown>): Promise<SlackArtifactCanvasResponse>;
+        edit?(args: Record<string, unknown>): Promise<SlackArtifactCanvasResponse>;
+    };
+    conversations?: {
+        canvases?: {
+            create(args: Record<string, unknown>): Promise<SlackArtifactCanvasResponse>;
+        };
+    };
+}
+interface PublishSlackArtifactOptions {
+    client: SlackArtifactClient;
+    artifact: SlackArtifact;
+    channelId?: string;
+    threadTs?: string;
+    token?: string;
+    unfurlLinks?: boolean;
+    unfurlMedia?: boolean;
+}
+interface SlackArtifactPublication {
+    artifact: SlackArtifact;
+    method: SlackArtifactPublishMethod;
+    response: unknown;
+    channelId?: string;
+    threadTs?: string;
+    messageTs?: string;
+    fileId?: string;
+    canvasId?: string;
+}
+
+interface SlackArtifactBlockKitMessage {
+    text: string;
+    blocks: Array<Record<string, unknown>>;
+}
+declare function createSlackArtifactBlocks(artifact: SlackArtifact): SlackArtifactBlockKitMessage;
+declare function createSlackLinkArtifactBlocks(artifact: SlackLinkArtifact): SlackArtifactBlockKitMessage;
+
+declare function publishSlackArtifact(options: PublishSlackArtifactOptions): Promise<SlackArtifactPublication>;
+declare function publishSlackTextArtifact(options: PublishSlackArtifactOptions & {
+    artifact: SlackTextArtifact;
+}): Promise<SlackArtifactPublication>;
+declare function publishSlackFileArtifact(options: PublishSlackArtifactOptions & {
+    artifact: SlackFileArtifact;
+}): Promise<SlackArtifactPublication>;
+declare function publishSlackImageArtifact(options: PublishSlackArtifactOptions & {
+    artifact: SlackImageArtifact;
+}): Promise<SlackArtifactPublication>;
+declare function publishSlackLinkArtifact(options: PublishSlackArtifactOptions & {
+    artifact: SlackLinkArtifact;
+}): Promise<SlackArtifactPublication>;
+declare function publishSlackCanvasArtifact(options: PublishSlackArtifactOptions & {
+    artifact: SlackCanvasArtifact;
+}): Promise<SlackArtifactPublication>;
+
+export { type PublishSlackArtifactOptions, type SlackArtifact, type SlackArtifactBase, type SlackArtifactBinaryData, type SlackArtifactBlockKitMessage, type SlackArtifactCanvasResponse, type SlackArtifactClient, type SlackArtifactFileUploadResponse, type SlackArtifactPostMessageResponse, type SlackArtifactPublication, type SlackArtifactPublishMethod, type SlackCanvasArtifact, type SlackFileArtifact, type SlackImageArtifact, type SlackLinkArtifact, type SlackTextArtifact, createSlackArtifactBlocks, createSlackLinkArtifactBlocks, publishSlackArtifact, publishSlackCanvasArtifact, publishSlackFileArtifact, publishSlackImageArtifact, publishSlackLinkArtifact, publishSlackTextArtifact };

package/dist/artifacts/index.js

@@ -0,0 +1,299 @@
+import {
+  markdownToSlackMrkdwn
+} from "../chunk-6WHFQUYQ.js";
+
+// src/artifacts/blocks.ts
+function createSlackArtifactBlocks(artifact) {
+  switch (artifact.kind) {
+    case "link":
+      return createSlackLinkArtifactBlocks(artifact);
+    case "canvas":
+      return createGenericArtifactBlocks({
+        title: artifact.title,
+        summary: artifact.summary ?? "Canvas created."
+      });
+    case "text":
+    case "file":
+    case "image":
+      return createGenericArtifactBlocks({
+        title: artifact.title,
+        summary: artifact.summary
+      });
+  }
+}
+function createSlackLinkArtifactBlocks(artifact) {
+  const title = normalizeText(artifact.title);
+  const summary = normalizeText(artifact.summary);
+  const link = `<${escapeSlackLinkUrl(artifact.url)}|Open link>`;
+  const body = [summary ? markdownToSlackMrkdwn(summary) : void 0, link].filter(Boolean).join("\n");
+  return {
+    text: [title, artifact.url].filter(Boolean).join(": "),
+    blocks: [
+      {
+        type: "section",
+        text: {
+          type: "mrkdwn",
+          text: [`*${title}*`, body].filter(Boolean).join("\n")
+        }
+      }
+    ]
+  };
+}
+function createGenericArtifactBlocks({
+  title,
+  summary
+}) {
+  const normalizedTitle = normalizeText(title);
+  const normalizedSummary = normalizeText(summary);
+  return {
+    text: normalizedSummary ? `${normalizedTitle}: ${normalizedSummary}` : normalizedTitle,
+    blocks: [
+      {
+        type: "section",
+        text: {
+          type: "mrkdwn",
+          text: [
+            `*${normalizedTitle}*`,
+            markdownToSlackMrkdwn(normalizedSummary)
+          ].filter(Boolean).join("\n")
+        }
+      }
+    ]
+  };
+}
+function normalizeText(value) {
+  return value?.trim() || "Untitled artifact";
+}
+function escapeSlackLinkUrl(url) {
+  return url.trim().replace(/[>|]/g, encodeURIComponent);
+}
+
+// src/artifacts/publish.ts
+async function publishSlackArtifact(options) {
+  switch (options.artifact.kind) {
+    case "link":
+      return publishSlackLinkArtifact({
+        ...options,
+        artifact: options.artifact
+      });
+    case "text":
+      return publishSlackTextArtifact({
+        ...options,
+        artifact: options.artifact
+      });
+    case "file":
+      return publishSlackFileArtifact({
+        ...options,
+        artifact: options.artifact
+      });
+    case "image":
+      return publishSlackImageArtifact({
+        ...options,
+        artifact: options.artifact
+      });
+    case "canvas":
+      return publishSlackCanvasArtifact({
+        ...options,
+        artifact: options.artifact
+      });
+  }
+}
+async function publishSlackTextArtifact(options) {
+  if (options.artifact.publishAs === "message") {
+    return publishArtifactMessage(
+      options,
+      createSlackArtifactBlocks({
+        ...options.artifact,
+        summary: options.artifact.summary ?? options.artifact.text
+      })
+    );
+  }
+  return uploadArtifactFile(options, {
+    filename: options.artifact.filename ?? filenameFromTitle(options.artifact.title, "txt"),
+    title: options.artifact.title,
+    content: options.artifact.text,
+    initialComment: options.artifact.summary
+  });
+}
+async function publishSlackFileArtifact(options) {
+  return uploadArtifactFile(options, {
+    filename: options.artifact.filename,
+    title: options.artifact.title,
+    data: options.artifact.data,
+    filePath: options.artifact.filePath,
+    initialComment: options.artifact.initialComment ?? options.artifact.summary
+  });
+}
+async function publishSlackImageArtifact(options) {
+  return uploadArtifactFile(options, {
+    filename: options.artifact.filename,
+    title: options.artifact.title,
+    data: options.artifact.data,
+    filePath: options.artifact.filePath,
+    initialComment: options.artifact.initialComment ?? options.artifact.summary,
+    altText: options.artifact.altText
+  });
+}
+async function publishSlackLinkArtifact(options) {
+  return publishArtifactMessage(
+    options,
+    createSlackArtifactBlocks(options.artifact)
+  );
+}
+async function publishSlackCanvasArtifact(options) {
+  const documentContent = {
+    type: "markdown",
+    markdown: options.artifact.markdown
+  };
+  const tokenArgs = options.token ? { token: options.token } : {};
+  let response;
+  if (options.artifact.canvasId) {
+    const edit = options.client.canvases?.edit;
+    if (typeof edit !== "function") {
+      throw new Error("Slack client does not expose canvases.edit.");
+    }
+    response = await edit({
+      ...tokenArgs,
+      canvas_id: options.artifact.canvasId,
+      changes: [
+        {
+          operation: "replace",
+          document_content: documentContent
+        }
+      ]
+    });
+  } else if (options.channelId && options.artifact.channelCanvas !== false && typeof options.client.conversations?.canvases?.create === "function") {
+    response = await options.client.conversations.canvases.create({
+      ...tokenArgs,
+      channel_id: options.channelId,
+      title: options.artifact.title,
+      document_content: documentContent
+    });
+  } else {
+    const create = options.client.canvases?.create;
+    if (typeof create !== "function") {
+      throw new Error(
+        "Slack client does not expose canvases.create or conversations.canvases.create."
+      );
+    }
+    response = await create({
+      ...tokenArgs,
+      ...options.channelId && options.artifact.channelCanvas !== false ? { channel_id: options.channelId } : {},
+      title: options.artifact.title,
+      document_content: documentContent
+    });
+  }
+  return {
+    artifact: options.artifact,
+    method: "canvas",
+    response,
+    ...options.channelId ? { channelId: options.channelId } : {},
+    ...options.threadTs ? { threadTs: options.threadTs } : {},
+    ...readString(response.canvas_id) ?? options.artifact.canvasId ? {
+      canvasId: readString(response.canvas_id) ?? options.artifact.canvasId
+    } : {}
+  };
+}
+async function publishArtifactMessage(options, message) {
+  const channelId = requireChannelId(options.channelId, options.artifact.kind);
+  const postMessage = options.client.chat?.postMessage;
+  if (typeof postMessage !== "function") {
+    throw new Error("Slack client does not expose chat.postMessage.");
+  }
+  const response = await postMessage({
+    ...options.token ? { token: options.token } : {},
+    channel: channelId,
+    text: message.text,
+    blocks: message.blocks,
+    ...options.threadTs ? { thread_ts: options.threadTs } : {},
+    ...options.unfurlLinks !== void 0 ? { unfurl_links: options.unfurlLinks } : {},
+    ...options.unfurlMedia !== void 0 ? { unfurl_media: options.unfurlMedia } : {}
+  });
+  return {
+    artifact: options.artifact,
+    method: "message",
+    response,
+    channelId,
+    ...options.threadTs ? { threadTs: options.threadTs } : {},
+    ...readString(response.ts) ? { messageTs: readString(response.ts) } : {}
+  };
+}
+async function uploadArtifactFile(options, file) {
+  const channelId = requireChannelId(options.channelId, options.artifact.kind);
+  const uploadV2 = options.client.files?.uploadV2;
+  if (typeof uploadV2 !== "function") {
+    throw new Error("Slack client does not expose files.uploadV2.");
+  }
+  const uploadArgs = {
+    ...options.token ? { token: options.token } : {},
+    channel_id: channelId,
+    ...options.threadTs ? { thread_ts: options.threadTs } : {},
+    filename: requireNonEmpty(file.filename, "artifact filename"),
+    title: requireNonEmpty(file.title, "artifact title"),
+    ...file.initialComment ? { initial_comment: file.initialComment } : {},
+    ...file.altText ? { alt_text: file.altText } : {},
+    ...resolveFilePayload(file)
+  };
+  const response = await uploadV2(uploadArgs);
+  return {
+    artifact: options.artifact,
+    method: "file",
+    response,
+    channelId,
+    ...options.threadTs ? { threadTs: options.threadTs } : {},
+    ...readUploadedFileId(response) ? { fileId: readUploadedFileId(response) } : {}
+  };
+}
+function resolveFilePayload(file) {
+  if (file.content !== void 0) {
+    return { content: file.content };
+  }
+  if (file.filePath) {
+    return { file: file.filePath };
+  }
+  if (file.data !== void 0) {
+    return typeof file.data === "string" ? { content: file.data } : { file: toBuffer(file.data) };
+  }
+  throw new Error(
+    "Slack file artifact requires `data`, `filePath`, or `content`."
+  );
+}
+function toBuffer(data) {
+  return data instanceof ArrayBuffer ? Buffer.from(new Uint8Array(data)) : Buffer.from(data);
+}
+function requireChannelId(channelId, artifactKind) {
+  const trimmed = channelId?.trim();
+  if (!trimmed) {
+    throw new Error(
+      `Slack ${artifactKind} artifact publication requires a channelId.`
+    );
+  }
+  return trimmed;
+}
+function requireNonEmpty(value, label) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    throw new Error(`Slack ${label} must not be empty.`);
+  }
+  return trimmed;
+}
+function filenameFromTitle(title, extension) {
+  const slug = title.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  return `${slug || "artifact"}.${extension}`;
+}
+function readUploadedFileId(response) {
+  return readString(response.file?.id) ?? readString(response.files?.[0]?.id);
+}
+function readString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+export {
+  createSlackArtifactBlocks,
+  createSlackLinkArtifactBlocks,
+  publishSlackArtifact,
+  publishSlackCanvasArtifact,
+  publishSlackFileArtifact,
+  publishSlackImageArtifact,
+  publishSlackLinkArtifact,
+  publishSlackTextArtifact
+};

package/dist/{assistant.d.ts → assistant/index.d.ts}

@@ -1,4 +1,4 @@
-import { S as SlackActivityInfo } from './activity-ByrD9Ftr.js';
+import { S as SlackActivityInfo } from '../activity-ByrD9Ftr.js';
 
 /**
  * Per-thread Assistant context store.