@zhin.js/adapter-slack 1.1.20 → 1.1.21

package/CHANGELOG.md

@@ -1,5 +1,48 @@
 # Changelog
 
+## 1.1.21
+
+### Patch Changes
+
+- af8f803: Use the current Endpoint's platform profile for Agent account identity, with per-field configured fallbacks and scoped, identity-approved profile tools. Keep SOUL first-person and independent of account names. Profile ports preserve the source Client, cancellation, truthful update outcomes and private image authority.
+
+  Adapter Feature API 2.1 and Tool Feature API 1.1 describe the additive profile requirements; new Core, official adapters and generated plugins declare the corresponding floors. Existing compatible API-2.0/API-1.0 plugins remain accepted by the newer providers. npm releases remain patch.
+
+  Private IM assets now bind to the full canonical conversation and principal. Existing IM asset records that contain only the earlier lossy hash remain on disk until their original expiry, but cannot be safely rebound; recapture them. No automatic file deletion, platform profile mutation or workspace SOUL rewrite occurs during upgrade.
+
+- 26fda97: Deliver validated final answers progressively through configured QQ C2C, Telegram drafts, Slack streams, Lark cards and Sandbox updates. Keep complete-message delivery for unsupported scenes, disabled adapters and outbound middleware that does not explicitly support revisions. Discord retains complete-message delivery.
+
+  Preserve source-account leases, media order and confirmed delivery facts across cancellation, capacity rollover and follow-up answer phases. Preview drafts and uncertain outcomes do not become sent history. Bound each reply's semantic snapshot to 1 MiB, retain confirmed prefixes on failure and avoid replaying published answers.
+
+  Project the latest confirmed message revision into paginated conversation history and synchronize Sandbox message updates across connections. Existing adapter implementations and complete-send callers remain compatible.
+
+- 976886c: Preserve confirmed progressive reply content, routing and delivery evidence across cancellation, rollover and closing failures without replaying published text. Keep error dispositions and actual message references, and abort the owning provider request when its functional text consumer fails.
+
+  Enable native Sandbox Markdown through the real Core projection so Console updates retain formatting in one message. Preserve instance-level streaming opt-outs, recall tombstones and multi-page synchronization. The first safe content is immediate; later updates retain the configured pacing, including large valid intervals.
+
+  Keep Slack and Lark Markdown streaming within the current physical message. When continuation formatting cannot be verified, stop and retain confirmed content instead of replaying or silently changing it to plain text. Plain-text continuations retain their original reply route.
+
+  Use rebuildable revision metadata and indexes in the existing conversation event table for bounded SQL history reads. Original event JSON and retention remain unchanged; older writers and models keep their compatible read path. Supported adapter streaming remains enabled by default, with complete-message fallback for disabled settings or outbound middleware without incremental: true.
+
+- Updated dependencies [b88e988]
+- Updated dependencies [f78eb84]
+- Updated dependencies [c15cef9]
+- Updated dependencies [b0c02a2]
+- Updated dependencies [af8f803]
+- Updated dependencies [26fda97]
+- Updated dependencies [976886c]
+- Updated dependencies [032dc96]
+  - @zhin.js/adapter@1.1.27
+  - @zhin.js/client@1.1.23
+  - @zhin.js/im-contract@1.1.10
+  - @zhin.js/core@1.1.55
+  - @zhin.js/tool@1.1.14
+  - @zhin.js/page@1.1.13
+  - @zhin.js/host-http@1.1.13
+  - @zhin.js/agent-feature@1.1.12
+  - @zhin.js/feature-kit@1.1.11
+  - @zhin.js/skill@1.1.12
+
 ## 1.1.20
 
 ### Patch Changes

package/README.md

@@ -10,6 +10,18 @@ Zhin.js Slack 适配器（Plugin Runtime），优先 Socket Mode，也可经 Run
 - 约定式 `defineAdapter` / `definePlugin`（无需 `usePlugin`）
 - Block Kit 按钮、斜杠命令、消息编辑、表情反应等（见 `tools/`）
 
+## 渐进式回复
+
+`streaming` 默认 `true`，可在插件或单个 endpoint 配置中设为 `false`，恢复普通完整发送。原生流使用同一条消息的 `chat.startStream`、`chat.appendStream` 与 `chat.stopStream`；全程固定为 `chunks` 模式，正文和 Markdown 按已确认的源码前缀追加。
+
+私聊和普通频道都需要既有线程或明确的引用目标；普通频道还需要可信的发言者和 workspace。缺少这些信息时保留普通发送，不为获得流式能力创建新线程。引用和 @ 前缀只提交一次；未知结果不重发。媒体和按钮由统一发送链按原始顺序投递，不重复上传。
+
+`streamingIntervalMs` 默认 `1000` 毫秒，用于后续回复更新间隔；首段立即发送，中间更新由统一回复控制器合并。
+
+原生流的累计正文上限为 12,000 字符，总时长上限为 10 分钟，追加内容不会延长时限。平台明确返回已有流已结束时，纯文字回复保留已确认正文，在同一话题的新消息中继续未发送的部分；发送结果未知时不重发。详见 [Slack 原生流限制](https://docs.slack.dev/reference/methods/chat.startStream/#stream-timeout)。
+
+纯文字可以在已确认的容量或时限边界续条。Markdown 保留单容器内的流式发送；需要续容器但无法保证独立格式时，会停止并保留已确认部分，不降级为纯文本。
+
 ## 安装
 
 ```bash

package/lib/adapter.js

@@ -17,6 +17,7 @@ export class SlackAdapter extends Adapter {
     get configurationIdentityProbeFields() { return ['token', 'appToken', 'signingSecret']; }
     get configurationUpdateFields() {
         return ['token', 'appToken', 'signingSecret', 'socketMode',
+            'streaming', 'streamingIntervalMs',
             'webhookPath', 'clientPingTimeout', 'webApiProxy', 'webApiProxy.port', 'streamProxy', 'streamProxy.port', 'streamProxy.serverName'];
     }
     validateConfiguration(config) { resolveSlackConfig(config); }

package/lib/console-spec.js

@@ -6,6 +6,8 @@ export const slackConsoleSpec = {
         { key: 'signingSecret', env: true, description: '签名密钥（HTTP Events，socketMode: false 必填）', descriptionI18n: { en: 'Signing secret (required for HTTP Events)' } },
         { key: 'appToken', env: true, description: 'App-Level Token（xapp-...，Socket Mode）', descriptionI18n: { en: 'App-level token (xapp-..., Socket Mode)' } },
         { key: 'socketMode', type: 'boolean', description: 'Socket Mode; false selects HTTP Events' },
+        { key: 'streaming', type: 'boolean', description: '生成时逐步显示回复', descriptionI18n: { en: 'Show replies progressively while generating' } },
+        { key: 'streamingIntervalMs', type: 'number', description: '回复更新间隔（毫秒）', descriptionI18n: { en: 'Reply update interval in milliseconds' } },
         { key: 'webhookPath', description: 'HTTP Events route' },
         { key: 'clientPingTimeout', type: 'number', description: 'SDK client ping timeout in milliseconds' },
         { key: 'webApiProxy.port', type: 'number', description: 'Configured Web API loopback proxy port' },

package/lib/endpoint.js

@@ -5,6 +5,7 @@ import { WebClient } from '@slack/web-api';
 import { SocketModeClient } from '@slack/socket-mode';
 import { createSlackStreamAgent } from './stream-proxy.js';
 import { slackSocketConnectionError } from './socket-error.js';
+import { createSlackSelfProfile } from './self-profile.js';
 import { slackWebClientOptions, slackDeliveryError } from './web-client.js';
 import { createEndpointSpecification, endpointSpec, createEndpointLifecycle, createEndpointOperation, } from 'zhin.js/adapter';
 import { formatCompact, getAdapterLogger } from '@zhin.js/logger';
@@ -16,6 +17,7 @@ import { postSlackEphemeral } from './slack-response-url.js';
 import { editSlackContent, sendSlackContent } from './slack-outbound.js';
 import { registerSlackWebhookRoutes } from './webhook.js';
 import { receiveSlackSideEvent } from './side-event-dispatch.js';
+import { openSlackReplyStream, supportsSlackReplyStream } from './reply-stream.js';
 export class SlackEndpoint extends WebClient {
     [endpointSpec];
     #logger;
@@ -69,6 +71,12 @@ export class SlackEndpoint extends WebClient {
             stop: () => this.#stopFramework(), send: request => this.#sendFramework(request),
             name: options.config.id, get transportState() { return endpoint.#transportState; },
             management: this.#management, control: this.#control,
+            ...(options.config.streaming !== false ? { streaming: { mode: 'native',
+                    minIntervalMs: options.config.streamingIntervalMs ?? 1000,
+                    supports: supportsSlackReplyStream,
+                    open: (request) => openSlackReplyStream(this, request, ts => this.trackMessageChannel(ts, request.conversation.id)),
+                } } : {}),
+            profile: createSlackSelfProfile({ client: this, accountId: () => this.#botUserId }),
         });
     }
     /** Console 展示 / AdapterIndex live name（多 endpoint 时与 entry name 一致）。 */
@@ -107,6 +115,8 @@ export class SlackEndpoint extends WebClient {
             const authTest = await this.auth.test();
             if (authTest.user_id)
                 this.#botUserId = String(authTest.user_id);
+            if (this.#botUserId)
+                this[endpointSpec].reportSelfUserId(this.#botUserId);
             this.#logger.info(`connected (${config.mode})`
                 + (this.#botUserId ? ` | user: ${this.#botUserId}` : ''));
         }

package/lib/native-stream.d.ts

@@ -0,0 +1,12 @@
+import type { WebClient, ChatStartStreamArguments, ChatAppendStreamArguments } from '@slack/web-api';
+type StreamContent = Pick<ChatAppendStreamArguments, 'markdown_text' | 'chunks'>;
+type StreamTarget = Pick<ChatStartStreamArguments, 'channel' | 'thread_ts' | 'recipient_team_id' | 'recipient_user_id'>;
+type StreamClient = Pick<WebClient['chat'], 'startStream' | 'appendStream' | 'stopStream'>;
+/** Slack's native stream always uses one content mode and one confirmed message identity. */
+export declare function createSlackNativeStream(chat: StreamClient, target: StreamTarget, signal?: AbortSignal): {
+    readonly messageTs: string | undefined;
+    readonly finalizedByPlatform: boolean;
+    append(content: StreamContent): Promise<string>;
+    stop(): Promise<string | undefined>;
+};
+export {};

package/lib/native-stream.js

@@ -0,0 +1,86 @@
+import { createEndpointOperation } from 'zhin.js/adapter';
+import { EndpointDeliveryError } from '@zhin.js/im-contract';
+import { slackDeliveryError } from './web-client.js';
+import { ErrorCode } from '@slack/web-api';
+/** Slack's native stream always uses one content mode and one confirmed message identity. */
+export function createSlackNativeStream(chat, target, signal) {
+    const operation = createEndpointOperation({ signal });
+    let ts;
+    let mode;
+    let stopped = false;
+    let finalizedByPlatform = false;
+    let failure;
+    function assertOpen() {
+        if (failure)
+            throw failure;
+        if (stopped)
+            throw new EndpointDeliveryError('stream_closed', 'Slack stream is closed', 'not_sent');
+    }
+    function contentMode(content) {
+        const next = content.markdown_text !== undefined ? 'markdown_text' : 'chunks';
+        if (content.markdown_text !== undefined && content.chunks !== undefined
+            || content.markdown_text === undefined && content.chunks === undefined
+            || mode && mode !== next) {
+            throw new EndpointDeliveryError('invalid_payload', 'Slack stream content mode cannot change', 'not_sent');
+        }
+        mode = next;
+    }
+    function wasFinalized(error) {
+        const result = error;
+        // Slack documents that timed-out streams retain all previously accepted content.
+        // Only this explicit response with an existing identity proves the container is final.
+        if (!ts || result?.code !== ErrorCode.PlatformError || result.data?.error !== 'message_not_in_streaming_state')
+            return false;
+        stopped = true;
+        finalizedByPlatform = true;
+        return true;
+    }
+    return {
+        get messageTs() { return ts; },
+        get finalizedByPlatform() { return finalizedByPlatform; },
+        async append(content) {
+            assertOpen();
+            contentMode(content);
+            try {
+                const response = ts
+                    ? await operation.run(() => chat.appendStream({ channel: target.channel, ts: ts, ...content }))
+                    : await operation.run(() => chat.startStream({ ...target, ...content }));
+                if (!ts) {
+                    if (typeof response.ts !== 'string' || !response.ts.trim()) {
+                        throw new EndpointDeliveryError('delivery_unconfirmed', 'Slack stream returned no message timestamp', 'unknown');
+                    }
+                    ts = response.ts;
+                }
+                return ts;
+            }
+            catch (error) {
+                if (wasFinalized(error))
+                    throw new EndpointDeliveryError('stream_expired', 'Slack finalized the existing stream', 'not_sent');
+                failure = slackDeliveryError(error);
+                throw failure;
+            }
+        },
+        async stop() {
+            if (failure)
+                throw failure;
+            if (stopped)
+                return ts;
+            assertOpen();
+            if (!ts) {
+                stopped = true;
+                return undefined;
+            }
+            try {
+                await operation.run(() => chat.stopStream({ channel: target.channel, ts: ts }));
+                stopped = true;
+                return ts;
+            }
+            catch (error) {
+                if (wasFinalized(error))
+                    return ts;
+                failure = slackDeliveryError(error);
+                throw failure;
+            }
+        },
+    };
+}

package/lib/protocol.d.ts

@@ -1,7 +1,11 @@
+import type { EndpointProfileConfiguration } from 'zhin.js/adapter';
 import type { IncomingMessage } from 'node:http';
 import { type ConversationRef } from '@zhin.js/im-contract';
 /** One endpoint config after AdapterIndex expands `plugins.<instanceKey>.endpoints`. */
-export interface SlackEndpointConfig {
+export interface SlackEndpointConfig extends EndpointProfileConfiguration {
+    /** Native reply streaming is enabled unless explicitly disabled. */
+    readonly streaming?: boolean;
+    readonly streamingIntervalMs?: number;
     readonly webApiProxy?: import('./web-api-proxy.js').SlackWebApiProxy;
     readonly streamProxy?: import('./stream-proxy.js').SlackStreamProxy;
     readonly id: string;
@@ -14,6 +18,8 @@ export interface SlackEndpointConfig {
     readonly clientPingTimeout?: number;
 }
 export interface ResolvedSlackConfig {
+    readonly streaming?: boolean;
+    readonly streamingIntervalMs?: number;
     readonly webApiProxy?: import('./web-api-proxy.js').SlackWebApiProxy;
     readonly streamProxy?: import('./stream-proxy.js').SlackStreamProxy;
     readonly context: 'slack';

package/lib/protocol.js

@@ -14,6 +14,10 @@ function dropOutboundMedia(type, reason) {
 const SLACK_SIG_VERSION = 'v0';
 const MAX_TIMESTAMP_DRIFT_SECONDS = 300;
 export function resolveSlackConfig(config) {
+    if (config.streaming !== undefined && typeof config.streaming !== 'boolean')
+        throw new TypeError('Slack streaming must be a boolean');
+    if (config.streamingIntervalMs !== undefined && (!Number.isSafeInteger(config.streamingIntervalMs) || config.streamingIntervalMs < 0))
+        throw new TypeError('Slack streamingIntervalMs must be a non-negative integer');
     if (config.webApiProxy && (!Number.isInteger(config.webApiProxy.port) || config.webApiProxy.port < 1 || config.webApiProxy.port > 65535))
         throw new TypeError('Invalid Slack webApiProxy port');
     if (config.streamProxy && (!Number.isInteger(config.streamProxy.port) || config.streamProxy.port < 1 || config.streamProxy.port > 65535
@@ -34,6 +38,8 @@ export function resolveSlackConfig(config) {
         ...(config.webApiProxy ? { webApiProxy: config.webApiProxy } : {}),
         ...(config.streamProxy ? { streamProxy: config.streamProxy } : {}),
         context: 'slack',
+        streaming: config.streaming !== false,
+        streamingIntervalMs: config.streamingIntervalMs ?? 1000,
         id,
         token,
         mode,

package/lib/reply-stream.d.ts

@@ -0,0 +1,4 @@
+import type { WebClient } from '@slack/web-api';
+import type { EndpointMessageStream, EndpointStreamRequest } from 'zhin.js/adapter';
+export declare function supportsSlackReplyStream(request: Pick<EndpointStreamRequest, 'conversation' | 'source'>): boolean;
+export declare function openSlackReplyStream(client: WebClient, request: EndpointStreamRequest, onMessage: (ts: string) => void): EndpointMessageStream | undefined;

package/lib/reply-stream.js

@@ -0,0 +1,105 @@
+import { EndpointDeliveryError } from '@zhin.js/im-contract';
+import { createSlackNativeStream } from './native-stream.js';
+import { formatOutboundWire } from './protocol.js';
+import { formatSlackMessageRef, parseSlackMessageRef } from './slack-message-ref.js';
+export function supportsSlackReplyStream(request) {
+    const event = request.source?.event;
+    // A future reply prefix may select a thread; recipient authority cannot be supplied by the model.
+    return request.conversation.kind === 'private'
+        || Boolean(typeof event?.team_id === 'string' && event.team_id && request.source?.senderId);
+}
+export function openSlackReplyStream(client, request, onMessage) {
+    if (!supportsSlackReplyStream(request))
+        return undefined;
+    // A new physical message cannot inherit the previous native Markdown renderer state.
+    if (request.format === 'markdown' && request.continuation)
+        return undefined;
+    const prefix = request.prefix ?? [];
+    if (prefix.some(segment => segment.type !== 'reply' && segment.type !== 'mention'))
+        return undefined;
+    const wire = formatOutboundWire(prefix.length ? prefix : '');
+    const replyTo = wire.replyTo ?? request.continuation?.replyTo;
+    const quoted = replyTo ? parseSlackMessageRef(replyTo) : null;
+    if (quoted && quoted.channel !== request.conversation.id)
+        return undefined;
+    const threadTs = request.conversation.threadId ?? quoted?.ts ?? replyTo;
+    // Ordinary channel replies must not move into a new thread just to gain streaming.
+    if (!threadTs)
+        return undefined;
+    const event = request.source?.event;
+    const teamId = typeof event?.team_id === 'string' ? event.team_id : undefined;
+    const senderId = request.source?.senderId;
+    const native = createSlackNativeStream(client.chat, {
+        channel: request.conversation.id, thread_ts: threadTs,
+        ...(request.conversation.kind !== 'private' ? { recipient_team_id: teamId, recipient_user_id: senderId } : {}),
+    }, request.signal);
+    let acceptedText = '';
+    let cancelled = false;
+    let finished = false;
+    let exhausted = false;
+    let lastAcknowledgement;
+    const acknowledge = () => lastAcknowledgement = Object.freeze({
+        status: native.messageTs ? 'sent' : 'buffered',
+        ...(native.messageTs ? { messageId: formatSlackMessageRef(request.conversation.id, native.messageTs) } : {}),
+        acceptedText,
+        ...(exhausted ? { exhausted: true } : {}),
+    });
+    const write = async (text) => {
+        if (cancelled)
+            throw new EndpointDeliveryError('stream_cancelled', 'Slack stream was cancelled', 'not_sent');
+        if (finished)
+            return acknowledge();
+        if (!text.startsWith(acceptedText))
+            throw new EndpointDeliveryError('stream_rewrite', 'A confirmed reply prefix cannot change', 'not_sent');
+        if (native.finalizedByPlatform) {
+            exhausted = true;
+            return acknowledge();
+        }
+        let next = text;
+        if (wire.text.length + next.length > 12_000) {
+            exhausted = true;
+            if (request.format === 'markdown') {
+                if (!acceptedText)
+                    throw new EndpointDeliveryError('stream_capacity', 'Slack Markdown has no confirmed boundary within its container capacity', 'not_sent');
+                return acknowledge();
+            }
+            next = next.slice(0, Math.max(0, 12_000 - wire.text.length));
+            if (/[\uD800-\uDBFF]$/.test(next))
+                next = next.slice(0, -1);
+        }
+        if (next === acceptedText)
+            return acknowledge();
+        const delta = (native.messageTs ? '' : wire.text) + next.slice(acceptedText.length);
+        // Fixed chunks mode allows complete rich blocks without switching Slack's wire mode.
+        let ts;
+        try {
+            ts = await native.append({ chunks: [{ type: 'markdown_text', text: delta }] });
+        }
+        catch (error) {
+            if (!native.finalizedByPlatform)
+                throw error;
+            exhausted = true;
+            return acknowledge();
+        }
+        acceptedText = next;
+        onMessage(ts);
+        return acknowledge();
+    };
+    return {
+        get lastAcknowledgement() { return lastAcknowledgement; },
+        write,
+        async finish(text) {
+            if (finished)
+                return acknowledge();
+            await write(text);
+            if (cancelled)
+                throw new EndpointDeliveryError('stream_cancelled', 'Slack stream was cancelled', 'not_sent');
+            await native.stop();
+            finished = true;
+            if (native.finalizedByPlatform)
+                exhausted = true;
+            return acknowledge();
+        },
+        cancel() { cancelled = true; },
+    };
+}

package/lib/self-profile.d.ts

@@ -0,0 +1,9 @@
+import { type EndpointProfile } from 'zhin.js/adapter';
+import type { WebClient } from '@slack/web-api';
+interface SlackSelfProfileOptions {
+    readonly client: Pick<WebClient, 'users'>;
+    readonly accountId: () => string | undefined;
+}
+/** Bot-token reads use users.info. User-token-only profile mutations are not advertised. */
+export declare function createSlackSelfProfile({ client, accountId }: SlackSelfProfileOptions): EndpointProfile;
+export {};

package/lib/self-profile.js

@@ -0,0 +1,19 @@
+import { createEndpointOperation } from 'zhin.js/adapter';
+/** Bot-token reads use users.info. User-token-only profile mutations are not advertised. */
+export function createSlackSelfProfile({ client, accountId }) {
+    return Object.freeze({
+        writableFields: Object.freeze([]),
+        async read({ signal }) {
+            const id = accountId();
+            if (!id)
+                throw new Error('Slack self account is unavailable');
+            const response = await createEndpointOperation({ signal }).prepare(() => client.users.info({ user: id }));
+            if (!response.ok || response.user?.id !== id)
+                throw new Error('Slack returned no matching self profile');
+            const profile = response.user.profile;
+            const nickname = profile?.display_name || profile?.real_name || response.user.real_name || response.user.name;
+            return { ...(typeof nickname === 'string' ? { nickname } : {}),
+                ...(typeof profile?.image_512 === 'string' ? { avatar: profile.image_512 } : {}) };
+        },
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhin.js/adapter-slack",
-  "version": "1.1.20",
+  "version": "1.1.21",
   "description": "Zhin.js Slack adapter for Plugin Runtime (Socket Mode / HTTP Events)",
   "type": "module",
   "main": "./lib/index.js",
@@ -33,27 +33,27 @@
   "dependencies": {
     "@slack/socket-mode": "^2.0.7",
     "@slack/web-api": "^7.19.0",
-    "@zhin.js/adapter": "1.1.26",
-    "@zhin.js/agent-feature": "1.1.11",
-    "@zhin.js/client": "1.1.22",
+    "@zhin.js/adapter": "1.1.27",
+    "@zhin.js/agent-feature": "1.1.12",
+    "@zhin.js/client": "1.1.23",
     "@zhin.js/console-contract": "1.1.3",
-    "@zhin.js/core": "1.1.54",
-    "@zhin.js/feature-kit": "1.1.10",
-    "@zhin.js/host-http": "1.1.12",
-    "@zhin.js/im-contract": "1.1.9",
+    "@zhin.js/core": "1.1.55",
+    "@zhin.js/feature-kit": "1.1.11",
+    "@zhin.js/host-http": "1.1.13",
+    "@zhin.js/im-contract": "1.1.10",
     "@zhin.js/logger": "1.1.2",
-    "@zhin.js/page": "1.1.12",
-    "@zhin.js/skill": "1.1.11",
-    "@zhin.js/tool": "1.1.13"
+    "@zhin.js/page": "1.1.13",
+    "@zhin.js/skill": "1.1.12",
+    "@zhin.js/tool": "1.1.14"
   },
   "peerDependencies": {
     "zod": "^4.0.0",
-    "@zhin.js/adapter": "^1.1.26",
-    "@zhin.js/command": "^1.1.12",
-    "@zhin.js/core": "^1.1.54",
-    "@zhin.js/host-http": "^1.1.12",
-    "@zhin.js/permission": "^1.1.10",
-    "zhin.js": "^1.1.19"
+    "@zhin.js/adapter": "^1.1.27",
+    "@zhin.js/command": "^1.1.13",
+    "@zhin.js/core": "^1.1.55",
+    "@zhin.js/host-http": "^1.1.13",
+    "@zhin.js/permission": "^1.1.11",
+    "zhin.js": "^1.1.20"
   },
   "peerDependenciesMeta": {
     "@zhin.js/command": {
@@ -71,7 +71,7 @@
     "typescript": "^6.0.3",
     "vitest": "^4.1.10",
     "zod": "^4.4.3",
-    "zhin.js": "1.1.19"
+    "zhin.js": "1.1.20"
   },
   "files": [
     "adapters",
@@ -103,7 +103,7 @@
     "features": [
       {
         "package": "@zhin.js/adapter",
-        "api": "^2.0.0"
+        "api": "^2.1.0"
       },
       {
         "package": "@zhin.js/command",
@@ -111,7 +111,7 @@
       },
       {
         "package": "@zhin.js/tool",
-        "api": "^1.0.0"
+        "api": "^1.1.0"
       },
       {
         "package": "@zhin.js/skill",

package/schema.json

@@ -154,6 +154,36 @@
                 "description": "Fault proxy for outbound JSON Web APIs only: pin slack.com:443 TCP to loopback while preserving SNI and certificate validation. Independent of the Socket proxy; does not apply to upload hosts."
               }
             }
+          },
+          "streaming": {
+            "type": "boolean",
+            "description": "Use native streaming replies when the target supports them."
+          },
+          "streamingIntervalMs": {
+            "type": "integer",
+            "minimum": 0,
+            "description": "Reply stream update interval in milliseconds."
+          },
+          "nickname": {
+            "type": [
+              "string",
+              "null"
+            ],
+            "description": "账号昵称兜底",
+            "x-i18n": {
+              "en": {
+                "description": "Fallback account nickname"
+              }
+            }
+          },
+          "profile": {
+            "$ref": "#/$defs/selfProfileFallback",
+            "description": "账号资料兜底",
+            "x-i18n": {
+              "en": {
+                "description": "Fallback account profile"
+              }
+            }
           }
         },
         "required": [
@@ -176,9 +206,104 @@
           "description": "Command prefix. The default empty string allows unprefixed commands; '/' requires a leading slash. Each endpoints[i] can override it."
         }
       }
+    },
+    "streaming": {
+      "type": "boolean",
+      "default": true,
+      "description": "Use native streaming replies when the target supports them."
+    },
+    "streamingIntervalMs": {
+      "type": "integer",
+      "minimum": 0,
+      "description": "Reply stream update interval in milliseconds.",
+      "default": 1000
+    },
+    "nickname": {
+      "type": [
+        "string",
+        "null"
+      ],
+      "description": "账号昵称兜底",
+      "x-i18n": {
+        "en": {
+          "description": "Fallback account nickname"
+        }
+      }
+    },
+    "profile": {
+      "$ref": "#/$defs/selfProfileFallback",
+      "description": "账号资料兜底",
+      "x-i18n": {
+        "en": {
+          "description": "Fallback account profile"
+        }
+      }
     }
   },
   "required": [
     "endpoints"
-  ]
+  ],
+  "$defs": {
+    "selfProfileFallback": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "gender": {
+          "type": [
+            "string",
+            "null"
+          ],
+          "enum": [
+            "male",
+            "female",
+            "other",
+            "unknown",
+            null
+          ]
+        },
+        "age": {
+          "type": [
+            "integer",
+            "null"
+          ],
+          "minimum": 0
+        },
+        "birthday": {
+          "type": [
+            "string",
+            "null"
+          ],
+          "pattern": "^\\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$"
+        },
+        "signature": {
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "avatar": {
+          "type": [
+            "string",
+            "null"
+          ],
+          "pattern": "^(https?://[^\\s/?#]+(?:[/?#].*)?|)$"
+        },
+        "interests": {
+          "type": [
+            "array",
+            "null"
+          ],
+          "items": {
+            "type": "string"
+          }
+        },
+        "bio": {
+          "type": [
+            "string",
+            "null"
+          ]
+        }
+      }
+    }
+  }
 }

package/src/adapter.ts

@@ -12,6 +12,7 @@ export class SlackAdapter extends Adapter<SlackEndpoint, SlackEndpointConfig, Sl
   override get configurationIdentityFields(): readonly string[] { return ['id']; }
   override get configurationIdentityProbeFields(): readonly string[] { return ['token', 'appToken', 'signingSecret']; }
   override get configurationUpdateFields(): readonly string[] { return ['token', 'appToken', 'signingSecret', 'socketMode',
+    'streaming', 'streamingIntervalMs',
     'webhookPath', 'clientPingTimeout', 'webApiProxy', 'webApiProxy.port', 'streamProxy', 'streamProxy.port', 'streamProxy.serverName']; }
   protected override validateConfiguration(config: SlackEndpointConfig): void { resolveSlackConfig(config); }
   protected override async identifyConfiguration(input: SlackEndpointConfig, signal: AbortSignal, changedFields: readonly string[]): Promise<string | undefined> {

package/src/console-spec.ts

@@ -11,6 +11,8 @@ export const slackConsoleSpec = {
     { key: 'signingSecret', env: true, description: '签名密钥（HTTP Events，socketMode: false 必填）', descriptionI18n: { en: 'Signing secret (required for HTTP Events)' } },
     { key: 'appToken', env: true, description: 'App-Level Token（xapp-...，Socket Mode）', descriptionI18n: { en: 'App-level token (xapp-..., Socket Mode)' } },
     { key: 'socketMode', type: 'boolean', description: 'Socket Mode; false selects HTTP Events' },
+    { key: 'streaming', type: 'boolean', description: '生成时逐步显示回复', descriptionI18n: { en: 'Show replies progressively while generating' } },
+    { key: 'streamingIntervalMs', type: 'number', description: '回复更新间隔（毫秒）', descriptionI18n: { en: 'Reply update interval in milliseconds' } },
     { key: 'webhookPath', description: 'HTTP Events route' },
     { key: 'clientPingTimeout', type: 'number', description: 'SDK client ping timeout in milliseconds' },
     { key: 'webApiProxy.port', type: 'number', description: 'Configured Web API loopback proxy port' },

package/src/endpoint.ts

@@ -6,6 +6,7 @@ import { SocketModeClient } from '@slack/socket-mode';
 import { createSlackWebApiAgent } from './web-api-proxy.js';
 import { createSlackStreamAgent } from './stream-proxy.js';
 import { slackSocketConnectionError } from './socket-error.js';
+import { createSlackSelfProfile } from './self-profile.js';
 import { slackWebClientOptions, slackDeliveryError } from './web-client.js';
 import {
   createEndpointSpecification,
@@ -48,6 +49,7 @@ import { postSlackEphemeral } from './slack-response-url.js';
 import { editSlackContent, sendSlackContent, type SlackChatClient, type SlackEditRequest } from './slack-outbound.js';
 import { registerSlackWebhookRoutes, type SlackWebhookHandler } from './webhook.js';
 import { receiveSlackSideEvent } from './side-event-dispatch.js';
+import { openSlackReplyStream, supportsSlackReplyStream } from './reply-stream.js';
 
 export interface SlackSocketLike {
   on(
@@ -124,6 +126,13 @@ export class SlackEndpoint extends WebClient implements Endpoint, SlackWebhookHa
       stop: () => this.#stopFramework(), send: request => this.#sendFramework(request),
       name: options.config.id, get transportState() { return endpoint.#transportState; },
       management: this.#management, control: this.#control,
+      ...(options.config.streaming !== false ? { streaming: { mode: 'native' as const,
+        minIntervalMs: options.config.streamingIntervalMs ?? 1000,
+        supports: supportsSlackReplyStream,
+        open: (request: import('zhin.js/adapter').EndpointStreamRequest) => openSlackReplyStream(this, request,
+          ts => this.trackMessageChannel(ts, request.conversation.id)),
+      } } : {}),
+      profile: createSlackSelfProfile({ client: this, accountId: () => this.#botUserId }),
     });
   }
 
@@ -166,6 +175,7 @@ export class SlackEndpoint extends WebClient implements Endpoint, SlackWebhookHa
 
       const authTest = await this.auth.test();
       if (authTest.user_id) this.#botUserId = String(authTest.user_id);
+      if (this.#botUserId) this[endpointSpec].reportSelfUserId(this.#botUserId);
 
       this.#logger.info(
         `connected (${config.mode})`

package/src/native-stream.ts

@@ -0,0 +1,79 @@
+import type { WebClient, ChatStartStreamArguments, ChatAppendStreamArguments } from '@slack/web-api';
+import { createEndpointOperation } from 'zhin.js/adapter';
+import { EndpointDeliveryError } from '@zhin.js/im-contract';
+import { slackDeliveryError } from './web-client.js';
+import { ErrorCode } from '@slack/web-api';
+
+type StreamContent = Pick<ChatAppendStreamArguments, 'markdown_text' | 'chunks'>;
+type StreamTarget = Pick<ChatStartStreamArguments, 'channel' | 'thread_ts' | 'recipient_team_id' | 'recipient_user_id'>;
+type StreamClient = Pick<WebClient['chat'], 'startStream' | 'appendStream' | 'stopStream'>;
+
+/** Slack's native stream always uses one content mode and one confirmed message identity. */
+export function createSlackNativeStream(chat: StreamClient, target: StreamTarget, signal?: AbortSignal) {
+  const operation = createEndpointOperation({ signal });
+  let ts: string | undefined;
+  let mode: 'markdown_text' | 'chunks' | undefined;
+  let stopped = false;
+  let finalizedByPlatform = false;
+  let failure: EndpointDeliveryError | undefined;
+
+  function assertOpen() {
+    if (failure) throw failure;
+    if (stopped) throw new EndpointDeliveryError('stream_closed', 'Slack stream is closed', 'not_sent');
+  }
+  function contentMode(content: StreamContent) {
+    const next = content.markdown_text !== undefined ? 'markdown_text' : 'chunks';
+    if (content.markdown_text !== undefined && content.chunks !== undefined
+      || content.markdown_text === undefined && content.chunks === undefined
+      || mode && mode !== next) {
+      throw new EndpointDeliveryError('invalid_payload', 'Slack stream content mode cannot change', 'not_sent');
+    }
+    mode = next;
+  }
+  function wasFinalized(error: unknown): boolean {
+    const result = error as { code?: unknown; data?: { error?: unknown } } | undefined;
+    // Slack documents that timed-out streams retain all previously accepted content.
+    // Only this explicit response with an existing identity proves the container is final.
+    if (!ts || result?.code !== ErrorCode.PlatformError || result.data?.error !== 'message_not_in_streaming_state') return false;
+    stopped = true; finalizedByPlatform = true;
+    return true;
+  }
+
+  return {
+    get messageTs() { return ts; },
+    get finalizedByPlatform() { return finalizedByPlatform; },
+    async append(content: StreamContent): Promise<string> {
+      assertOpen();
+      contentMode(content);
+      try {
+        const response = ts
+          ? await operation.run(() => chat.appendStream({ channel: target.channel, ts: ts!, ...content }))
+          : await operation.run(() => chat.startStream({ ...target, ...content }));
+        if (!ts) {
+          if (typeof response.ts !== 'string' || !response.ts.trim()) {
+            throw new EndpointDeliveryError('delivery_unconfirmed', 'Slack stream returned no message timestamp', 'unknown');
+          }
+          ts = response.ts;
+        }
+        return ts!;
+      } catch (error) {
+        if (wasFinalized(error)) throw new EndpointDeliveryError('stream_expired', 'Slack finalized the existing stream', 'not_sent');
+        failure = slackDeliveryError(error); throw failure;
+      }
+    },
+    async stop(): Promise<string | undefined> {
+      if (failure) throw failure;
+      if (stopped) return ts;
+      assertOpen();
+      if (!ts) { stopped = true; return undefined; }
+      try {
+        await operation.run(() => chat.stopStream({ channel: target.channel, ts: ts! }));
+        stopped = true;
+        return ts;
+      } catch (error) {
+        if (wasFinalized(error)) return ts;
+        failure = slackDeliveryError(error); throw failure;
+      }
+    },
+  };
+}

package/src/protocol.ts

@@ -1,3 +1,4 @@
+import type { EndpointProfileConfiguration } from 'zhin.js/adapter';
 /**
  * Slack protocol helpers — no legacy Adapter/Endpoint / segment-mapper.
  * Canonicalization is owned by gateway/core before endpoint.send.
@@ -19,7 +20,10 @@ const SLACK_SIG_VERSION = 'v0';
 const MAX_TIMESTAMP_DRIFT_SECONDS = 300;
 
 /** One endpoint config after AdapterIndex expands `plugins.<instanceKey>.endpoints`. */
-export interface SlackEndpointConfig {
+export interface SlackEndpointConfig extends EndpointProfileConfiguration {
+  /** Native reply streaming is enabled unless explicitly disabled. */
+  readonly streaming?: boolean;
+  readonly streamingIntervalMs?: number;
   readonly webApiProxy?: import('./web-api-proxy.js').SlackWebApiProxy;
   readonly streamProxy?: import('./stream-proxy.js').SlackStreamProxy;
   readonly id: string;
@@ -33,6 +37,8 @@ export interface SlackEndpointConfig {
 }
 
 export interface ResolvedSlackConfig {
+  readonly streaming?: boolean;
+  readonly streamingIntervalMs?: number;
   readonly webApiProxy?: import('./web-api-proxy.js').SlackWebApiProxy;
   readonly streamProxy?: import('./stream-proxy.js').SlackStreamProxy;
   readonly context: 'slack';
@@ -125,6 +131,8 @@ export interface SlackWireSegment {
 export interface SlackBlock { readonly type: string; readonly block_id?: string; readonly [key: string]: unknown }
 
 export function resolveSlackConfig(config: SlackEndpointConfig): ResolvedSlackConfig {
+  if (config.streaming !== undefined && typeof config.streaming !== 'boolean') throw new TypeError('Slack streaming must be a boolean');
+  if (config.streamingIntervalMs !== undefined && (!Number.isSafeInteger(config.streamingIntervalMs) || config.streamingIntervalMs < 0)) throw new TypeError('Slack streamingIntervalMs must be a non-negative integer');
   if (config.webApiProxy && (!Number.isInteger(config.webApiProxy.port) || config.webApiProxy.port < 1 || config.webApiProxy.port > 65535)) throw new TypeError('Invalid Slack webApiProxy port');
   if (config.streamProxy && (!Number.isInteger(config.streamProxy.port) || config.streamProxy.port < 1 || config.streamProxy.port > 65535
     || typeof config.streamProxy.serverName !== 'string' || !config.streamProxy.serverName || /[\s/:@?#]/.test(config.streamProxy.serverName) || config.streamProxy.serverName === 'slack.com')) throw new TypeError('Invalid Slack streamProxy port/serverName');
@@ -145,6 +153,8 @@ export function resolveSlackConfig(config: SlackEndpointConfig): ResolvedSlackCo
     ...(config.webApiProxy ? { webApiProxy: config.webApiProxy } : {}),
     ...(config.streamProxy ? { streamProxy: config.streamProxy } : {}),
     context: 'slack',
+    streaming: config.streaming !== false,
+    streamingIntervalMs: config.streamingIntervalMs ?? 1000,
     id,
     token,
     mode,

package/src/reply-stream.ts

@@ -0,0 +1,88 @@
+import type { WebClient } from '@slack/web-api';
+import type { EndpointMessageStream, EndpointStreamRequest, EndpointStreamAcknowledgement } from 'zhin.js/adapter';
+import { EndpointDeliveryError } from '@zhin.js/im-contract';
+import { createSlackNativeStream } from './native-stream.js';
+import { formatOutboundWire } from './protocol.js';
+import { formatSlackMessageRef, parseSlackMessageRef } from './slack-message-ref.js';
+
+export function supportsSlackReplyStream(request: Pick<EndpointStreamRequest, 'conversation' | 'source'>): boolean {
+  const event = request.source?.event as { team_id?: unknown } | undefined;
+  // A future reply prefix may select a thread; recipient authority cannot be supplied by the model.
+  return request.conversation.kind === 'private'
+    || Boolean(typeof event?.team_id === 'string' && event.team_id && request.source?.senderId);
+}
+
+export function openSlackReplyStream(client: WebClient, request: EndpointStreamRequest,
+  onMessage: (ts: string) => void): EndpointMessageStream | undefined {
+  if (!supportsSlackReplyStream(request)) return undefined;
+  // A new physical message cannot inherit the previous native Markdown renderer state.
+  if (request.format === 'markdown' && request.continuation) return undefined;
+  const prefix = request.prefix ?? [];
+  if (prefix.some(segment => segment.type !== 'reply' && segment.type !== 'mention')) return undefined;
+  const wire = formatOutboundWire(prefix.length ? prefix : '');
+  const replyTo = wire.replyTo ?? request.continuation?.replyTo;
+  const quoted = replyTo ? parseSlackMessageRef(replyTo) : null;
+  if (quoted && quoted.channel !== request.conversation.id) return undefined;
+  const threadTs = request.conversation.threadId ?? quoted?.ts ?? replyTo;
+  // Ordinary channel replies must not move into a new thread just to gain streaming.
+  if (!threadTs) return undefined;
+  const event = request.source?.event as { team_id?: unknown } | undefined;
+  const teamId = typeof event?.team_id === 'string' ? event.team_id : undefined;
+  const senderId = request.source?.senderId;
+  const native = createSlackNativeStream(client.chat, {
+    channel: request.conversation.id, thread_ts: threadTs,
+    ...(request.conversation.kind !== 'private' ? { recipient_team_id: teamId, recipient_user_id: senderId } : {}),
+  }, request.signal);
+  let acceptedText = '';
+  let cancelled = false;
+  let finished = false;
+  let exhausted = false;
+  let lastAcknowledgement: EndpointStreamAcknowledgement | undefined;
+  const acknowledge = (): EndpointStreamAcknowledgement => lastAcknowledgement = Object.freeze({
+    status: native.messageTs ? 'sent' : 'buffered',
+    ...(native.messageTs ? { messageId: formatSlackMessageRef(request.conversation.id, native.messageTs) } : {}),
+    acceptedText,
+    ...(exhausted ? { exhausted: true } : {}),
+  });
+  const write = async (text: string) => {
+    if (cancelled) throw new EndpointDeliveryError('stream_cancelled', 'Slack stream was cancelled', 'not_sent');
+    if (finished) return acknowledge();
+    if (!text.startsWith(acceptedText)) throw new EndpointDeliveryError('stream_rewrite', 'A confirmed reply prefix cannot change', 'not_sent');
+    if (native.finalizedByPlatform) { exhausted = true; return acknowledge(); }
+    let next = text;
+    if (wire.text.length + next.length > 12_000) {
+      exhausted = true;
+      if (request.format === 'markdown') {
+        if (!acceptedText) throw new EndpointDeliveryError('stream_capacity', 'Slack Markdown has no confirmed boundary within its container capacity', 'not_sent');
+        return acknowledge();
+      }
+      next = next.slice(0, Math.max(0, 12_000 - wire.text.length));
+      if (/[\uD800-\uDBFF]$/.test(next)) next = next.slice(0, -1);
+    }
+    if (next === acceptedText) return acknowledge();
+    const delta = (native.messageTs ? '' : wire.text) + next.slice(acceptedText.length);
+    // Fixed chunks mode allows complete rich blocks without switching Slack's wire mode.
+    let ts: string;
+    try { ts = await native.append({ chunks: [{ type: 'markdown_text', text: delta }] }); }
+    catch (error) {
+      if (!native.finalizedByPlatform) throw error;
+      exhausted = true;
+      return acknowledge();
+    }
+    acceptedText = next; onMessage(ts);
+    return acknowledge();
+  };
+  return {
+    get lastAcknowledgement() { return lastAcknowledgement; },
+    write,
+    async finish(text) {
+      if (finished) return acknowledge();
+      await write(text);
+      if (cancelled) throw new EndpointDeliveryError('stream_cancelled', 'Slack stream was cancelled', 'not_sent');
+      await native.stop(); finished = true;
+      if (native.finalizedByPlatform) exhausted = true;
+      return acknowledge();
+    },
+    cancel() { cancelled = true; },
+  };
+}

package/src/self-profile.ts

@@ -0,0 +1,24 @@
+import { createEndpointOperation, type EndpointProfile } from 'zhin.js/adapter';
+import type { WebClient } from '@slack/web-api';
+
+interface SlackSelfProfileOptions {
+  readonly client: Pick<WebClient, 'users'>;
+  readonly accountId: () => string | undefined;
+}
+
+/** Bot-token reads use users.info. User-token-only profile mutations are not advertised. */
+export function createSlackSelfProfile({ client, accountId }: SlackSelfProfileOptions): EndpointProfile {
+  return Object.freeze<EndpointProfile>({
+    writableFields: Object.freeze([]),
+    async read({ signal }) {
+      const id = accountId();
+      if (!id) throw new Error('Slack self account is unavailable');
+      const response = await createEndpointOperation({ signal }).prepare(() => client.users.info({ user: id }));
+      if (!response.ok || response.user?.id !== id) throw new Error('Slack returned no matching self profile');
+      const profile = response.user.profile;
+      const nickname = profile?.display_name || profile?.real_name || response.user.real_name || response.user.name;
+      return { ...(typeof nickname === 'string' ? { nickname } : {}),
+        ...(typeof profile?.image_512 === 'string' ? { avatar: profile.image_512 } : {}) };
+    },
+  });
+}