@cuylabs/channel-m365-slack-agent-core 0.3.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,32 @@
+# @cuylabs/channel-m365-slack-agent-core
+
+M365/Azure Bot Service Slack transport for `@cuylabs/agent-core`.
+
+Use this package when Slack traffic should arrive through Azure Bot Service and
+the Microsoft Agents hosting stack instead of Slack Bolt.
+
+```ts
+import { mountM365SlackAgent } from "@cuylabs/channel-m365-slack-agent-core";
+```
+
+Install:
+
+```bash
+pnpm add @cuylabs/channel-m365-slack-agent-core @cuylabs/channel-m365-slack @cuylabs/channel-slack @cuylabs/channel-m365-agent-core @microsoft/agents-hosting @microsoft/agents-activity express
+```
+
+This package depends on:
+
+- `@cuylabs/channel-m365-slack` for Slack payload parsing from M365
+  `channelData`
+- `@cuylabs/channel-slack` for shared Slack formatting, session, and ambient
+  context primitives
+- `@cuylabs/channel-m365-agent-core` for the Microsoft Agents / CloudAdapter base
+  transport
+- `@microsoft/agents-*` peers for runtime hosting types and adapters
+
+Internally this package imports only the
+`@cuylabs/channel-slack/core` subpath, so it does not depend on Bolt,
+Socket Mode, or direct Slack runtime code.
+
+See [docs/m365-slack.md](./docs/m365-slack.md) for setup and behavior details.

package/dist/index.d.ts

@@ -0,0 +1,230 @@
+import { M365ChannelAdapter, M365ChannelOptions, M365TurnRequestContext, M365TurnPreparation } from '@cuylabs/channel-m365-agent-core';
+import { TurnContext, AuthConfiguration, CloudAdapter } from '@microsoft/agents-hosting';
+import { SlackMessageFormattingOptions, SlackActivityInfo, SlackAmbientTurnContext } from '@cuylabs/channel-slack/core';
+import { Server } from 'node:http';
+import { AgentTurnSource } from '@cuylabs/agent-core';
+import { Application } from 'express';
+import { SlackM365ChannelData, SlackM365MessagePayload } from '@cuylabs/channel-m365-slack';
+export { SlackM365ChannelData, SlackM365MessagePayload, parseSlackM365Activity, parseSlackM365ChannelData } from '@cuylabs/channel-m365-slack';
+
+/**
+ * M365 Slack Channel Adapter
+ *
+ * Extends `@cuylabs/channel-m365-agent-core` to add Slack-specific parsing and
+ * ambient context when the agent is deployed via the Azure Bot Service Slack
+ * channel connector.
+ *
+ * This adapter is the Slack equivalent of `createTeamsChannelAdapter`:
+ * - It wraps `createM365ChannelAdapter` — you still use `CloudAdapter` and
+ *   `authorizeJWT`, and activities arrive as regular Bot Framework activities.
+ * - It enriches each turn with a parsed `SlackActivityInfo` from the
+ *   `activity.channelData.SlackMessage` payload that ABS embeds.
+ * - It stores Slack-specific scope attributes for observability.
+ * - It exposes `currentM365SlackTurnContext()` inside tools and middleware.
+ *
+ * ## When to use this vs `createSlackChannelAdapter`
+ *
+ * | | `createSlackChannelAdapter` | `createM365SlackChannelAdapter` |
+ * |---|---|---|
+ * | Transport | @slack/bolt directly | CloudAdapter + ABS Slack channel |
+ * | Azure Bot registration | Not needed | Required |
+ * | Shared Teams + Slack Azure reg | No | Yes |
+ * | Slack Block Kit / native API | Full control | Limited (ABS normalises) |
+ * | Auth/verification | Bolt signing secret | Entra JWT |
+ *
+ * ## Assistant pane limitation
+ *
+ * Azure Bot Service's Slack channel connector relays Slack `message` events
+ * as Bot Framework activities, but it does **not** relay
+ * `assistant_thread_started` / `assistant_thread_context_changed` events,
+ * and it does not surface Slack's assistant-pane utilities
+ * (`assistant.threads.setStatus` / `setSuggestedPrompts` / `setTitle`).
+ *
+ * If you need the modern Slack Assistant UX (status pane, suggested prompts,
+ * `chatStream` with `task_display_mode`, feedback blocks), use the direct
+ * Slack adapter package. Plain DM and `app_mention` flows work fine through
+ * this M365-backed path.
+ *
+ * @example
+ * ```ts
+ * import { mountM365SlackAgent } from "@cuylabs/channel-m365-slack-agent-core";
+ *
+ * await mountM365SlackAgent(agent);
+ * // → listens on /api/messages with CloudAdapter auth
+ * // Requires the same env vars as channel-m365-agent-core
+ * ```
+ */
+
+interface M365SlackTurnRequestContext extends M365TurnRequestContext {
+    /** Parsed Slack activity metadata (when channelId === "slack") */
+    slack: SlackActivityInfo;
+}
+type M365SlackTurnPreparation = M365TurnPreparation;
+interface M365SlackSessionRequestContext {
+    /** Raw M365 turn context for the active ABS Slack activity. */
+    turnContext: TurnContext;
+    /** Parsed Slack activity metadata. */
+    slack: SlackActivityInfo;
+    /** M365 conversation ID from the activity. */
+    conversationId: string;
+    /** M365 channel ID, normally `"slack"`. */
+    channelId: string;
+}
+/**
+ * Options for the M365-backed Slack channel adapter.
+ *
+ * Identical to `M365ChannelOptions` with one addition: `prepareTurn` receives
+ * a `M365SlackTurnRequestContext` that includes the parsed `slack` metadata.
+ */
+interface M365SlackChannelOptions extends Omit<M365ChannelOptions, "prepareTurn">, SlackMessageFormattingOptions {
+    /**
+     * Prepare an agent turn from the full Slack + M365 request context.
+     *
+     * Called for every message. Returns an optional system override, scope
+     * attributes, or per-turn ambient context.
+     */
+    prepareTurn?: (request: M365SlackTurnRequestContext) => M365SlackTurnPreparation | Promise<M365SlackTurnPreparation>;
+    /**
+     * Resolve the agent-core session ID from parsed Slack metadata.
+     *
+     * Use this for thread-aware Slack-via-ABS sessions. When omitted, the
+     * adapter preserves the base M365 `conversation-id` session behavior unless
+     * `sessionStrategy` / `resolveSessionId` are configured directly.
+     *
+     * @example
+     * ```ts
+     * resolveSession: ({ slack }) => resolveM365SlackThreadSessionId(slack)
+     * ```
+     */
+    resolveSession?: (request: M365SlackSessionRequestContext) => string | Promise<string>;
+    /**
+     * Hook called for every turn, before the adapter's own handling.
+     *
+     * Return `next()` to continue normal processing.
+     */
+    onTurn?: (context: TurnContext, next: () => Promise<void>) => Promise<void>;
+}
+/**
+ * The adapter returned by `createM365SlackChannelAdapter`.
+ *
+ * Exposes the underlying `m365` base adapter for advanced use cases.
+ */
+interface M365SlackChannelAdapter extends M365ChannelAdapter {
+    /**
+     * The underlying base M365 channel adapter.
+     */
+    m365: M365ChannelAdapter;
+}
+declare function createM365SlackChannelAdapter(options: M365SlackChannelOptions): M365SlackChannelAdapter;
+/**
+ * Read the parsed Slack activity info from the current M365 turn context.
+ *
+ * Works inside tools and middleware when using `createM365SlackChannelAdapter`.
+ * Returns `undefined` when called outside a Slack turn.
+ *
+ * ```ts
+ * import { currentM365SlackTurnContext } from "@cuylabs/channel-m365-slack-agent-core";
+ *
+ * const ctx = currentM365SlackTurnContext();
+ * ctx?.slack.channelId;   // "C01234..."
+ * ctx?.slack.threadTs;    // "1617000000.000100"
+ * ```
+ */
+declare function currentM365SlackTurnContext(): Readonly<SlackAmbientTurnContext> | undefined;
+declare function resolveM365SlackThreadSessionId(slack: SlackActivityInfo): string;
+
+/**
+ * Express integration for the M365-backed Slack channel adapter.
+ *
+ * Mirrors the Teams mounting style — uses `CloudAdapter`
+ * with Entra JWT auth, and serves the standard `/api/messages` route.
+ *
+ * Requires the same env vars as `mountM365Agent`:
+ * - `MicrosoftAppId`
+ * - `MicrosoftAppPassword`
+ * - `MicrosoftAppTenantId` (optional for multi-tenant)
+ *
+ * In Azure Bot Service you configure the Slack channel connector separately
+ * in the Azure portal — the agent code itself doesn't change.
+ *
+ * @example
+ * ```ts
+ * import { createAgent } from "@cuylabs/agent-core";
+ * import { anthropic } from "@ai-sdk/anthropic";
+ * import { mountM365SlackAgent } from "@cuylabs/channel-m365-slack-agent-core";
+ *
+ * const agent = createAgent({ model: anthropic("claude-sonnet-4-20250514") });
+ * await mountM365SlackAgent(agent);
+ * // → CloudAdapter listening on port 3978 at /api/messages
+ * ```
+ */
+
+interface MountM365SlackAgentOptions extends Omit<M365SlackChannelOptions, "agent" | "source"> {
+    /**
+     * Route path for the messages endpoint.
+     * @default "/api/messages"
+     */
+    path?: string;
+    /**
+     * M365 auth configuration. If not provided, loaded from environment
+     * variables (`MicrosoftAppId`, `MicrosoftAppPassword`, `MicrosoftAppTenantId`).
+     */
+    authConfig?: AuthConfiguration;
+    /**
+     * Port to listen on.
+     * Set to `null` to skip `app.listen()` — caller manages the server.
+     * @default process.env.PORT || 3978
+     */
+    port?: number | null;
+    /**
+     * Optional host/interface passed to `app.listen(port, host)`.
+     */
+    host?: string;
+    /**
+     * Pre-existing CloudAdapter instance.
+     */
+    adapter?: CloudAdapter;
+    /**
+     * Pre-existing Express app.
+     */
+    app?: Application;
+}
+interface MountM365SlackAgentResult {
+    /** The Express application */
+    app: Application;
+    /** The M365 Slack channel adapter */
+    channelAdapter: ReturnType<typeof createM365SlackChannelAdapter>;
+    /** The CloudAdapter instance */
+    cloudAdapter: CloudAdapter;
+    /** The Node HTTP server when `listen()` was started */
+    server?: Server;
+}
+/**
+ * Mount an agent-core-compatible turn source as a Slack bot via Azure Bot
+ * Service + CloudAdapter.
+ *
+ * This is identical to `mountTeamsAgent` in structure — it mounts a
+ * `POST /api/messages` route with Entra JWT auth. Azure Bot Service's Slack
+ * channel connector handles translating Slack events into Activities before
+ * they reach this endpoint.
+ */
+declare function mountM365SlackAgent(source: AgentTurnSource, options?: MountM365SlackAgentOptions): Promise<MountM365SlackAgentResult>;
+
+/**
+ * Slack channelData parsing for Azure Bot Service / Microsoft 365 Activity
+ * payloads.
+ *
+ * The parser itself lives in `@cuylabs/channel-m365-slack`; this adapter keeps
+ * the `TurnContext` convenience wrapper used by the agent-core runtime layer.
+ */
+
+type SlackABSMessagePayload = SlackM365MessagePayload;
+type SlackABSChannelData = SlackM365ChannelData;
+declare function parseSlackChannelData(channelData: unknown): SlackABSChannelData | undefined;
+/**
+ * Parse a `TurnContext` whose activity arrived via the Azure Bot Service Slack
+ * channel into a `SlackActivityInfo`.
+ */
+declare function parseSlackActivity(context: TurnContext): SlackActivityInfo | undefined;
+
+export { type M365SlackChannelAdapter, type M365SlackChannelOptions, type M365SlackSessionRequestContext, type M365SlackTurnPreparation, type M365SlackTurnRequestContext, type MountM365SlackAgentOptions, type MountM365SlackAgentResult, type SlackABSChannelData, type SlackABSMessagePayload, createM365SlackChannelAdapter, currentM365SlackTurnContext, mountM365SlackAgent, parseSlackActivity, parseSlackChannelData, resolveM365SlackThreadSessionId };

package/dist/index.js

@@ -0,0 +1,290 @@
+// src/adapter.ts
+import {
+  createM365ChannelAdapter,
+  currentM365TurnContext
+} from "@cuylabs/channel-m365-agent-core";
+import { AsyncLocalStorage } from "async_hooks";
+import {
+  resolveSlackMessageFormatter,
+  resolveThreadAwareSlackSessionId
+} from "@cuylabs/channel-slack/core";
+
+// src/channel-data.ts
+import {
+  parseSlackM365Activity,
+  parseSlackM365ChannelData
+} from "@cuylabs/channel-m365-slack";
+function parseSlackChannelData(channelData) {
+  return parseSlackM365ChannelData(channelData);
+}
+function parseSlackActivity(context) {
+  return parseSlackM365Activity(context.activity);
+}
+
+// src/adapter.ts
+function createM365SlackChannelAdapter(options) {
+  const {
+    agent,
+    prepareTurn,
+    onTurn: onTurnHook,
+    resolveSession,
+    resolveSessionId,
+    resolveMessage,
+    sessionStrategy,
+    source,
+    formatChatMarkdown,
+    formatMessageText,
+    ...baseOptions
+  } = options;
+  const sessionTurnContext = new AsyncLocalStorage();
+  const messageFormatter = resolveSlackMessageFormatter({
+    formatChatMarkdown,
+    formatMessageText
+  });
+  const turnSource = source ?? agent;
+  const base = createM365ChannelAdapter({
+    ...baseOptions,
+    ...turnSource ? {
+      source: wrapM365SlackSource(
+        turnSource,
+        messageFormatter,
+        sessionTurnContext
+      )
+    } : {},
+    ...resolveM365SlackSessionOptions({
+      resolveSession,
+      resolveSessionId,
+      sessionStrategy,
+      sessionTurnContext
+    }),
+    ...resolveMessage ? { resolveMessage } : {
+      resolveMessage: (context) => {
+        const slack = parseSlackActivity(context);
+        if (slack) {
+          return slack.text;
+        }
+        return context.activity.text;
+      }
+    },
+    prepareTurn: async (request) => {
+      const slack = parseSlackActivity(request.turnContext);
+      if (!slack && request.turnContext.activity.channelId !== "slack") {
+        return {};
+      }
+      const enrichedRequest = {
+        ...request,
+        slack: slack ?? buildFallbackSlackInfo(request)
+      };
+      const prepared = prepareTurn ? await prepareTurn(enrichedRequest) : void 0;
+      return {
+        ...prepared ?? {},
+        scopeName: prepared?.scopeName?.trim() || "slack-activity",
+        scopeAttributes: {
+          slackChannelId: enrichedRequest.slack.channelId,
+          slackChannelType: enrichedRequest.slack.channelType,
+          slackUserId: enrichedRequest.slack.userId,
+          slackTeamId: enrichedRequest.slack.teamId,
+          slackThreadTs: enrichedRequest.slack.threadTs,
+          slackIsMention: enrichedRequest.slack.isMention,
+          ...prepared?.scopeAttributes ?? {}
+        },
+        context: {
+          ...prepared?.context ?? {},
+          // Stored as "slack" key — read via currentM365SlackTurnContext()
+          slack: enrichedRequest.slack
+        }
+      };
+    }
+  });
+  async function coreHandler(context) {
+    if (context.activity.channelId !== "slack") {
+      await base.handler(context);
+      return;
+    }
+    await sessionTurnContext.run(context, () => base.handler(context));
+  }
+  async function handler(context) {
+    if (onTurnHook) {
+      await onTurnHook(context, () => coreHandler(context));
+    } else {
+      await coreHandler(context);
+    }
+  }
+  return {
+    ...base,
+    handler,
+    m365: base
+  };
+}
+function currentM365SlackTurnContext() {
+  const m365 = currentM365TurnContext();
+  const slack = m365?.context?.slack;
+  if (!isSlackActivityInfo(slack) || !m365) return void 0;
+  return {
+    slackActivity: slack,
+    user: {
+      userId: slack.userId,
+      channelId: slack.channelId,
+      teamId: slack.teamId,
+      threadTs: slack.threadTs,
+      messageTs: slack.messageTs
+    },
+    sessionId: m365.sessionId,
+    message: m365.message,
+    context: m365.context
+  };
+}
+function resolveM365SlackSessionOptions({
+  resolveSession,
+  resolveSessionId,
+  sessionStrategy,
+  sessionTurnContext
+}) {
+  if (!resolveSession) {
+    return {
+      ...sessionStrategy ? { sessionStrategy } : {},
+      ...resolveSessionId ? { resolveSessionId } : {}
+    };
+  }
+  return {
+    sessionStrategy: "custom",
+    resolveSessionId: async (conversationId, channelId) => {
+      const turnContext = sessionTurnContext.getStore();
+      if (!turnContext || turnContext.activity.channelId !== "slack") {
+        return resolveSessionId ? resolveSessionId(conversationId, channelId) : conversationId;
+      }
+      return resolveSession({
+        turnContext,
+        conversationId,
+        channelId,
+        slack: parseSlackActivity(turnContext) ?? buildFallbackSlackInfoFromTurn(turnContext, conversationId)
+      });
+    }
+  };
+}
+function wrapM365SlackSource(source, formatMessageText, sessionTurnContext) {
+  return {
+    async *chat(sessionId, message, options) {
+      const shouldFormat = sessionTurnContext.getStore()?.activity.channelId === "slack";
+      for await (const event of source.chat(sessionId, message, options)) {
+        if (shouldFormat && event.type === "text-delta") {
+          yield { ...event, text: formatMessageText(event.text) };
+          continue;
+        }
+        if (shouldFormat && event.type === "complete" && event.output) {
+          yield { ...event, output: formatMessageText(event.output) };
+          continue;
+        }
+        yield event;
+      }
+    }
+  };
+}
+function buildFallbackSlackInfoFromTurn(turnContext, conversationId) {
+  return {
+    channelId: conversationId,
+    channelType: "unknown",
+    userId: turnContext.activity.from?.id ?? "unknown",
+    teamId: turnContext.activity.conversation?.tenantId,
+    threadTs: void 0,
+    messageTs: void 0,
+    text: turnContext.activity.text ?? "",
+    isMention: false
+  };
+}
+function resolveM365SlackThreadSessionId(slack) {
+  return resolveThreadAwareSlackSessionId(slack);
+}
+function buildFallbackSlackInfo(request) {
+  const userId = request.user.userId;
+  const channelId = request.user.conversationId;
+  return {
+    channelId,
+    channelType: "unknown",
+    userId,
+    teamId: request.user.tenantId,
+    threadTs: void 0,
+    messageTs: void 0,
+    text: request.message,
+    isMention: false
+  };
+}
+function isSlackActivityInfo(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return typeof candidate.channelId === "string" && typeof candidate.channelType === "string" && typeof candidate.userId === "string" && typeof candidate.text === "string" && typeof candidate.isMention === "boolean";
+}
+
+// src/express.ts
+import {
+  adaptJwtMiddleware,
+  processWithAdapter
+} from "@cuylabs/channel-m365-agent-core/express-compat";
+async function mountM365SlackAgent(source, options = {}) {
+  const expressModule = await import("express");
+  const hostingModule = await import("@microsoft/agents-hosting");
+  const {
+    path: routePath = "/api/messages",
+    authConfig: providedAuthConfig,
+    port: portOption,
+    host,
+    adapter: providedAdapter,
+    app: providedApp,
+    ...adapterOptions
+  } = options;
+  const authConfig = hostingModule.getAuthConfigWithDefaults(providedAuthConfig);
+  const cloudAdapter = providedAdapter ?? new hostingModule.CloudAdapter(authConfig);
+  const expressApp = providedApp ?? expressModule.default();
+  const channelAdapter = createM365SlackChannelAdapter({
+    source,
+    ...adapterOptions
+  });
+  const jsonParser = expressModule.json();
+  const jwtAuthorizer = adaptJwtMiddleware(hostingModule, authConfig);
+  expressApp.post(
+    routePath,
+    jsonParser,
+    jwtAuthorizer,
+    (req, res) => processWithAdapter(
+      cloudAdapter,
+      req,
+      res,
+      (context) => channelAdapter.handler(context)
+    )
+  );
+  const port = portOption === void 0 ? resolvePort(process.env.PORT) : portOption;
+  let server;
+  if (port !== null) {
+    const onListen = () => {
+      process.stdout.write(
+        `M365 Slack agent listening on port ${port} \u2014 appId: ${authConfig.clientId ?? "(not set)"}
+`
+      );
+    };
+    server = host ? expressApp.listen(port, host, onListen) : expressApp.listen(port, onListen);
+  }
+  return {
+    app: expressApp,
+    channelAdapter,
+    cloudAdapter,
+    server
+  };
+}
+function resolvePort(port) {
+  if (!port) return 3978;
+  const parsed = Number(port);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    throw new Error(`Invalid PORT value: ${port}`);
+  }
+  return parsed;
+}
+export {
+  createM365SlackChannelAdapter,
+  currentM365SlackTurnContext,
+  mountM365SlackAgent,
+  parseSlackActivity,
+  parseSlackChannelData,
+  parseSlackM365Activity,
+  parseSlackM365ChannelData,
+  resolveM365SlackThreadSessionId
+};

package/docs/m365-slack.md

@@ -0,0 +1,139 @@
+# M365-Backed Slack Mode
+
+Use this mode when Slack traffic should share the same Azure Bot Service and
+`@microsoft/agents-hosting` stack you already use for Microsoft 365 channels.
+
+## Main APIs
+
+- `createM365SlackChannelAdapter(...)`
+- `mountM365SlackAgent(...)`
+- `currentM365SlackTurnContext()`
+- `parseSlackChannelData(...)`
+- `parseSlackActivity(...)`
+- `resolveM365SlackThreadSessionId(...)`
+
+## Required Dependencies
+
+```bash
+pnpm add @cuylabs/channel-m365-slack-agent-core @cuylabs/channel-m365-slack @cuylabs/channel-slack @cuylabs/channel-m365-agent-core @microsoft/agents-hosting @microsoft/agents-activity express
+```
+
+The adapter uses `@cuylabs/channel-m365-slack` to parse Slack payloads embedded
+in M365 `channelData`, and `@cuylabs/channel-slack/core` for shared Slack
+formatting, session, and context primitives. It does not import Bolt, Socket
+Mode, or direct Slack app runtime code.
+
+## Required Environment
+
+```bash
+OPENAI_API_KEY=...
+MicrosoftAppId=...
+MicrosoftAppPassword=...
+MicrosoftAppTenantId=...
+PORT=3978
+```
+
+## Endpoint Shape
+
+This path uses the same default endpoint as the M365 package:
+
+```text
+/api/messages
+```
+
+Azure Bot Service should be configured to deliver Slack-originated activities
+to that endpoint.
+
+## What Happens on the Wire
+
+Azure Bot Service normalizes Slack events into Bot Framework activities:
+
+- `activity.channelId === "slack"`
+- Slack-native metadata is embedded in `activity.channelData`
+- the raw Slack message payload is typically available as `channelData.SlackMessage`
+
+This package turns that embedded payload back into `SlackActivityInfo` so your
+agent code can still reason about Slack concepts like:
+
+- channel ID
+- thread timestamp
+- user ID
+- Slack channel type
+- mention status and other Slack message metadata when ABS preserved it
+
+## Quick Start
+
+```ts
+import { createAgent } from "@cuylabs/agent-core";
+import { openai } from "@ai-sdk/openai";
+import { mountM365SlackAgent } from "@cuylabs/channel-m365-slack-agent-core";
+
+const agent = createAgent({
+  model: openai("gpt-4o-mini"),
+});
+
+await mountM365SlackAgent(agent, {
+  prepareTurn: ({ slack, user }) => ({
+    system: `Help Slack user ${slack.userId}.`,
+    scopeName: "slack-activity",
+    scopeAttributes: {
+      slackChannelId: slack.channelId,
+      tenantId: user.tenantId,
+    },
+  }),
+});
+```
+
+By default, M365-backed Slack inherits the base M365 conversation-session
+behavior. If you want Slack thread sessions, wire the Slack resolver explicitly:
+
+```ts
+import {
+  createM365SlackChannelAdapter,
+  resolveM365SlackThreadSessionId,
+} from "@cuylabs/channel-m365-slack-agent-core";
+
+const adapter = createM365SlackChannelAdapter({
+  source: agent,
+  resolveSession: ({ slack }) => resolveM365SlackThreadSessionId(slack),
+});
+```
+
+## When This Mode Is a Good Fit
+
+- you already run Teams or other M365 channels through `channel-m365-agent-core`
+- you want one ingress/auth pattern for both Teams and Slack
+- you are comfortable reasoning at the Bot Framework transport layer
+
+## Limits Compared to Direct Slack
+
+This is not a full replacement for native Bolt when you need every Slack-native surface.
+
+Compared with direct Slack mode:
+
+- the host transport is mediated through Azure Bot Service
+- Slack payload details depend on what ABS preserves in `channelData`
+- Slack-native install/event management happens in Azure and Slack configuration, not purely in your app code
+- Slack Assistant pane events such as `assistant_thread_started` and
+  `assistant_thread_context_changed` do not arrive as native Bolt Assistant
+  lifecycle callbacks
+- Assistant utilities such as `assistant.threads.setStatus`,
+  `setSuggestedPrompts`, `setTitle`, and native `chatStream` task display mode
+  are direct-Slack features
+- Block Kit action callbacks and modal submissions used by
+  `createSlackInteractiveController(...)` are direct-Slack features; ABS does
+  not preserve them as the direct Bolt path does
+
+## Parsing Helpers
+
+Use `parseSlackChannelData(...)` when you need the raw ABS-specific shape.
+
+Use `parseSlackActivity(...)` when you want the normalized `SlackActivityInfo`.
+
+That distinction matters:
+
+- `parseSlackChannelData(...)` is the transport detail
+- `parseSlackActivity(...)` is the application-facing abstraction
+
+Inside tools or middleware, use `currentM365SlackTurnContext()` to read the
+Slack activity metadata parsed from the M365 ambient turn context.

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@cuylabs/channel-m365-slack-agent-core",
+  "version": "0.3.0",
+  "description": "M365/Azure Bot Service Slack transport for @cuylabs/agent-core",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "docs",
+    "README.md"
+  ],
+  "dependencies": {
+    "@cuylabs/agent-core": "^7.2.0",
+    "@cuylabs/channel-m365": "^0.3.0",
+    "@cuylabs/channel-m365-agent-core": "^0.3.0",
+    "@cuylabs/channel-m365-slack": "^0.3.0",
+    "@cuylabs/channel-slack": "^0.3.0"
+  },
+  "peerDependencies": {
+    "@microsoft/agents-activity": "^1.5.0",
+    "@microsoft/agents-hosting": "^1.5.0",
+    "express": ">=4.21.0 || >=5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "express": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@microsoft/agents-activity": "^1.5.3",
+    "@microsoft/agents-hosting": "^1.5.3",
+    "@types/express": "^5.0.0",
+    "@types/node": "^22.0.0",
+    "express": "^5.2.1",
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^4.0.18"
+  },
+  "keywords": [
+    "agent",
+    "slack",
+    "m365",
+    "azure-bot-service",
+    "channel"
+  ],
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cuylabs-ai/agent-channels-ts.git",
+    "directory": "packages/channel-m365-slack-agent-core"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --dts --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "clean": "rm -rf dist"
+  }
+}