@appthen/sdk-react 0.0.0

package/dist/ChatHubComposer.d.ts

@@ -0,0 +1,18 @@
+export interface ChatHubComposerOption {
+    label: string;
+    value: string;
+}
+export interface ChatHubComposerProps {
+    senderOptions: ChatHubComposerOption[];
+    selectedSenderId: string;
+    onSelectedSenderIdChange: (senderId: string) => void;
+    draft: string;
+    onDraftChange: (draft: string) => void;
+    onSend: () => void | Promise<void>;
+    disabled?: boolean;
+    busy?: boolean;
+    placeholder?: string;
+    sendLabel?: string;
+    className?: string;
+}
+export declare function ChatHubComposer(props: ChatHubComposerProps): import("react").JSX.Element;

package/dist/ChatHubComposer.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export function ChatHubComposer(props) {
+    const { senderOptions, selectedSenderId, onSelectedSenderIdChange, draft, onDraftChange, onSend, disabled, busy, placeholder, sendLabel, className, } = props;
+    const handleDraftChange = (event) => {
+        onDraftChange(event.target.value);
+    };
+    return (_jsxs("div", { className: className || 'grid gap-3 md:grid-cols-[220px_minmax(0,1fr)_auto]', children: [_jsx("select", { className: "flex h-10 w-full rounded-md border border-input bg-[var(--vscode-input-background)] px-3 py-2 text-sm", value: selectedSenderId, onChange: (event) => onSelectedSenderIdChange(event.target.value), disabled: disabled, children: senderOptions.map((option) => (_jsx("option", { value: option.value, children: option.label }, option.value))) }), _jsx("input", { className: "flex h-10 w-full rounded-md border border-input bg-[var(--vscode-input-background)] px-3 py-2 text-sm", value: draft, onChange: handleDraftChange, placeholder: placeholder || '输入一条消息', disabled: disabled }), _jsx("button", { type: "button", className: "inline-flex h-10 items-center justify-center rounded-md bg-primary px-4 text-sm font-medium text-primary-foreground disabled:cursor-not-allowed disabled:opacity-50", onClick: () => void onSend(), disabled: disabled || !draft.trim(), children: busy ? '发送中...' : sendLabel || '发送' })] }));
+}

package/dist/ChatHubDefaultBodyRenderers.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from 'react';
+import type { ConversationMessageRecord } from '@appthen/sdk-core';
+import { type ChatHubMessageBodyRenderers } from './ChatHubMessageBody';
+export interface ChatHubDefaultBodyRendererOptions {
+    renderMarkdown?: (markdown: string, message: ConversationMessageRecord) => ReactNode;
+    overrides?: ChatHubMessageBodyRenderers;
+}
+export declare function createChatHubDefaultBodyRenderers(options?: ChatHubDefaultBodyRendererOptions): ChatHubMessageBodyRenderers;

package/dist/ChatHubDefaultBodyRenderers.js

@@ -0,0 +1,74 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+function resolveText(value) {
+    return typeof value === 'string' && value.trim() ? value : undefined;
+}
+function renderPlainMarkdown(markdown) {
+    return _jsx("div", { className: "whitespace-pre-wrap leading-6", children: markdown });
+}
+function renderForwardedMessage(message) {
+    const senderSubjectId = resolveText(message.content?.senderSubjectId) ||
+        resolveText(message.content?.originalSenderSubjectId) ||
+        '未知发送人';
+    const previewText = resolveText(message.content?.previewText) ||
+        resolveText(message.content?.text) ||
+        resolveText(message.content?.summary) ||
+        '转发了一条消息';
+    const sourceConversationId = resolveText(message.content?.sourceConversationId);
+    const sourceConversationTitle = resolveText(message.content?.sourceConversationTitle) ||
+        (message.metadata &&
+            typeof message.metadata === 'object' &&
+            typeof message.metadata.sourceConversationTitle === 'string' &&
+            message.metadata.sourceConversationTitle.trim()
+            ? message.metadata.sourceConversationTitle.trim()
+            : undefined);
+    const kind = resolveText(message.content?.originalKind);
+    return (_jsxs("div", { className: "rounded-2xl border border-border/60 bg-muted/20 px-3 py-3", children: [_jsx("div", { className: "text-xs font-medium text-muted-foreground", children: "\u8F6C\u53D1\u6D88\u606F" }), _jsxs("div", { className: "mt-2 rounded-xl border border-border/60 bg-background/90 px-3 py-2", children: [_jsx("div", { className: "text-xs font-medium text-foreground", children: senderSubjectId }), _jsx("div", { className: "mt-1 whitespace-pre-wrap text-sm leading-6 text-foreground/90", children: previewText }), sourceConversationId || kind ? (_jsx("div", { className: "mt-2 text-[11px] text-muted-foreground", children: [
+                            kind ? `类型: ${kind}` : null,
+                            sourceConversationTitle
+                                ? `来源会话: ${sourceConversationTitle}`
+                                : sourceConversationId
+                                    ? `来源会话: ${sourceConversationId}`
+                                    : null,
+                        ]
+                            .filter(Boolean)
+                            .join(' · ') })) : null] })] }));
+}
+function renderEventCard(message, tone) {
+    const title = resolveText(message.content?.title) ||
+        resolveText(message.content?.eventType) ||
+        resolveText(message.kind) ||
+        '事件';
+    const summary = resolveText(message.content?.summary) ||
+        resolveText(message.content?.text) ||
+        resolveText(message.content?.message);
+    const status = resolveText(message.content?.status);
+    const details = resolveText(message.content?.details);
+    const toneClass = tone === 'success'
+        ? 'border-emerald-500/30 bg-emerald-500/10'
+        : tone === 'warning'
+            ? 'border-amber-500/30 bg-amber-500/10'
+            : 'border-border/60 bg-muted/40';
+    return (_jsxs("div", { className: `rounded-md border px-3 py-2 ${toneClass}`, children: [_jsxs("div", { className: "flex flex-wrap items-center gap-2", children: [_jsx("span", { className: "text-sm font-medium", children: title }), status ? (_jsx("span", { className: "rounded border border-border/60 px-1.5 py-0.5 text-[11px] uppercase tracking-wide text-muted-foreground", children: status })) : null] }), summary ? (_jsx("div", { className: "mt-1 whitespace-pre-wrap text-sm text-foreground/90", children: summary })) : null, details ? (_jsx("div", { className: "mt-2 whitespace-pre-wrap text-xs text-muted-foreground", children: details })) : null] }));
+}
+export function createChatHubDefaultBodyRenderers(options) {
+    const markdownRenderer = (message) => {
+        const markdown = resolveText(message.content?.markdown) ||
+            resolveText(message.content?.text) ||
+            '';
+        if (!markdown) {
+            return null;
+        }
+        return options?.renderMarkdown
+            ? options.renderMarkdown(markdown, message)
+            : renderPlainMarkdown(markdown);
+    };
+    return {
+        markdown: markdownRenderer,
+        forwarded_message: renderForwardedMessage,
+        status_event: (message) => renderEventCard(message, 'success'),
+        lifecycle_event: (message) => renderEventCard(message, 'neutral'),
+        approval_event: (message) => renderEventCard(message, 'warning'),
+        event: (message) => renderEventCard(message, 'neutral'),
+        ...(options?.overrides || {}),
+    };
+}

package/dist/ChatHubMessageActions.d.ts

@@ -0,0 +1,10 @@
+import type { ConversationMessageRecord } from '@appthen/sdk-core';
+import type { ChatHubActionSurface, ChatHubMessageActionItem } from './useChatHubMessageActions';
+export interface ChatHubMessageActionsProps {
+    message: ConversationMessageRecord;
+    actions: ChatHubMessageActionItem[];
+    surface?: ChatHubActionSurface;
+    className?: string;
+    onActionRun?: (action: ChatHubMessageActionItem, message: ConversationMessageRecord) => void;
+}
+export declare function ChatHubMessageActions(props: ChatHubMessageActionsProps): import("react").JSX.Element | null;

package/dist/ChatHubMessageActions.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+function resolveSurfaceClassName(surface) {
+    if (surface === 'sheet') {
+        return 'flex flex-col gap-2';
+    }
+    if (surface === 'menu') {
+        return 'flex flex-col gap-1';
+    }
+    return 'flex flex-wrap items-center gap-2';
+}
+export function ChatHubMessageActions(props) {
+    const { message, actions, surface = 'inline', className, onActionRun, } = props;
+    const visibleActions = actions.filter((action) => !action.hidden);
+    if (visibleActions.length === 0) {
+        return null;
+    }
+    return (_jsx("div", { className: className || resolveSurfaceClassName(surface), "data-chat-hub-action-surface": surface, role: "toolbar", "aria-label": "\u6D88\u606F\u64CD\u4F5C", children: visibleActions.map((action) => (_jsx("button", { type: "button", className: [
+                'inline-flex min-h-8 items-center justify-center rounded-full border px-2.5 text-[11px] font-medium transition-colors',
+                surface === 'inline'
+                    ? 'border-border/60 bg-background/80 text-muted-foreground hover:border-border hover:bg-muted/70 hover:text-foreground'
+                    : 'border-transparent bg-accent/40 text-foreground hover:bg-accent/70',
+                action.destructive
+                    ? 'text-destructive hover:border-destructive/20 hover:bg-destructive/10 hover:text-destructive'
+                    : '',
+                action.pending ? 'opacity-80' : '',
+            ]
+                .filter(Boolean)
+                .join(' '), onClick: () => {
+                onActionRun?.(action, message);
+                void action.run();
+            }, disabled: action.disabled || action.pending, "aria-label": action.description || action.label, "data-pending": action.pending ? 'true' : 'false', "data-action-id": action.id, children: action.pending ? `${action.label}中...` : action.shortLabel || action.label }, action.id))) }));
+}

package/dist/ChatHubMessageBody.d.ts

@@ -0,0 +1,9 @@
+import type { ReactNode } from 'react';
+import type { ConversationMessageRecord } from '@appthen/sdk-core';
+export type ChatHubMessageBodyRenderer = (message: ConversationMessageRecord) => ReactNode;
+export type ChatHubMessageBodyRenderers = Partial<Record<string, ChatHubMessageBodyRenderer>>;
+export interface ChatHubMessageBodyProps {
+    message: ConversationMessageRecord;
+    renderers?: ChatHubMessageBodyRenderers;
+}
+export declare function ChatHubMessageBody(props: ChatHubMessageBodyProps): import("react").JSX.Element;

package/dist/ChatHubMessageBody.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+function defaultRenderBody(message) {
+    const text = message.content?.text;
+    if (typeof text === 'string') {
+        // 必须用 whitespace-pre-wrap 容器：React 裸字符串节点会按 HTML 规则折叠连续空白
+        // （包括 \n），导致 markdown 表格全部挤成一行。pre-wrap 保留换行和空格。
+        return _jsx("div", { className: "whitespace-pre-wrap leading-6", children: text });
+    }
+    return (_jsx("div", { className: "whitespace-pre-wrap leading-6 text-xs text-muted-foreground", children: JSON.stringify(message.content || {}) }));
+}
+function renderMutedMessageBody(status) {
+    const label = status === 'deleted' ? '消息已删除' : '消息已撤回';
+    return (_jsx("div", { className: "rounded-2xl border border-dashed border-border/60 bg-muted/20 px-3 py-2 text-sm text-muted-foreground", children: label }));
+}
+export function ChatHubMessageBody(props) {
+    const { message, renderers } = props;
+    if (message.status === 'deleted' || message.status === 'revoked') {
+        return _jsx(_Fragment, { children: renderMutedMessageBody(message.status) });
+    }
+    const renderer = (message.kind && renderers?.[message.kind]) || renderers?.default;
+    return _jsx(_Fragment, { children: renderer ? renderer(message) : defaultRenderBody(message) });
+}

package/dist/ChatHubMessageTimeline.d.ts

@@ -0,0 +1,13 @@
+import type { ReactNode } from 'react';
+import type { ConversationMessageRecord } from '@appthen/sdk-core';
+import { type ChatHubMessageBodyRenderers } from './ChatHubMessageBody';
+export interface ChatHubMessageTimelineProps {
+    messages: ConversationMessageRecord[];
+    emptyState?: ReactNode;
+    className?: string;
+    renderBody?: (message: ConversationMessageRecord) => ReactNode;
+    renderTimestamp?: (message: ConversationMessageRecord) => ReactNode;
+    renderMeta?: (message: ConversationMessageRecord) => ReactNode;
+    bodyRenderers?: ChatHubMessageBodyRenderers;
+}
+export declare function ChatHubMessageTimeline(props: ChatHubMessageTimelineProps): import("react").JSX.Element;

package/dist/ChatHubMessageTimeline.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ChatHubMessageBody, } from './ChatHubMessageBody';
+function defaultResolveTime(message) {
+    const createdAt = typeof message.createdAt === 'string' ? message.createdAt : undefined;
+    const updatedAt = typeof message.updatedAt === 'string' ? message.updatedAt : undefined;
+    const value = createdAt || updatedAt;
+    if (!value)
+        return '-';
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? value : date.toLocaleString();
+}
+export function ChatHubMessageTimeline(props) {
+    const { messages, emptyState, className, renderBody, renderTimestamp, renderMeta, bodyRenderers, } = props;
+    if (messages.length === 0) {
+        return (_jsx("div", { className: className, children: emptyState || (_jsx("div", { className: "rounded-lg border border-dashed border-border/60 px-4 py-10 text-center text-sm text-muted-foreground", children: "\u6682\u65E0\u6D88\u606F" })) }));
+    }
+    return (_jsx("div", { className: className || 'space-y-3', children: messages.map((message) => (_jsxs("div", { className: "rounded-lg border border-border/60 bg-card/70 px-4 py-3", children: [_jsxs("div", { className: "flex flex-wrap items-center justify-between gap-2", children: [_jsxs("div", { className: "flex items-center gap-2 text-sm font-medium", children: [_jsx("span", { className: "inline-flex rounded border border-border/60 px-2 py-0.5 text-xs", children: message.senderSubjectId }), _jsx("span", { children: message.kind || 'text' })] }), _jsx("span", { className: "text-xs text-muted-foreground", children: renderTimestamp ? renderTimestamp(message) : defaultResolveTime(message) })] }), _jsx("div", { className: "mt-2 whitespace-pre-wrap text-sm leading-6", children: renderBody ? (renderBody(message)) : (_jsx(ChatHubMessageBody, { message: message, renderers: bodyRenderers })) }), _jsx("div", { className: "mt-2 text-xs text-muted-foreground", children: renderMeta ? renderMeta(message) : `messageId: ${message.messageId}` })] }, message.messageId))) }));
+}

package/dist/index.d.ts

@@ -0,0 +1,53 @@
+import type { ChatHubAppConfig, ChatHubAppRuntime, ChatHubBootstrapResult, ConversationMessageRecord, ConversationRecord, ListChatHubMessagesPageResult, ListChatHubMessagesOptions, SendChatHubMessageOptions, SendTextMessageOptions, UpdateChatHubMessageOptions } from '@appthen/sdk-core';
+export { ChatHubMessageTimeline } from './ChatHubMessageTimeline';
+export { ChatHubComposer } from './ChatHubComposer';
+export { ChatHubMessageActions } from './ChatHubMessageActions';
+export { ChatHubMessageBody, type ChatHubMessageBodyRenderer, type ChatHubMessageBodyRenderers, } from './ChatHubMessageBody';
+export { createChatHubDefaultBodyRenderers, type ChatHubDefaultBodyRendererOptions, } from './ChatHubDefaultBodyRenderers';
+export { extractChatHubMessagePlainText, useChatHubMessageMutations, type ChatHubForwardDraftItem, type ForwardChatHubMessagesOptions, type ChatHubMutationActionState, type UseChatHubMessageMutationsOptions, type UseChatHubMessageMutationsResult, } from './useChatHubMessageMutations';
+export { useChatHubMessageActions, type ChatHubActionSurface, type ChatHubMessageActionItem, type UseChatHubMessageActionsOptions, type UseChatHubMessageActionsResult, } from './useChatHubMessageActions';
+export interface UseChatHubAppOptions {
+    runtime: ChatHubAppRuntime;
+    config: ChatHubAppConfig;
+    autoLoad?: boolean;
+    autoLoadMessages?: boolean;
+    initialConversationId?: string;
+}
+export interface UseChatHubAppResult {
+    config: ChatHubAppConfig;
+    runtime: ChatHubAppRuntime;
+    status: string;
+    error: string | null;
+    busy: boolean;
+    conversations: ConversationRecord[];
+    messages: ConversationMessageRecord[];
+    selectedConversationId: string;
+    setSelectedConversationId: (conversationId: string) => void;
+    selectedSenderId: string;
+    setSelectedSenderId: (subjectId: string) => void;
+    bootstrapConversation: () => Promise<ChatHubBootstrapResult | null>;
+    refreshConversations: () => Promise<void>;
+    refreshMessages: (conversationIdOrOptions?: string | (Partial<ListChatHubMessagesOptions> & {
+        mode?: 'replace' | 'prepend' | 'append';
+    })) => Promise<ConversationMessageRecord[]>;
+    refreshMessagesPage: (conversationIdOrOptions?: string | (Partial<ListChatHubMessagesOptions> & {
+        mode?: 'replace' | 'prepend' | 'append';
+    })) => Promise<ListChatHubMessagesPageResult>;
+    mergeMessages: (incoming: ConversationMessageRecord[], conversationId: string, mode?: 'replace' | 'prepend' | 'append') => void;
+    sendTextMessage: (input: Omit<SendTextMessageOptions, 'conversationId'> & {
+        conversationId?: string;
+    }) => Promise<ConversationMessageRecord | null>;
+    sendMessage: (input: Omit<SendChatHubMessageOptions, 'conversationId'> & {
+        conversationId?: string;
+    }) => Promise<ConversationMessageRecord | null>;
+    updateMessage: (input: UpdateChatHubMessageOptions & {
+        conversationId?: string;
+    }) => Promise<ConversationMessageRecord | null>;
+}
+export type ChatHubMessageMergeMode = 'replace' | 'prepend' | 'append';
+export declare function areConversationMessagesEqual(left: ConversationMessageRecord, right: ConversationMessageRecord): boolean;
+export declare function mergeConversationMessages(current: ConversationMessageRecord[], incoming: ConversationMessageRecord[], mode?: ChatHubMessageMergeMode): ConversationMessageRecord[];
+export declare function sortConversationMessages(messages: ConversationMessageRecord[]): ConversationMessageRecord[];
+export declare function filterConversationMessages(messages: ConversationMessageRecord[], conversationId: string): ConversationMessageRecord[];
+export declare function areConversationMessageListsEqual(left: ConversationMessageRecord[], right: ConversationMessageRecord[]): boolean;
+export declare function useChatHubApp(options: UseChatHubAppOptions): UseChatHubAppResult;

package/dist/index.js

@@ -0,0 +1,325 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+export { ChatHubMessageTimeline } from './ChatHubMessageTimeline';
+export { ChatHubComposer } from './ChatHubComposer';
+export { ChatHubMessageActions } from './ChatHubMessageActions';
+export { ChatHubMessageBody, } from './ChatHubMessageBody';
+export { createChatHubDefaultBodyRenderers, } from './ChatHubDefaultBodyRenderers';
+export { extractChatHubMessagePlainText, useChatHubMessageMutations, } from './useChatHubMessageMutations';
+export { useChatHubMessageActions, } from './useChatHubMessageActions';
+export function areConversationMessagesEqual(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+export function mergeConversationMessages(current, incoming, mode = 'replace') {
+    if (mode === 'replace') {
+        return sortConversationMessages(incoming);
+    }
+    const byId = new Map(current.map((message) => [message.messageId, message]));
+    for (const message of incoming) {
+        const existing = byId.get(message.messageId);
+        byId.set(message.messageId, existing && areConversationMessagesEqual(existing, message)
+            ? existing
+            : message);
+    }
+    if (mode === 'prepend') {
+        const incomingIds = new Set(incoming.map((message) => message.messageId));
+        return sortConversationMessages([
+            ...incoming.map((message) => byId.get(message.messageId) || message),
+            ...current.filter((message) => !incomingIds.has(message.messageId)),
+        ]);
+    }
+    const currentIds = new Set(current.map((message) => message.messageId));
+    return sortConversationMessages([
+        ...current.map((message) => byId.get(message.messageId) || message),
+        ...incoming
+            .filter((message) => !currentIds.has(message.messageId))
+            .map((message) => byId.get(message.messageId) || message),
+    ]);
+}
+function resolveMessageSequence(message) {
+    return typeof message.sequence === 'number' && Number.isFinite(message.sequence)
+        ? message.sequence
+        : null;
+}
+function resolveMessageTimestamp(message) {
+    const value = typeof message.createdAt === 'string'
+        ? message.createdAt
+        : typeof message.updatedAt === 'string'
+            ? message.updatedAt
+            : '';
+    const timestamp = value ? Date.parse(value) : NaN;
+    return Number.isFinite(timestamp) ? timestamp : 0;
+}
+function compareConversationMessages(left, right) {
+    const leftSequence = resolveMessageSequence(left);
+    const rightSequence = resolveMessageSequence(right);
+    if (leftSequence !== null && rightSequence !== null && leftSequence !== rightSequence) {
+        return leftSequence - rightSequence;
+    }
+    if (leftSequence !== null && rightSequence === null) {
+        return -1;
+    }
+    if (leftSequence === null && rightSequence !== null) {
+        return 1;
+    }
+    const timeDiff = resolveMessageTimestamp(left) - resolveMessageTimestamp(right);
+    if (timeDiff !== 0) {
+        return timeDiff;
+    }
+    return left.messageId.localeCompare(right.messageId);
+}
+export function sortConversationMessages(messages) {
+    return [...messages].sort(compareConversationMessages);
+}
+export function filterConversationMessages(messages, conversationId) {
+    return messages.filter((message) => message.conversationId === conversationId);
+}
+export function areConversationMessageListsEqual(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    return left.every((message, index) => {
+        const next = right[index];
+        return next ? areConversationMessagesEqual(message, next) : false;
+    });
+}
+export function useChatHubApp(options) {
+    const { runtime, config, autoLoad = true, autoLoadMessages = autoLoad, initialConversationId = '', } = options;
+    const [status, setStatus] = useState('准备中');
+    const [error, setError] = useState(null);
+    const [busy, setBusy] = useState(false);
+    const [conversations, setConversations] = useState([]);
+    const [messages, setMessages] = useState([]);
+    const [selectedConversationId, setSelectedConversationIdState] = useState(initialConversationId);
+    const selectedConversationIdRef = useRef(initialConversationId);
+    const refreshConversationsRequestSeqRef = useRef(0);
+    const [selectedSenderId, setSelectedSenderIdState] = useState(config.subjects?.[0]?.subjectId || '');
+    // ref 镜像：refreshConversations 等回调依赖里不含 selectedSenderId，闭包会过期，统一从 ref 读
+    const selectedSenderIdRef = useRef(selectedSenderId);
+    const setSelectedSenderId = useCallback((subjectId) => {
+        selectedSenderIdRef.current = subjectId;
+        setSelectedSenderIdState(subjectId);
+    }, []);
+    const setSelectedConversationId = useCallback((conversationId) => {
+        selectedConversationIdRef.current = conversationId;
+        setSelectedConversationIdState(conversationId);
+    }, []);
+    const mergeMessages = useCallback((incoming, conversationId, mode = 'replace') => {
+        if (conversationId !== selectedConversationIdRef.current) {
+            return;
+        }
+        const scopedIncoming = filterConversationMessages(incoming, conversationId);
+        if (mode === 'replace') {
+            setMessages((current) => {
+                const scopedCurrent = filterConversationMessages(current, conversationId);
+                return areConversationMessageListsEqual(scopedCurrent, scopedIncoming)
+                    ? current
+                    : scopedIncoming;
+            });
+            return;
+        }
+        setMessages((current) => {
+            const scopedCurrent = filterConversationMessages(current, conversationId);
+            const merged = mergeConversationMessages(scopedCurrent, scopedIncoming, mode);
+            return areConversationMessageListsEqual(scopedCurrent, merged)
+                ? current
+                : merged;
+        });
+    }, []);
+    useEffect(() => {
+        // config 变化时重置为默认主体；调用方仍可通过 setSelectedSenderId 覆写为真实用户身份
+        setSelectedSenderId(config.subjects?.[0]?.subjectId || '');
+    }, [config, setSelectedSenderId]);
+    const withBusy = useCallback(async (label, task) => {
+        setBusy(true);
+        setError(null);
+        setStatus(label);
+        try {
+            return await task();
+        }
+        catch (nextError) {
+            setError(nextError instanceof Error ? nextError.message : `${label}失败`);
+            setStatus(`${label}失败`);
+            return null;
+        }
+        finally {
+            setBusy(false);
+        }
+    }, []);
+    const refreshConversations = useCallback(async () => {
+        const requestSeq = ++refreshConversationsRequestSeqRef.current;
+        const list = await runtime.listConversations(selectedSenderIdRef.current);
+        if (requestSeq !== refreshConversationsRequestSeqRef.current) {
+            return;
+        }
+        setConversations(list);
+        setSelectedConversationIdState((current) => {
+            const next = current || list[0]?.conversationId || '';
+            selectedConversationIdRef.current = next;
+            return next;
+        });
+    }, [runtime]);
+    const refreshMessages = useCallback(async (conversationIdOrOptions) => {
+        const options = typeof conversationIdOrOptions === 'string'
+            ? {
+                conversationId: conversationIdOrOptions,
+                mode: 'replace',
+            }
+            : {
+                mode: 'replace',
+                ...(conversationIdOrOptions || {}),
+            };
+        const targetConversationId = options.conversationId || selectedConversationIdRef.current;
+        if (!targetConversationId) {
+            setMessages([]);
+            return [];
+        }
+        const list = await runtime.listMessages({
+            conversationId: targetConversationId,
+            limit: options.limit,
+            beforeCreatedAt: options.beforeCreatedAt,
+            afterSequence: options.afterSequence,
+        });
+        mergeMessages(list, targetConversationId, options.mode);
+        return list;
+    }, [mergeMessages, runtime]);
+    const refreshMessagesPage = useCallback(async (conversationIdOrOptions) => {
+        const options = typeof conversationIdOrOptions === 'string'
+            ? {
+                conversationId: conversationIdOrOptions,
+                mode: 'replace',
+            }
+            : {
+                mode: 'replace',
+                ...(conversationIdOrOptions || {}),
+            };
+        const targetConversationId = options.conversationId || selectedConversationIdRef.current;
+        if (!targetConversationId) {
+            setMessages([]);
+            return {
+                items: [],
+                hasMore: false,
+            };
+        }
+        const page = await runtime.listMessagesPage({
+            conversationId: targetConversationId,
+            limit: options.limit,
+            beforeCreatedAt: options.beforeCreatedAt,
+            afterSequence: options.afterSequence,
+        });
+        mergeMessages(page.items, targetConversationId, options.mode);
+        return page;
+    }, [mergeMessages, runtime]);
+    useEffect(() => {
+        if (!autoLoad) {
+            return;
+        }
+        refreshConversations().catch((nextError) => {
+            setError(nextError instanceof Error ? nextError.message : '加载会话失败');
+        });
+    }, [autoLoad, refreshConversations]);
+    useEffect(() => {
+        if (!autoLoad || !autoLoadMessages) {
+            return;
+        }
+        refreshMessages().catch((nextError) => {
+            setError(nextError instanceof Error ? nextError.message : '加载消息失败');
+        });
+    }, [autoLoad, autoLoadMessages, refreshMessages, selectedConversationId]);
+    const bootstrapConversation = useCallback(async () => {
+        const result = await withBusy('准备会话', async () => {
+            const bootstrap = await runtime.bootstrapConversation();
+            const conversationId = bootstrap.conversation?.conversationId || '';
+            setSelectedConversationId(conversationId);
+            await refreshConversations();
+            if (conversationId) {
+                await refreshMessages(conversationId);
+            }
+            setStatus('会话已就绪');
+            return bootstrap;
+        });
+        return result;
+    }, [refreshConversations, refreshMessages, runtime, withBusy]);
+    const sendTextMessage = useCallback(async (input) => {
+        const conversationId = input.conversationId || selectedConversationId;
+        if (!conversationId) {
+            return null;
+        }
+        const result = await withBusy('发送消息', async () => {
+            const message = await runtime.sendTextMessage({
+                ...input,
+                conversationId,
+            });
+            mergeMessages([message], conversationId, 'append');
+            setStatus('消息已发送');
+            return message;
+        });
+        return result;
+    }, [mergeMessages, runtime, selectedConversationId, withBusy]);
+    const sendMessage = useCallback(async (input) => {
+        const conversationId = input.conversationId || selectedConversationId;
+        if (!conversationId) {
+            return null;
+        }
+        const result = await withBusy('发送消息', async () => {
+            const message = await runtime.sendMessage({
+                ...input,
+                conversationId,
+            });
+            mergeMessages([message], conversationId, 'append');
+            setStatus('消息已发送');
+            return message;
+        });
+        return result;
+    }, [mergeMessages, runtime, selectedConversationId, withBusy]);
+    const updateMessage = useCallback(async (input) => {
+        const conversationId = input.conversationId || selectedConversationId;
+        const result = await withBusy('更新消息', async () => {
+            const message = await runtime.updateMessage(input);
+            if (conversationId) {
+                mergeMessages([message], conversationId, 'append');
+            }
+            setStatus('消息已更新');
+            return message;
+        });
+        return result;
+    }, [mergeMessages, runtime, selectedConversationId, withBusy]);
+    return useMemo(() => ({
+        config,
+        runtime,
+        status,
+        error,
+        busy,
+        conversations,
+        messages,
+        selectedConversationId,
+        setSelectedConversationId,
+        selectedSenderId,
+        setSelectedSenderId,
+        bootstrapConversation,
+        refreshConversations,
+        refreshMessages,
+        refreshMessagesPage,
+        mergeMessages,
+        sendTextMessage,
+        sendMessage,
+        updateMessage,
+    }), [
+        bootstrapConversation,
+        busy,
+        config,
+        conversations,
+        error,
+        messages,
+        refreshConversations,
+        refreshMessages,
+        refreshMessagesPage,
+        mergeMessages,
+        runtime,
+        sendMessage,
+        selectedConversationId,
+        selectedSenderId,
+        sendTextMessage,
+        status,
+        updateMessage,
+    ]);
+}

package/dist/useChatHubMessageActions.d.ts

@@ -0,0 +1,35 @@
+import type { ConversationMessageRecord } from '@appthen/sdk-core';
+import type { UseChatHubMessageMutationsResult } from './useChatHubMessageMutations';
+export type ChatHubActionSurface = 'inline' | 'menu' | 'sheet';
+export interface ChatHubMessageActionItem {
+    id: string;
+    label: string;
+    shortLabel?: string;
+    description?: string;
+    hidden?: boolean;
+    disabled?: boolean;
+    pending?: boolean;
+    destructive?: boolean;
+    preferredSurface?: ChatHubActionSurface;
+    run: () => void | Promise<void>;
+}
+export interface UseChatHubMessageActionsOptions {
+    message: ConversationMessageRecord;
+    mutations?: Pick<UseChatHubMessageMutationsResult, 'copyMessage' | 'deleteMessage' | 'revokeMessage' | 'setReplyTarget' | 'toggleForwardSelection' | 'isForwardSelected' | 'getActionState'>;
+    enableCopy?: boolean;
+    enableReply?: boolean;
+    enableForward?: boolean;
+    enableRetry?: boolean;
+    enableDelete?: boolean;
+    enableRevoke?: boolean;
+    onForward?: (message: ConversationMessageRecord) => void | Promise<void>;
+    onRetry?: (message: ConversationMessageRecord) => void | Promise<void>;
+    onDelete?: (message: ConversationMessageRecord) => void | Promise<void>;
+    onRevoke?: (message: ConversationMessageRecord) => void | Promise<void>;
+}
+export interface UseChatHubMessageActionsResult {
+    actions: ChatHubMessageActionItem[];
+    primaryActions: ChatHubMessageActionItem[];
+    overflowActions: ChatHubMessageActionItem[];
+}
+export declare function useChatHubMessageActions(options: UseChatHubMessageActionsOptions): UseChatHubMessageActionsResult;

package/dist/useChatHubMessageActions.js

@@ -0,0 +1,124 @@
+import { useMemo } from 'react';
+function isRetryableMessage(message) {
+    const status = typeof message.status === 'string' ? message.status.toLowerCase() : '';
+    return status === 'failed' || status === 'error';
+}
+function isMutedMessage(message) {
+    const status = typeof message.status === 'string' ? message.status.toLowerCase() : '';
+    return status === 'deleted' || status === 'revoked';
+}
+export function useChatHubMessageActions(options) {
+    const { message, mutations, enableCopy = true, enableReply = true, enableForward = true, enableRetry = true, enableDelete = false, enableRevoke = false, onForward, onRetry, onDelete, onRevoke, } = options;
+    return useMemo(() => {
+        const actions = [];
+        const muted = isMutedMessage(message);
+        if (enableCopy) {
+            const state = mutations?.getActionState(`copy:${message.messageId}`);
+            actions.push({
+                id: 'copy',
+                label: '复制',
+                shortLabel: '复制',
+                description: '复制消息文本，桌面端可用于菜单，移动端可用于长按动作面板',
+                pending: state?.pending,
+                disabled: muted || !mutations?.copyMessage,
+                preferredSurface: 'menu',
+                run: async () => {
+                    if (!mutations?.copyMessage) {
+                        return;
+                    }
+                    await mutations.copyMessage(message);
+                },
+            });
+        }
+        if (enableReply) {
+            actions.push({
+                id: 'reply',
+                label: '回复',
+                shortLabel: '回复',
+                description: '将当前消息挂到 composer 回复态，适合桌面和移动端复用',
+                disabled: muted || !mutations?.setReplyTarget,
+                preferredSurface: 'inline',
+                run: () => {
+                    mutations?.setReplyTarget?.(message);
+                },
+            });
+        }
+        if (enableForward) {
+            const selected = mutations?.isForwardSelected?.(message.messageId) || false;
+            actions.push({
+                id: 'forward',
+                label: selected ? '取消转发' : '加入转发',
+                shortLabel: '转发',
+                description: '将当前消息加入待转发集合，由宿主决定是否展示目标会话选择并执行正式转发',
+                disabled: muted || (!mutations?.toggleForwardSelection && !onForward),
+                preferredSurface: 'sheet',
+                run: async () => {
+                    mutations?.toggleForwardSelection?.(message);
+                    await onForward?.(message);
+                },
+            });
+        }
+        if (enableRetry && isRetryableMessage(message) && onRetry) {
+            actions.push({
+                id: 'retry',
+                label: '重试',
+                shortLabel: '重试',
+                description: '适用于宿主维护失败队列时的逐条重试动作',
+                preferredSurface: 'inline',
+                run: async () => {
+                    await onRetry(message);
+                },
+            });
+        }
+        if (enableDelete && onDelete) {
+            const state = mutations?.getActionState(`delete:${message.messageId}`);
+            actions.push({
+                id: 'delete',
+                label: '删除',
+                shortLabel: '删除',
+                description: '将消息更新为删除状态，保留消息记录但以删除占位展示',
+                pending: state?.pending,
+                destructive: true,
+                preferredSurface: 'menu',
+                disabled: muted,
+                run: async () => {
+                    await onDelete(message);
+                },
+            });
+        }
+        if (enableRevoke && onRevoke) {
+            const state = mutations?.getActionState(`revoke:${message.messageId}`);
+            actions.push({
+                id: 'revoke',
+                label: '撤回',
+                shortLabel: '撤回',
+                description: '将消息更新为撤回状态，并向当前会话同步撤回占位',
+                pending: state?.pending,
+                destructive: true,
+                preferredSurface: 'menu',
+                disabled: muted,
+                run: async () => {
+                    await onRevoke(message);
+                },
+            });
+        }
+        return {
+            actions,
+            primaryActions: actions.filter((action) => !action.hidden && action.preferredSurface === 'inline'),
+            overflowActions: actions.filter((action) => !action.hidden && action.preferredSurface !== 'inline'),
+        };
+    }, [
+        enableCopy,
+        enableDelete,
+        enableForward,
+        enableRevoke,
+        enableReply,
+        enableRetry,
+        message,
+        mutations,
+        onDelete,
+        onForward,
+        onRevoke,
+        onRetry,
+    ]);
+}

package/dist/useChatHubMessageMutations.d.ts

@@ -0,0 +1,53 @@
+import type { ChatHubAppRuntime, ConversationMessageRecord, SendChatHubMessageOptions, SendTextMessageOptions, UpdateChatHubMessageOptions } from '@appthen/sdk-core';
+export interface ChatHubForwardDraftItem {
+    messageId: string;
+    sourceConversationId: string;
+    senderSubjectId: string;
+    kind?: string;
+    previewText: string;
+    content: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
+export interface ForwardChatHubMessagesOptions {
+    targetConversationId: string;
+    senderSubjectId?: string;
+    items?: ChatHubForwardDraftItem[];
+    metadata?: Record<string, unknown>;
+    clearSelection?: boolean;
+}
+export interface UseChatHubMessageMutationsOptions {
+    runtime: ChatHubAppRuntime;
+    selectedConversationId?: string;
+    selectedSenderId?: string;
+    copyToClipboard?: (text: string) => Promise<void>;
+    allowMultiForwardSelection?: boolean;
+}
+export interface ChatHubMutationActionState {
+    pending: boolean;
+    error: string | null;
+}
+export interface UseChatHubMessageMutationsResult {
+    replyTarget: ConversationMessageRecord | null;
+    setReplyTarget: (message: ConversationMessageRecord | null) => void;
+    clearReplyTarget: () => void;
+    forwardDraftItems: ChatHubForwardDraftItem[];
+    toggleForwardSelection: (message: ConversationMessageRecord) => void;
+    clearForwardSelection: () => void;
+    isForwardSelected: (messageId: string) => boolean;
+    getActionState: (actionKey: string) => ChatHubMutationActionState;
+    copyMessage: (message: ConversationMessageRecord) => Promise<string>;
+    deleteMessage: (message: ConversationMessageRecord, input?: Omit<UpdateChatHubMessageOptions, 'messageId' | 'status'>) => Promise<ConversationMessageRecord>;
+    revokeMessage: (message: ConversationMessageRecord, input?: Omit<UpdateChatHubMessageOptions, 'messageId' | 'status'>) => Promise<ConversationMessageRecord>;
+    forwardMessages: (input: ForwardChatHubMessagesOptions) => Promise<ConversationMessageRecord[]>;
+    forwardSelectedMessages: (input: Omit<ForwardChatHubMessagesOptions, 'items'>) => Promise<ConversationMessageRecord[]>;
+    sendTextMessage: (input: Omit<SendTextMessageOptions, 'conversationId' | 'senderSubjectId'> & {
+        conversationId?: string;
+        senderSubjectId?: string;
+    }) => Promise<ConversationMessageRecord>;
+    sendMessage: (input: Omit<SendChatHubMessageOptions, 'conversationId' | 'senderSubjectId'> & {
+        conversationId?: string;
+        senderSubjectId?: string;
+    }) => Promise<ConversationMessageRecord>;
+}
+export declare function extractChatHubMessagePlainText(message: ConversationMessageRecord): string;
+export declare function useChatHubMessageMutations(options: UseChatHubMessageMutationsOptions): UseChatHubMessageMutationsResult;

package/dist/useChatHubMessageMutations.js

@@ -0,0 +1,293 @@
+import { useCallback, useMemo, useState } from 'react';
+function resolveMutationError(error, fallback) {
+    return error instanceof Error ? error.message : fallback;
+}
+export function extractChatHubMessagePlainText(message) {
+    const content = message.content || {};
+    const textCandidates = [
+        content.text,
+        content.markdown,
+        content.body,
+        content.summary,
+        content.label,
+    ];
+    const matchedText = textCandidates.find((value) => typeof value === 'string' && value.trim().length > 0);
+    if (typeof matchedText === 'string') {
+        return matchedText;
+    }
+    try {
+        return JSON.stringify(content, null, 2);
+    }
+    catch {
+        return message.messageId;
+    }
+}
+function toForwardDraftItem(message) {
+    return {
+        messageId: message.messageId,
+        sourceConversationId: message.conversationId,
+        senderSubjectId: message.senderSubjectId,
+        kind: message.kind,
+        previewText: extractChatHubMessagePlainText(message),
+        content: message.content,
+        metadata: message.metadata,
+    };
+}
+function mergeReplyMetadata(metadata, replyTarget) {
+    if (!replyTarget) {
+        return metadata;
+    }
+    return {
+        ...(metadata || {}),
+        replyTo: {
+            messageId: replyTarget.messageId,
+            senderSubjectId: replyTarget.senderSubjectId,
+            kind: replyTarget.kind,
+            previewText: extractChatHubMessagePlainText(replyTarget),
+        },
+    };
+}
+function isMutedMessage(message) {
+    return message.status === 'deleted' || message.status === 'revoked';
+}
+export function useChatHubMessageMutations(options) {
+    const { runtime, selectedConversationId = '', selectedSenderId = '', copyToClipboard, allowMultiForwardSelection = true, } = options;
+    const [replyTarget, setReplyTarget] = useState(null);
+    const [forwardDraftItems, setForwardDraftItems] = useState([]);
+    const [actionStateByKey, setActionStateByKey] = useState({});
+    const updateActionState = useCallback((actionKey, nextState) => {
+        setActionStateByKey((current) => {
+            if (!nextState) {
+                const { [actionKey]: _removed, ...rest } = current;
+                return rest;
+            }
+            return {
+                ...current,
+                [actionKey]: {
+                    pending: false,
+                    error: null,
+                    ...(current[actionKey] || {}),
+                    ...nextState,
+                },
+            };
+        });
+    }, []);
+    const runAction = useCallback(async (actionKey, task, fallbackMessage) => {
+        updateActionState(actionKey, {
+            pending: true,
+            error: null,
+        });
+        try {
+            const result = await task();
+            updateActionState(actionKey, {
+                pending: false,
+                error: null,
+            });
+            return result;
+        }
+        catch (error) {
+            updateActionState(actionKey, {
+                pending: false,
+                error: resolveMutationError(error, fallbackMessage),
+            });
+            throw error;
+        }
+    }, [updateActionState]);
+    const resolveClipboardWriter = useCallback(async () => {
+        if (copyToClipboard) {
+            return copyToClipboard;
+        }
+        if (typeof navigator !== 'undefined' &&
+            navigator.clipboard &&
+            typeof navigator.clipboard.writeText === 'function') {
+            return async (text) => navigator.clipboard.writeText(text);
+        }
+        throw new Error('当前环境不支持剪贴板写入');
+    }, [copyToClipboard]);
+    const clearReplyTarget = useCallback(() => {
+        setReplyTarget(null);
+    }, []);
+    const clearForwardSelection = useCallback(() => {
+        setForwardDraftItems([]);
+    }, []);
+    const toggleForwardSelection = useCallback((message) => {
+        setForwardDraftItems((current) => {
+            const exists = current.some((item) => item.messageId === message.messageId);
+            if (exists) {
+                return current.filter((item) => item.messageId !== message.messageId);
+            }
+            if (!allowMultiForwardSelection) {
+                return [toForwardDraftItem(message)];
+            }
+            return [...current, toForwardDraftItem(message)];
+        });
+    }, [allowMultiForwardSelection]);
+    const isForwardSelected = useCallback((messageId) => forwardDraftItems.some((item) => item.messageId === messageId), [forwardDraftItems]);
+    const getActionState = useCallback((actionKey) => actionStateByKey[actionKey] || {
+        pending: false,
+        error: null,
+    }, [actionStateByKey]);
+    const copyMessage = useCallback(async (message) => {
+        if (isMutedMessage(message)) {
+            throw new Error('已删除或撤回的消息不能复制');
+        }
+        const actionKey = `copy:${message.messageId}`;
+        return runAction(actionKey, async () => {
+            const text = extractChatHubMessagePlainText(message);
+            const writeToClipboard = await resolveClipboardWriter();
+            await writeToClipboard(text);
+            return text;
+        }, '复制消息失败');
+    }, [resolveClipboardWriter, runAction]);
+    const deleteMessage = useCallback(async (message, input) => {
+        const actionKey = `delete:${message.messageId}`;
+        return runAction(actionKey, async () => runtime.deleteMessage({
+            messageId: message.messageId,
+            actorSubjectId: input?.actorSubjectId || selectedSenderId || message.senderSubjectId,
+            metadata: input?.metadata,
+        }), '删除消息失败');
+    }, [runAction, runtime, selectedSenderId]);
+    const revokeMessage = useCallback(async (message, input) => {
+        const actionKey = `revoke:${message.messageId}`;
+        return runAction(actionKey, async () => runtime.revokeMessage({
+            messageId: message.messageId,
+            actorSubjectId: input?.actorSubjectId || selectedSenderId || message.senderSubjectId,
+            metadata: input?.metadata,
+        }), '撤回消息失败');
+    }, [runAction, runtime, selectedSenderId]);
+    const forwardMessages = useCallback(async (input) => {
+        const targetConversationId = input.targetConversationId;
+        const senderSubjectId = input.senderSubjectId || selectedSenderId;
+        const items = input.items || forwardDraftItems;
+        if (!targetConversationId) {
+            throw new Error('缺少目标 conversationId，无法转发消息');
+        }
+        if (!senderSubjectId) {
+            throw new Error('缺少 senderSubjectId，无法转发消息');
+        }
+        if (items.length === 0) {
+            throw new Error('当前没有可转发的消息');
+        }
+        const actionKey = `forward:${targetConversationId}:${items
+            .map((item) => item.messageId)
+            .join(',')}`;
+        return runAction(actionKey, async () => {
+            const results = await Promise.all(items.map((item) => runtime.sendMessage({
+                conversationId: targetConversationId,
+                senderSubjectId,
+                kind: 'forwarded_message',
+                content: {
+                    text: item.previewText,
+                    previewText: item.previewText,
+                    originalMessageId: item.messageId,
+                    originalKind: item.kind,
+                    originalSenderSubjectId: item.senderSubjectId,
+                    senderSubjectId: item.senderSubjectId,
+                    sourceConversationId: item.sourceConversationId,
+                    originalContent: item.content,
+                },
+                metadata: {
+                    ...(input.metadata || {}),
+                    forwardedFrom: {
+                        conversationId: item.sourceConversationId,
+                        messageId: item.messageId,
+                        senderSubjectId: item.senderSubjectId,
+                        kind: item.kind,
+                    },
+                    originalMetadata: item.metadata,
+                },
+            })));
+            if (input.clearSelection !== false) {
+                setForwardDraftItems((current) => {
+                    const forwardedMessageIds = new Set(items.map((item) => item.messageId));
+                    return current.filter((item) => !forwardedMessageIds.has(item.messageId));
+                });
+            }
+            return results;
+        }, '转发消息失败');
+    }, [forwardDraftItems, runAction, runtime, selectedSenderId]);
+    const forwardSelectedMessages = useCallback(async (input) => forwardMessages({
+        ...input,
+        items: forwardDraftItems,
+    }), [forwardDraftItems, forwardMessages]);
+    const sendTextMessage = useCallback(async (input) => {
+        const conversationId = input.conversationId || selectedConversationId;
+        const senderSubjectId = input.senderSubjectId || selectedSenderId;
+        if (!conversationId) {
+            throw new Error('缺少 conversationId，无法发送消息');
+        }
+        if (!senderSubjectId) {
+            throw new Error('缺少 senderSubjectId，无法发送消息');
+        }
+        const actionKey = `send-text:${conversationId}:${input.messageId || 'draft'}`;
+        const currentReplyTarget = replyTarget;
+        return runAction(actionKey, async () => {
+            const message = await runtime.sendTextMessage({
+                ...input,
+                conversationId,
+                senderSubjectId,
+                metadata: mergeReplyMetadata(input.metadata, currentReplyTarget),
+            });
+            if (currentReplyTarget) {
+                setReplyTarget((existing) => existing?.messageId === currentReplyTarget.messageId ? null : existing);
+            }
+            return message;
+        }, '发送消息失败');
+    }, [replyTarget, runAction, runtime, selectedConversationId, selectedSenderId]);
+    const sendMessage = useCallback(async (input) => {
+        const conversationId = input.conversationId || selectedConversationId;
+        const senderSubjectId = input.senderSubjectId || selectedSenderId;
+        if (!conversationId) {
+            throw new Error('缺少 conversationId，无法发送消息');
+        }
+        if (!senderSubjectId) {
+            throw new Error('缺少 senderSubjectId，无法发送消息');
+        }
+        const actionKey = `send:${conversationId}:${input.messageId || input.kind}`;
+        const currentReplyTarget = replyTarget;
+        return runAction(actionKey, async () => {
+            const message = await runtime.sendMessage({
+                ...input,
+                conversationId,
+                senderSubjectId,
+                metadata: mergeReplyMetadata(input.metadata, currentReplyTarget),
+            });
+            if (currentReplyTarget) {
+                setReplyTarget((existing) => existing?.messageId === currentReplyTarget.messageId ? null : existing);
+            }
+            return message;
+        }, '发送消息失败');
+    }, [replyTarget, runAction, runtime, selectedConversationId, selectedSenderId]);
+    return useMemo(() => ({
+        replyTarget,
+        setReplyTarget,
+        clearReplyTarget,
+        forwardDraftItems,
+        toggleForwardSelection,
+        clearForwardSelection,
+        isForwardSelected,
+        getActionState,
+        copyMessage,
+        deleteMessage,
+        revokeMessage,
+        forwardMessages,
+        forwardSelectedMessages,
+        sendTextMessage,
+        sendMessage,
+    }), [
+        clearForwardSelection,
+        clearReplyTarget,
+        copyMessage,
+        deleteMessage,
+        forwardMessages,
+        forwardSelectedMessages,
+        forwardDraftItems,
+        getActionState,
+        isForwardSelected,
+        replyTarget,
+        revokeMessage,
+        sendMessage,
+        sendTextMessage,
+        toggleForwardSelection,
+    ]);
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@appthen/sdk-react",
+  "version": "0.0.0",
+  "description": "AppThen Conversation Hub SDK - React headless hooks",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "@appthen/sdk-core": "0.0.0"
+  },
+  "peerDependencies": {
+    "react": "^18.0.0 || ^19.0.0"
+  },
+  "sideEffects": false,
+  "license": "UNLICENSED",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsc -p tsconfig.json --watch",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "clean": "rm -rf dist *.tsbuildinfo"
+  }
+}