feat：集成统一 mod‑chat 面板，对接自定义聊天状态管理与 API 流程

- 将原有 ChatPanel 替换为 IntegratedChatPanel，基于 mod‑chat 实现聊天能力。
- 实现全新聊天状态存储，用于管理聊天消息、会话以及 API 交互逻辑。
- 支持在聊天界面内完成文档下载功能。
- 更新 App 组件，适配左侧面板布局改动。
- 增强 AI 聊天服务，支持 mod‑chat API 调用，同时处理文档相关工作流。
- 新增聊天配置项与 mod‑chat 属性的类型定义，提升类型安全。
- 配置 Vite 的模块联邦，将 mod‑chat 作为远程模块加载。
- 重构工作流服务，保证文档命名唯一性，优化响应处理逻辑。

.env

@@ -1,7 +1,7 @@
 # API Base URL
 # This is the base URL for the backend API server
 # Default: http://localhost:8000
-VITE_API_BASE_URL=http://192.168.0.195:8000
+VITE_API_BASE_URL=http://127.0.0.1:8000
 
 # Application Title
 # This will be displayed in the browser tab
@@ -15,6 +15,10 @@ VITE_DEBUG=false
 # AI and workflow calls must go through the backend proxy.
 VITE_AI_PROXY_URL=/api/v1/ai/chat
 VITE_WORKFLOW_PROXY_URL=/api/v1/ai/workflow
+# mod-chat Composer backend used by the unified hostBridge chat.
+VITE_MOD_CHAT_API_BASE_URL=http://192.168.0.44:8010
+VITE_MOD_CHAT_REGISTRY_API_BASE_URL=http://192.168.0.44:8040
+VITE_MOD_CHAT_REMOTE_URL=http://localhost:5174/assets/remoteEntry.js
 
 # WebMCP Bridge 连接配置
 VITE_WEBMCP_CLIENT_ID=ax-editor-local

.env.example

@@ -14,9 +14,15 @@ VITE_APP_TITLE=AX Document Editor
 # Default: false
 VITE_DEBUG=false
 
+# Module Federation remote entry for the integrated chat panel.
+VITE_MOD_CHAT_REMOTE_URL=http://localhost:5174/assets/remoteEntry.js
+
 # The browser must use backend proxy endpoints. Keep upstream API keys server-side.
 VITE_AI_PROXY_URL=/api/v1/ai/chat
 VITE_WORKFLOW_PROXY_URL=/api/v1/ai/workflow
+# mod-chat Composer backend used by the unified hostBridge chat.
+VITE_MOD_CHAT_API_BASE_URL=http://192.168.0.44:8010
+VITE_MOD_CHAT_REGISTRY_API_BASE_URL=http://192.168.0.44:8040
 
 # Local development only; production uses a session-based WebMCP ticket.
 VITE_WEBMCP_BRIDGE_TOKEN=

package-lock.json

@@ -23,6 +23,7 @@
       },
       "devDependencies": {
         "@eslint/js": "^10.0.1",
+        "@originjs/vite-plugin-federation": "^1.4.1",
         "@testing-library/jest-dom": "^6.9.1",
         "@testing-library/react": "^16.3.2",
         "@types/hash-sum": "^1.0.2",
@@ -954,6 +955,34 @@
         "@emnapi/runtime": "^1.7.1"
       }
     },
+    "node_modules/@originjs/vite-plugin-federation": {
+      "version": "1.4.1",
+      "resolved": "https://registry.npmmirror.com/@originjs/vite-plugin-federation/-/vite-plugin-federation-1.4.1.tgz",
+      "integrity": "sha512-Uo08jW5pj1t58OUKuZNkmzcfTN2pqeVuAWCCiKf/75/oll4Efq4cHOqSE1FXMlvwZNGDziNdDyBbQ5IANem3CQ==",
+      "dev": true,
+      "license": "MulanPSL-2.0",
+      "dependencies": {
+        "estree-walker": "^3.0.2",
+        "magic-string": "^0.27.0"
+      },
+      "engines": {
+        "node": ">=14.0.0",
+        "pnpm": ">=7.0.1"
+      }
+    },
+    "node_modules/@originjs/vite-plugin-federation/node_modules/magic-string": {
+      "version": "0.27.0",
+      "resolved": "https://registry.npmmirror.com/magic-string/-/magic-string-0.27.0.tgz",
+      "integrity": "sha512-8UnnX2PeRAPZuN12svgR9j7M1uWMovg/CEnIwIG0LFkXSJJe4PdfUGiTGl8V9bsBHFUtfVINcSyYxd7q+kx9fA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.4.13"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
     "node_modules/@oxc-project/types": {
       "version": "0.133.0",
       "resolved": "https://registry.npmmirror.com/@oxc-project/types/-/types-0.133.0.tgz",

package.json

@@ -37,6 +37,7 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
+    "@originjs/vite-plugin-federation": "^1.4.1",
     "@testing-library/jest-dom": "^6.9.1",
     "@testing-library/react": "^16.3.2",
     "@types/hash-sum": "^1.0.2",

public/mockServiceWorker.js

@@ -0,0 +1,349 @@
+/* eslint-disable */
+/* tslint:disable */
+
+/**
+ * Mock Service Worker.
+ * @see https://github.com/mswjs/msw
+ * - Please do NOT modify this file.
+ */
+
+const PACKAGE_VERSION = '2.13.4'
+const INTEGRITY_CHECKSUM = '4db4a41e972cec1b64cc569c66952d82'
+const IS_MOCKED_RESPONSE = Symbol('isMockedResponse')
+const activeClientIds = new Set()
+
+addEventListener('install', function () {
+  self.skipWaiting()
+})
+
+addEventListener('activate', function (event) {
+  event.waitUntil(self.clients.claim())
+})
+
+addEventListener('message', async function (event) {
+  const clientId = Reflect.get(event.source || {}, 'id')
+
+  if (!clientId || !self.clients) {
+    return
+  }
+
+  const client = await self.clients.get(clientId)
+
+  if (!client) {
+    return
+  }
+
+  const allClients = await self.clients.matchAll({
+    type: 'window',
+  })
+
+  switch (event.data) {
+    case 'KEEPALIVE_REQUEST': {
+      sendToClient(client, {
+        type: 'KEEPALIVE_RESPONSE',
+      })
+      break
+    }
+
+    case 'INTEGRITY_CHECK_REQUEST': {
+      sendToClient(client, {
+        type: 'INTEGRITY_CHECK_RESPONSE',
+        payload: {
+          packageVersion: PACKAGE_VERSION,
+          checksum: INTEGRITY_CHECKSUM,
+        },
+      })
+      break
+    }
+
+    case 'MOCK_ACTIVATE': {
+      activeClientIds.add(clientId)
+
+      sendToClient(client, {
+        type: 'MOCKING_ENABLED',
+        payload: {
+          client: {
+            id: client.id,
+            frameType: client.frameType,
+          },
+        },
+      })
+      break
+    }
+
+    case 'CLIENT_CLOSED': {
+      activeClientIds.delete(clientId)
+
+      const remainingClients = allClients.filter((client) => {
+        return client.id !== clientId
+      })
+
+      // Unregister itself when there are no more clients
+      if (remainingClients.length === 0) {
+        self.registration.unregister()
+      }
+
+      break
+    }
+  }
+})
+
+addEventListener('fetch', function (event) {
+  const requestInterceptedAt = Date.now()
+
+  // Bypass navigation requests.
+  if (event.request.mode === 'navigate') {
+    return
+  }
+
+  // Opening the DevTools triggers the "only-if-cached" request
+  // that cannot be handled by the worker. Bypass such requests.
+  if (
+    event.request.cache === 'only-if-cached' &&
+    event.request.mode !== 'same-origin'
+  ) {
+    return
+  }
+
+  // Bypass all requests when there are no active clients.
+  // Prevents the self-unregistered worked from handling requests
+  // after it's been terminated (still remains active until the next reload).
+  if (activeClientIds.size === 0) {
+    return
+  }
+
+  const requestId = crypto.randomUUID()
+  event.respondWith(handleRequest(event, requestId, requestInterceptedAt))
+})
+
+/**
+ * @param {FetchEvent} event
+ * @param {string} requestId
+ * @param {number} requestInterceptedAt
+ */
+async function handleRequest(event, requestId, requestInterceptedAt) {
+  const client = await resolveMainClient(event)
+  const requestCloneForEvents = event.request.clone()
+  const response = await getResponse(
+    event,
+    client,
+    requestId,
+    requestInterceptedAt,
+  )
+
+  // Send back the response clone for the "response:*" life-cycle events.
+  // Ensure MSW is active and ready to handle the message, otherwise
+  // this message will pend indefinitely.
+  if (client && activeClientIds.has(client.id)) {
+    const serializedRequest = await serializeRequest(requestCloneForEvents)
+
+    // Clone the response so both the client and the library could consume it.
+    const responseClone = response.clone()
+
+    sendToClient(
+      client,
+      {
+        type: 'RESPONSE',
+        payload: {
+          isMockedResponse: IS_MOCKED_RESPONSE in response,
+          request: {
+            id: requestId,
+            ...serializedRequest,
+          },
+          response: {
+            type: responseClone.type,
+            status: responseClone.status,
+            statusText: responseClone.statusText,
+            headers: Object.fromEntries(responseClone.headers.entries()),
+            body: responseClone.body,
+          },
+        },
+      },
+      responseClone.body ? [serializedRequest.body, responseClone.body] : [],
+    )
+  }
+
+  return response
+}
+
+/**
+ * Resolve the main client for the given event.
+ * Client that issues a request doesn't necessarily equal the client
+ * that registered the worker. It's with the latter the worker should
+ * communicate with during the response resolving phase.
+ * @param {FetchEvent} event
+ * @returns {Promise<Client | undefined>}
+ */
+async function resolveMainClient(event) {
+  const client = await self.clients.get(event.clientId)
+
+  if (activeClientIds.has(event.clientId)) {
+    return client
+  }
+
+  if (client?.frameType === 'top-level') {
+    return client
+  }
+
+  const allClients = await self.clients.matchAll({
+    type: 'window',
+  })
+
+  return allClients
+    .filter((client) => {
+      // Get only those clients that are currently visible.
+      return client.visibilityState === 'visible'
+    })
+    .find((client) => {
+      // Find the client ID that's recorded in the
+      // set of clients that have registered the worker.
+      return activeClientIds.has(client.id)
+    })
+}
+
+/**
+ * @param {FetchEvent} event
+ * @param {Client | undefined} client
+ * @param {string} requestId
+ * @param {number} requestInterceptedAt
+ * @returns {Promise<Response>}
+ */
+async function getResponse(event, client, requestId, requestInterceptedAt) {
+  // Clone the request because it might've been already used
+  // (i.e. its body has been read and sent to the client).
+  const requestClone = event.request.clone()
+
+  function passthrough() {
+    // Cast the request headers to a new Headers instance
+    // so the headers can be manipulated with.
+    const headers = new Headers(requestClone.headers)
+
+    // Remove the "accept" header value that marked this request as passthrough.
+    // This prevents request alteration and also keeps it compliant with the
+    // user-defined CORS policies.
+    const acceptHeader = headers.get('accept')
+    if (acceptHeader) {
+      const values = acceptHeader.split(',').map((value) => value.trim())
+      const filteredValues = values.filter(
+        (value) => value !== 'msw/passthrough',
+      )
+
+      if (filteredValues.length > 0) {
+        headers.set('accept', filteredValues.join(', '))
+      } else {
+        headers.delete('accept')
+      }
+    }
+
+    return fetch(requestClone, { headers })
+  }
+
+  // Bypass mocking when the client is not active.
+  if (!client) {
+    return passthrough()
+  }
+
+  // Bypass initial page load requests (i.e. static assets).
+  // The absence of the immediate/parent client in the map of the active clients
+  // means that MSW hasn't dispatched the "MOCK_ACTIVATE" event yet
+  // and is not ready to handle requests.
+  if (!activeClientIds.has(client.id)) {
+    return passthrough()
+  }
+
+  // Notify the client that a request has been intercepted.
+  const serializedRequest = await serializeRequest(event.request)
+  const clientMessage = await sendToClient(
+    client,
+    {
+      type: 'REQUEST',
+      payload: {
+        id: requestId,
+        interceptedAt: requestInterceptedAt,
+        ...serializedRequest,
+      },
+    },
+    [serializedRequest.body],
+  )
+
+  switch (clientMessage.type) {
+    case 'MOCK_RESPONSE': {
+      return respondWithMock(clientMessage.data)
+    }
+
+    case 'PASSTHROUGH': {
+      return passthrough()
+    }
+  }
+
+  return passthrough()
+}
+
+/**
+ * @param {Client} client
+ * @param {any} message
+ * @param {Array<Transferable>} transferrables
+ * @returns {Promise<any>}
+ */
+function sendToClient(client, message, transferrables = []) {
+  return new Promise((resolve, reject) => {
+    const channel = new MessageChannel()
+
+    channel.port1.onmessage = (event) => {
+      if (event.data && event.data.error) {
+        return reject(event.data.error)
+      }
+
+      resolve(event.data)
+    }
+
+    client.postMessage(message, [
+      channel.port2,
+      ...transferrables.filter(Boolean),
+    ])
+  })
+}
+
+/**
+ * @param {Response} response
+ * @returns {Response}
+ */
+function respondWithMock(response) {
+  // Setting response status code to 0 is a no-op.
+  // However, when responding with a "Response.error()", the produced Response
+  // instance will have status code set to 0. Since it's not possible to create
+  // a Response instance with status code 0, handle that use-case separately.
+  if (response.status === 0) {
+    return Response.error()
+  }
+
+  const mockedResponse = new Response(response.body, response)
+
+  Reflect.defineProperty(mockedResponse, IS_MOCKED_RESPONSE, {
+    value: true,
+    enumerable: true,
+  })
+
+  return mockedResponse
+}
+
+/**
+ * @param {Request} request
+ */
+async function serializeRequest(request) {
+  return {
+    url: request.url,
+    mode: request.mode,
+    method: request.method,
+    headers: Object.fromEntries(request.headers.entries()),
+    cache: request.cache,
+    credentials: request.credentials,
+    destination: request.destination,
+    integrity: request.integrity,
+    redirect: request.redirect,
+    referrer: request.referrer,
+    referrerPolicy: request.referrerPolicy,
+    body: await request.arrayBuffer(),
+    keepalive: request.keepalive,
+  }
+}

src/App.tsx

@@ -5,7 +5,7 @@
  * - Wraps everything in ErrorBoundary to catch unhandled render errors
  * - Uses useOnlineStatus for network detection (Req 11.3)
  * - Dual-panel desktop layout via ResizableLayout with 40/60 split (Req 12.1)
- * - Left panel: ChatPanel (fixed)
+ * - Left panel: Unified mod-chat panel running its own chat store and API flow
  * - Right panel: Dynamically switches between ExportRecordList (default) and EditorPanel (when document is opened)
  * - Uses React.lazy for code splitting of non-critical panels (Req 13.2, 13.8)
  *
@@ -24,9 +24,8 @@
  * @module App
  */
 
-import React, { useCallback, useEffect, useState, memo, lazy, Suspense, useMemo } from 'react';
-import { ConfigProvider, Alert, Button, Drawer, Spin, message } from 'antd';
-import { MessageOutlined } from '@ant-design/icons';
+import React, { useCallback, useEffect, memo, lazy, Suspense, useMemo } from 'react';
+import { ConfigProvider, Alert, Spin, message } from 'antd';
 import zhCN from 'antd/locale/zh_CN';
 
 import { ErrorBoundary } from './components/common';
@@ -34,18 +33,18 @@ import ResizableLayout from './components/Layout/ResizableLayout';
 import { useUIStore } from './stores/uiStore';
 import { getDocument } from './services/documentService';
 import { isApiError } from './services/api';
+import { useChatStore } from './stores/chatStore';
+import apiClient from './services/api';
+import { downloadBlob, getFileNameFromContentDisposition } from './utils/download';
 
 // ── Lazy-loaded panel components (Req 13.2, 13.8) ────────────────────────────
 // These non-first-screen panels are split into separate chunks by Vite,
 // reducing the initial JS bundle size.
-const ChatPanel = lazy(() => import('./components/ChatPanel/ChatPanel'));
+const ModChatPanel = lazy(() => import('mod_chat/App'));
 const EditorPanel = lazy(() => import('./components/EditorPanel/EditorPanel'));
 const ExportRecordList = lazy(() =>
   import('./components/ExportRecordList').then((m) => ({ default: m.ExportRecordList }))
 );
-const SessionList = lazy(() =>
-  import('./components/SessionList').then((m) => ({ default: m.SessionList }))
-);
 
 import { useOnlineStatus } from './hooks/useOnlineStatus';
 
@@ -75,12 +74,6 @@ const PanelFallback: React.FC = memo(() => (
 ));
 PanelFallback.displayName = 'PanelFallback';
 
-const leftPanel = (
-  <Suspense fallback={<PanelFallback />}>
-    <ChatPanel />
-  </Suspense>
-);
-
 const CURRENT_USER_ID = 'default-user';
 
 // ── Styles ────────────────────────────────────────────────────────────────────
@@ -123,6 +116,79 @@ const OfflineBanner: React.FC = memo(() => (
 ));
 OfflineBanner.displayName = 'OfflineBanner';
 
+const IntegratedChatPanel: React.FC = () => {
+  const messages = useChatStore((state) => state.messages);
+  const isLoading = useChatStore((state) => state.isLoading);
+  const sendMessage = useChatStore((state) => state.sendMessage);
+  const sessions = useChatStore((state) => state.sessions);
+  const activeSessionId = useChatStore((state) => state.currentSessionId);
+  const createSession = useChatStore((state) => state.createSession);
+  const loadSession = useChatStore((state) => state.loadSession);
+  const deleteSession = useChatStore((state) => state.deleteSession);
+  const updateSessionTitle = useChatStore((state) => state.updateSessionTitle);
+  const updateSessionSettings = useChatStore((state) => state.updateSessionSettings);
+  const openDocumentPreview = useUIStore((state) => state.openDocumentPreview);
+
+  const handleDownloadDocument = async (downloadUrl: string, fileName?: string) => {
+    const urlMatch = downloadUrl.match(/\/export\/records\/([^/]+)\/download/);
+    if (!urlMatch) {
+      window.open(downloadUrl, '_blank', 'noopener,noreferrer');
+      return;
+    }
+
+    const recordId = urlMatch[1];
+    const userId = new URL(downloadUrl, window.location.origin).searchParams.get('userId') || 'default-user';
+    const response = await apiClient.get(`/api/v1/export/records/${recordId}/download`, {
+      params: { userId },
+      responseType: 'blob',
+    });
+    const resolvedFileName = fileName || getFileNameFromContentDisposition(
+      response.headers['content-disposition'],
+      'document.docx'
+    );
+    downloadBlob(new Blob([response.data], { type: 'application/msword' }), resolvedFileName);
+  };
+
+  return (
+    <Suspense fallback={<PanelFallback />}>
+      <ModChatPanel
+        layoutMode="full-page"
+        hostBridge={{
+          messages: messages.map((chatMessage) => ({
+            id: chatMessage.id,
+            role: chatMessage.role,
+            content: chatMessage.content,
+            createdAt: chatMessage.timestamp,
+            exportRecord: chatMessage.exportRecord
+              ? {
+                  documentId: chatMessage.exportRecord.documentId,
+                  fileName: chatMessage.exportRecord.fileName,
+                  downloadUrl: chatMessage.exportRecord.downloadUrl,
+                }
+              : undefined,
+          })),
+          isLoading,
+          onSendMessage: (content, options) => sendMessage(content, options),
+          sessions: sessions.map((session) => ({
+            id: session.id,
+            title: session.title,
+            updatedAt: session.updatedAt,
+            settings: session.settings,
+          })),
+          activeSessionId,
+          onCreateSession: createSession,
+          onSelectSession: loadSession,
+          onDeleteSession: deleteSession,
+          onRenameSession: updateSessionTitle,
+          onUpdateSessionSettings: updateSessionSettings,
+          onPreviewDocument: openDocumentPreview,
+          onDownloadDocument: handleDownloadDocument,
+        }}
+      />
+    </Suspense>
+  );
+};
+
 // ── App Component ─────────────────────────────────────────────────────────────
 
 /**
@@ -131,7 +197,7 @@ OfflineBanner.displayName = 'OfflineBanner';
  * The top-level React component. Handles layout orchestration.
  *
  * Uses a fixed dual-panel desktop layout with ResizableLayout (40% left / 60% right).
- * The left panel shows ChatPanel (fixed), and the right panel dynamically switches:
+ * The left panel shows the unified mod-chat interface, and the right panel dynamically switches:
  * - Default: ExportRecordList (shows export history)
  * - When document opened: EditorPanel (shows document for preview and editing)
  */
@@ -172,13 +238,7 @@ const App: React.FC = () => {
     };
   }, [openDocumentPreview, closeDocumentPreview]);
 
-  // ── Session history drawer ────────────────────────────────────────────────
-  const [sessionListOpen, setSessionListOpen] = useState(false);
-
-  /** Stable callback to close the session drawer */
-  const handleCloseSessionList = useCallback(() => setSessionListOpen(false), []);
-  /** Stable callback to open the session drawer */
-  const handleOpenSessionList = useCallback(() => setSessionListOpen(true), []);
+  const leftPanel = <IntegratedChatPanel />;
 
   /**
    * Handle close editor button click
@@ -211,35 +271,6 @@ const App: React.FC = () => {
     );
   }, [previewDocumentId, previewDocumentName, handleCloseEditor]);
 
-  // ── Session history drawer ────────────────────────────────────────────────
-  const sessionListDrawer = sessionListOpen ? (
-    <Drawer
-      title="会话历史"
-      placement="left"
-      width={360}
-      open
-      onClose={handleCloseSessionList}
-      styles={{ body: { padding: 0, display: 'flex', flexDirection: 'column' } }}
-      data-testid="session-list-drawer"
-    >
-      <Suspense fallback={<PanelFallback />}>
-        <SessionList onSessionLoad={handleCloseSessionList} />
-      </Suspense>
-    </Drawer>
-  ) : null;
-
-  // ── Session history toggle button ─────────────────────────────────────────
-  const sessionListButton = (
-    <Button
-      type="text"
-      icon={<MessageOutlined />}
-      onClick={handleOpenSessionList}
-      title="会话历史"
-      aria-label="打开会话历史"
-      data-testid="open-session-list-button"
-    />
-  );
-
   // ── Desktop dual-panel layout (Req 12.1) ──────────────────────────────────
   return (
     <ConfigProvider locale={zhCN}>
@@ -248,9 +279,6 @@ const App: React.FC = () => {
           {/* Offline banner (Req 11.3) */}
           {!isOnline && <OfflineBanner />}
 
-          {/* Session history drawer */}
-          {sessionListDrawer}
-
           {/* Main two-panel layout */}
           <div style={mainContentStyle}>
             {/* Toolbar row with session history toggle */}
@@ -267,7 +295,6 @@ const App: React.FC = () => {
               }}
               data-testid="app-toolbar"
             >
-              {sessionListButton}
             </div>
 
             {/* Resizable dual-panel layout (Req 4.1–4.5, 12.1) */}

src/main.tsx

@@ -1,21 +1,50 @@
-import { StrictMode } from 'react';
-import { createRoot } from 'react-dom/client';
+import * as React from 'react';
+import * as ReactDOM from 'react-dom';
+import * as ReactDOMClient from 'react-dom/client';
 import './index.css';
 import AppEntry from './AppEntry';
 import { registerWebMcpTools } from './services/webMcpService';
 import { connectWebMcpBridge } from './share/webmcp';
 
-connectWebMcpBridge();
+const removeStaleMockWorkers = async (): Promise<boolean> => {
+  if (!import.meta.env.DEV || !('serviceWorker' in navigator)) return false;
+  const registrations = await navigator.serviceWorker.getRegistrations();
+  const staleRegistrations = registrations.filter((registration) =>
+    registration.active?.scriptURL.endsWith('/mockServiceWorker.js')
+  );
+  if (!staleRegistrations.length) return false;
+  await Promise.all(staleRegistrations.map((registration) => registration.unregister()));
+  return true;
+};
 
-void registerWebMcpTools().then((registration) => {
+const startHostApp = async (): Promise<void> => {
+  // Remove old mock workers before any host API or WebMCP request can start.
+  if (await removeStaleMockWorkers()) {
+    window.location.reload();
+    return;
+  }
+
+  connectWebMcpBridge();
 
+  const runtime = globalThis as typeof globalThis & {
+    __AXONIX_REACT__?: typeof React;
+    __AXONIX_REACT_DOM__?: typeof ReactDOM;
+    __AXONIX_REACT_DOM_CLIENT__?: typeof ReactDOMClient;
+  };
+  runtime.__AXONIX_REACT__ = React;
+  runtime.__AXONIX_REACT_DOM__ = ReactDOM;
+  runtime.__AXONIX_REACT_DOM_CLIENT__ = ReactDOMClient;
+
+  const registration = await registerWebMcpTools();
   if (!registration.supported || registration.error) {
     console.info('[WebMCP] 当前页面未注册工具', registration.error || '浏览器未启用 WebMCP');
   }
-});
 
-createRoot(document.getElementById('root')!).render(
-  <StrictMode>
-    <AppEntry />
-  </StrictMode>
-);
+  ReactDOMClient.createRoot(document.getElementById('root')!).render(
+    <React.StrictMode>
+      <AppEntry />
+    </React.StrictMode>
+  );
+};
+
+void startHostApp();

src/react-jsx-dev-runtime.ts

@@ -0,0 +1,7 @@
+import { Fragment, jsx, jsxs } from './react-jsx-runtime';
+
+export { Fragment, jsx, jsxs };
+
+export const jsxDEV = jsx;
+
+export default { Fragment, jsx, jsxs, jsxDEV };

src/react-jsx-runtime.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+
+export const Fragment = React.Fragment;
+
+export const jsx = (type: React.ElementType, props: Record<string, unknown>, key?: React.Key) => {
+  const children = props?.children;
+  if (Array.isArray(children)) {
+    const { children: _children, ...rest } = props;
+    return React.createElement(type, { ...rest, key }, ...children);
+  }
+  return React.createElement(type, { ...props, key });
+};
+
+export const jsxs = jsx;
+
+export default { Fragment, jsx, jsxs };

src/services/aiChatService.ts

@@ -48,6 +48,10 @@ export interface ChatCompletionRequest {
   detail?: boolean;
   /** Chat messages */
   messages: ChatMessage[];
+  agentId?: string | null;
+  model?: string;
+  tools?: string[];
+  fileUrls?: Array<{ uid: string; name: string; url: string }>;
 }
 
 /**
@@ -71,6 +75,7 @@ export interface ChatCompletionResponse {
  */
 interface AIChatConfig {
   apiUrl: string;
+  modChatApiUrl: string;
 }
 
 /**
@@ -79,10 +84,74 @@ interface AIChatConfig {
 const getAIChatConfig = (): AIChatConfig => {
   return {
     apiUrl: import.meta.env.VITE_AI_PROXY_URL,
+    modChatApiUrl: import.meta.env.VITE_MOD_CHAT_API_BASE_URL,
   };
 };
 
 /**
+ * Send a normal chat message through the same Composer backend used by mod-chat.
+ * The host still owns session/workflow/WebMCP orchestration; this adapter only
+ * replaces the normal text completion request.
+ */
+const sendModChatCompletion = async (
+  request: ChatCompletionRequest,
+  baseUrl: string,
+): Promise<ChatCompletionResponse> => {
+  const normalizedBaseUrl = baseUrl.replace(/\/$/, '');
+  const payload = {
+    dialog_id: request.chatId,
+    axf_asset_id: request.agentId ?? '',
+    chat_input: request.messages.at(-1)?.content ?? '',
+    model: request.model ?? 'axonix-chat',
+    tools: request.tools ?? [],
+    file_urls: (request.fileUrls ?? []).map((file) => file.url),
+    streaming: true,
+  };
+
+  const runResponse = await fetchWithTimeout(`${normalizedBaseUrl}/composer/runs`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(payload),
+  });
+  if (!runResponse.ok) {
+    throw new Error(`Composer 创建运行失败 (${runResponse.status})`);
+  }
+
+  const runData = (await runResponse.json()) as { run_id?: string };
+  if (!runData.run_id) throw new Error('Composer 未返回 run_id');
+
+  const streamResponse = await fetchWithTimeout(`${normalizedBaseUrl}/composer/runs/start`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', Accept: 'text/event-stream' },
+    body: JSON.stringify({ ...payload, run_id: runData.run_id }),
+  });
+  if (!streamResponse.ok) {
+    throw new Error(`Composer 启动运行失败 (${streamResponse.status})`);
+  }
+
+  const responseText = await streamResponse.text();
+  const chunks = responseText
+    .split(/\r?\n/)
+    .filter((line) => line.startsWith('data:'))
+    .map((line) => line.slice(5).trim())
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        const event = JSON.parse(line) as {
+          content?: { items?: Array<{ kind?: string; data?: { content?: unknown } }> };
+        };
+        const item = event.content?.items?.find((entry) => entry.kind === 'llm_result');
+        return typeof item?.data?.content === 'string' ? item.data.content : '';
+      } catch {
+        return '';
+      }
+    })
+    .filter(Boolean);
+
+  return { content: chunks.join('') || responseText.trim() };
+};
+
+/**
  * Send a chat completion request to AI platform
  *
  * @param request - Chat completion request
@@ -95,6 +164,15 @@ export const sendChatCompletion = async (
   try {
     const config = getAIChatConfig();
 
+    if (config.modChatApiUrl) {
+      try {
+        return await sendModChatCompletion(request, config.modChatApiUrl);
+      } catch (error) {
+        if (!config.apiUrl) throw error;
+        console.warn('mod-chat Composer 不可用，回退到宿主 AI 代理', error);
+      }
+    }
+
     if (!config.apiUrl) {
       if (import.meta.env.PROD) {
         throw new Error('AI 服务未配置，请先配置服务端代理');
@@ -112,6 +190,10 @@ export const sendChatCompletion = async (
         stream: request.stream ?? false,
         detail: request.detail ?? false,
         messages: request.messages,
+        agentId: request.agentId,
+        model: request.model,
+        tools: request.tools,
+        fileUrls: request.fileUrls,
       }),
     });
 

src/services/webMcpAgentService.ts

@@ -156,20 +156,18 @@ const loadDocumentCandidates = async (): Promise<ExportCandidate[]> => {
         if (!record || typeof record !== 'object') continue;
         const item = record as Record<string, unknown>;
         if (typeof item.documentId !== 'string' || typeof item.fileName !== 'string') continue;
+        const exportTitle = item.fileName.replace(/\.(docx?|DOCX?)$/i, '').trim();
+        const baseExportTitle = exportTitle.replace(/[_-]\d{8,}(?:[_-][a-f0-9]{8})?$/i, '').trim();
         const candidate = unique.get(item.documentId) || {
           documentId: item.documentId,
-          title: item.fileName
-            .replace(/\.(docx?|DOCX?)$/i, '')
-            .replace(/[_-]\d{8,}$/, '')
-            .trim(),
+          title: exportTitle,
         };
-        const exportTitle = item.fileName
-          .replace(/\.(docx?|DOCX?)$/i, '')
-          .replace(/[_-]\d{8,}$/, '')
-          .trim();
         if (exportTitle && exportTitle !== candidate.title) {
           candidate.aliases = [...new Set([...(candidate.aliases || []), exportTitle])];
         }
+        if (baseExportTitle && baseExportTitle !== candidate.title) {
+          candidate.aliases = [...new Set([...(candidate.aliases || []), baseExportTitle])];
+        }
         if (!candidate.recordId && typeof item.recordId === 'string')
           candidate.recordId = item.recordId;
         unique.set(item.documentId, candidate);
@@ -191,29 +189,55 @@ const normalizeDocumentText = (value: string): string =>
 const findDocumentCandidate = (
   title: string,
   candidates: ExportCandidate[]
-): { candidate?: ExportCandidate; ambiguous: boolean } => {
+): { candidate?: ExportCandidate; ambiguous: boolean; matches?: ExportCandidate[] } => {
   const normalizedTitle = normalizeDocumentText(title);
   const matches = candidates.filter((candidate) => {
     const candidateTitles = [candidate.title, ...(candidate.aliases || [])].map(
       normalizeDocumentText
     );
-    return (
-      candidate.documentId === title ||
-      candidate.recordId === title ||
-      candidateTitles.some(
-        (candidateTitle) =>
-          candidateTitle === normalizedTitle ||
-          candidateTitle.includes(normalizedTitle) ||
-          normalizedTitle.includes(candidateTitle)
-      )
+    return candidate.documentId === title || candidate.recordId === title || candidateTitles.includes(normalizedTitle);
+  });
+  if (matches.length === 1) return { candidate: matches[0], ambiguous: false, matches };
+  if (matches.length > 1) return { ambiguous: true, matches };
+
+  const fuzzyMatches = candidates.filter((candidate) => {
+    const candidateTitles = [candidate.title, ...(candidate.aliases || [])].map(
+      normalizeDocumentText
+    );
+    return candidateTitles.some(
+      (candidateTitle) =>
+        candidateTitle.includes(normalizedTitle) || normalizedTitle.includes(candidateTitle)
     );
   });
   return {
-    candidate: matches.length === 1 ? matches[0] : undefined,
-    ambiguous: matches.length > 1,
+    candidate: fuzzyMatches.length === 1 ? fuzzyMatches[0] : undefined,
+    ambiguous: fuzzyMatches.length > 1,
+    matches: fuzzyMatches,
   };
 };
 
+const formatAmbiguousDocuments = (title: string, candidates: ExportCandidate[]): string => {
+  const lines = candidates.slice(0, 10).map((candidate, index) => {
+    const uniqueName = candidate.aliases?.find((alias) => /_\d{8,}(?:_[a-f0-9]{8})?$/i.test(alias));
+    return `${index + 1}. ${uniqueName || candidate.title}（文档 ID：${candidate.documentId}）`;
+  });
+  return `找到多份与“${title}”相近的文档，请使用完整文件名或文档 ID：\n${lines.join('\n')}`;
+};
+
+const resolveOpenDocument = async (
+  title: string
+): Promise<{ candidate?: ExportCandidate; response?: string }> => {
+  const candidates = await getDocumentCandidates();
+  const match = findDocumentCandidate(title, candidates);
+  if (match.ambiguous) {
+    return { response: formatAmbiguousDocuments(title, match.matches || []) };
+  }
+  if (!match.candidate) {
+    return { response: `没有找到名为“${title}”的文档，请先列出文档或使用文档 ID。` };
+  }
+  return { candidate: match.candidate };
+};
+
 const getActionHelp = (action: string): string => {
   if (action === 'download_export_record')
     return '请告诉我要下载的文档名称，例如：下载产品说明文档。';
@@ -346,11 +370,12 @@ const parseLocalDocumentCommand = async (
   if (!remainder || (isBlockAction && !blockId && !blockReference))
     return { handled: true, response: getActionHelp(toolName) };
   const candidates = await getDocumentCandidates();
-  const { candidate, ambiguous } = findDocumentCandidate(remainder, candidates);
+  const documentMatch = findDocumentCandidate(remainder, candidates);
+  const { candidate, ambiguous } = documentMatch;
   if (ambiguous)
     return {
       handled: true,
-      response: `找到多份与“${remainder}”相近的文档，请提供更完整的文档名称。`,
+      response: formatAmbiguousDocuments(remainder, documentMatch.matches || []),
     };
   if (!candidate)
     return { handled: true, response: `没有找到名为“${remainder}”的文档，请确认文档名称后重试。` };
@@ -609,26 +634,37 @@ export const executeWebMcpChatCommand = async (content: string): Promise<WebMcpC
   const tool = getWebMcpTool(toolName);
   if (!tool) return { handled: true, response: `WebMCP 工具不存在：${toolName}`, toolName };
 
+  let matchedInput = matched.input;
+  let documentTitle: string | undefined;
+  if (toolName === 'open_document' && typeof matched.input.documentId === 'string') {
+    const resolved = await resolveOpenDocument(matched.input.documentId);
+    if (resolved.response) return { handled: true, response: resolved.response, toolName };
+    if (resolved.candidate) {
+      matchedInput = { documentId: resolved.candidate.documentId };
+      documentTitle = resolved.candidate.title;
+    }
+  }
+
   if (!READ_ONLY_TOOLS.has(toolName)) {
     return {
       handled: true,
       toolName,
       template: matched.template,
-      input: matched.input,
+      input: matchedInput,
       requiresConfirmation: true,
-      response: `该操作需要确认：${matched.template.label}\n${JSON.stringify(matched.input, null, 2)}`,
+      response: `该操作需要确认：${matched.template.label}\n${JSON.stringify(matchedInput, null, 2)}`,
     };
   }
 
-  const result = await executeWebMcpTool(toolName, matched.input);
+  const result = await executeWebMcpTool(toolName, matchedInput);
   return {
     handled: true,
     toolName,
     template: matched.template,
-    input: matched.input,
+    input: matchedInput,
     requiresConfirmation: false,
     result,
-    response: friendlyResult(toolName, matched.input, result),
+    response: friendlyResult(toolName, { ...matchedInput, documentTitle }, result),
   };
 };
 

src/services/webMcpChatTemplates.ts

@@ -26,7 +26,7 @@ const template = (
 
 export const webMcpChatTemplates: ReadonlyArray<WebMcpChatTemplate> = [
     template('list_documents', '列出我的文档', /^列出(?:我的|当前用户的)?文档$/, ['列出我的文档'], () => ({})),
-    template('open_document', '打开文档', /^(?:打开|查看)\s+(\S+)\s+文档$/, ['查看 doc-abc123 文档'], (match) => ({ documentId: match[1] })),
+    template('open_document', '打开文档', /^(?:打开|查看)\s+(.+?)\s+文档$/, ['查看 doc-abc123 文档'], (match) => ({ documentId: match[1] })),
     template('get_document', '读取文档', /^读取文档\s+(\S+)$/, ['读取文档 doc-abc123'], (match) => ({ documentId: match[1] })),
     template('search_document', '搜索文档', /^搜索文档\s+(\S+)\s+(.+)$/, ['搜索文档 doc-abc123 WebMCP'], (match) => ({ documentId: match[1], query: match[2] })),
     template('get_block', '读取文档块', /^读取文档块\s+(\S+)\s+(\S+)$/, ['读取文档块 doc-abc123 block-p-50'], (match) => ({ documentId: match[1], blockId: match[2] })),

src/services/webMcpService.ts

@@ -43,6 +43,10 @@ interface WebMcpNavigator extends Navigator {
 	modelContext?: ModelContext;
 }
 
+interface WebMcpDocument extends Document {
+	modelContext?: ModelContext;
+}
+
 export interface WebMcpRegistrationResult {
 	supported: boolean;
 	registeredTools: string[];
@@ -178,7 +182,7 @@ const tools: WebMcpTool[] = [
 	{
 		name: 'open_document',
 		title: '打开文档',
-		description: '在当前网站编辑器中打开指定文档。只读操作。',
+		description: '在当前网站编辑器中打开指定文档。请使用文档 ID 或导出文件的完整唯一文件名；同名文档需先列出候选。只读操作。',
 		readOnlyHint: true,
 		inputSchema: objectSchema({ documentId: documentIdProperty }, ['documentId']),
 		execute: (input) => run(async () => {
@@ -433,12 +437,13 @@ export const executeWebMcpTool = async (
 export const registerWebMcpTools = (): Promise<WebMcpRegistrationResult> => {
 	if (registrationPromise) return registrationPromise;
 	registrationPromise = (async () => {
-		const modelContext = (navigator as WebMcpNavigator).modelContext;
+		const modelContext =
+			(document as WebMcpDocument).modelContext ?? (navigator as WebMcpNavigator).modelContext;
 		if (!modelContext) return { supported: false, registeredTools: [], error: '当前浏览器未提供 navigator.modelContext' };
 		try {
 			const definitions = browserTools();
-			if (modelContext.provideContext) await modelContext.provideContext({ tools: definitions });
-			else if (modelContext.registerTool) for (const tool of definitions) await modelContext.registerTool(tool);
+			if (modelContext.registerTool) for (const tool of definitions) await modelContext.registerTool(tool);
+			else if (modelContext.provideContext) await modelContext.provideContext({ tools: definitions });
 			else return { supported: true, registeredTools: [], error: 'WebMCP API 不支持工具注册' };
 			return { supported: true, registeredTools: tools.map((tool) => tool.name) };
 		} catch (error) {

src/services/workflowService.ts

@@ -28,6 +28,9 @@ interface WorkflowRequest {
   chatId: string;
   sessionId?: string; // 新增：显式传递sessionId
   timestamp?: number; // 新增：时间戳避免缓存
+  requestId?: string;
+  input?: string;
+  query?: string;
   stream?: boolean;
   detail?: boolean;
   messages: WorkflowMessage[];
@@ -69,6 +72,17 @@ interface WorkflowResponse {
   }>;
 }
 
+type WorkflowRecord = NonNullable<WorkflowResponse['records']>[number];
+
+const isWorkflowRecordFresh = (record: WorkflowRecord, requestTimestamp: number): boolean =>
+  typeof record.createdAt !== 'number' || record.createdAt >= requestTimestamp - 5_000;
+
+const selectWorkflowRecord = (records: WorkflowRecord[], requestTimestamp: number): WorkflowRecord | undefined => {
+  const freshRecord = records.find((record) => isWorkflowRecordFresh(record, requestTimestamp));
+  return freshRecord ??
+    [...records].sort((left, right) => (right.createdAt ?? 0) - (left.createdAt ?? 0))[0];
+};
+
 /**
  * Configuration for Workflow API
  */
@@ -101,6 +115,18 @@ const normalizeExportDownloadUrl = (downloadUrl: string): string => {
   return downloadUrl;
 };
 
+/** Give every workflow result a unique client-visible name, even when the
+ * workflow returns the same base filename for repeated requests. */
+const makeUniqueExportFileName = (fileName: string, requestTimestamp: number): string => {
+  const extensionMatch = fileName.match(/(\.[^./\\]+)$/);
+  const extension = extensionMatch?.[1] || '.docx';
+  const baseName = extensionMatch ? fileName.slice(0, -extension.length) : fileName;
+  const randomSuffix = typeof crypto !== 'undefined' && 'randomUUID' in crypto
+    ? crypto.randomUUID().slice(0, 8)
+    : Math.random().toString(16).slice(2, 10);
+  return `${baseName || '导出文档'}_${requestTimestamp}_${randomSuffix}${extension}`;
+};
+
 /**
  * Check if user input should trigger document generation workflow
  *
@@ -152,6 +178,7 @@ export const triggerDocumentWorkflow = async (
     // 这样工作流会为每个请求生成新的文档,但它们都关联到同一个sessionId
     const timestamp = Date.now();
     const uniqueChatId = `${sessionId}__${timestamp}`;
+    const requestId = `${uniqueChatId}__document`;
 
     // Call the workflow API
     // 关键点:
@@ -167,6 +194,9 @@ export const triggerDocumentWorkflow = async (
         chatId: uniqueChatId, // 带时间戳的唯一ID，避免工作流缓存
         sessionId: sessionId, // 原始sessionId，供工作流调用后端API时使用
         timestamp: timestamp, // 显式传递时间戳
+        requestId,
+        input: userInput,
+        query: userInput,
         stream: false,
         detail: false,
         messages: [
@@ -197,6 +227,8 @@ export const triggerDocumentWorkflow = async (
       try {
         const parsedContent = JSON.parse(content);
 
+        const noFreshRecordMessage = '⚠️ 工作流未返回本次请求生成的新文档，请检查工作流输入配置';
+
         // Handle nested response format: { code: 0, data: { records: [...] } }
         if (
           parsedContent.code === 0 &&
@@ -204,8 +236,8 @@ export const triggerDocumentWorkflow = async (
           Array.isArray(parsedContent.data.records)
         ) {
           const records = parsedContent.data.records;
-          if (records.length > 0) {
-            const record = records[0];
+          const record = selectWorkflowRecord(records, timestamp);
+          if (record) {
             exportRecord = {
               recordId: record.recordId,
               fileName: record.fileName || '导出文档.docx',
@@ -215,6 +247,8 @@ export const triggerDocumentWorkflow = async (
 
             // Update content to be more user-friendly
             content = '✅ 文档已生成，点击下方卡片预览或下载';
+          } else {
+            content = noFreshRecordMessage;
           }
         }
         // Handle direct records array format
@@ -223,41 +257,53 @@ export const triggerDocumentWorkflow = async (
           Array.isArray(parsedContent.records) &&
           parsedContent.records.length > 0
         ) {
-          const record = parsedContent.records[0];
-          exportRecord = {
-            recordId: record.recordId,
-            fileName: record.fileName || '导出文档.docx',
-            downloadUrl: record.downloadUrl,
-            documentId: record.documentId || record.recordId,
-          };
-
-          // Update content to be more user-friendly
-          content = '✅ 文档已生成，点击下方卡片预览或下载';
+          const record = selectWorkflowRecord(parsedContent.records, timestamp);
+          if (!record) {
+            content = noFreshRecordMessage;
+          } else {
+            exportRecord = {
+              recordId: record.recordId,
+              fileName: record.fileName || '导出文档.docx',
+              downloadUrl: record.downloadUrl,
+              documentId: record.documentId || record.recordId,
+            };
+
+            // Update content to be more user-friendly
+            content = '✅ 文档已生成，点击下方卡片预览或下载';
+          }
         }
         // Handle single record object format (not wrapped in array)
         else if (parsedContent.recordId && parsedContent.downloadUrl) {
-          exportRecord = {
-            recordId: parsedContent.recordId,
-            fileName: parsedContent.fileName || '导出文档.docx',
-            downloadUrl: parsedContent.downloadUrl,
-            documentId: parsedContent.documentId || parsedContent.recordId,
-          };
-
-          // Update content to be more user-friendly
-          content = '✅ 文档已生成，点击下方卡片预览或下载';
+          if (isWorkflowRecordFresh(parsedContent, timestamp)) {
+            exportRecord = {
+              recordId: parsedContent.recordId,
+              fileName: parsedContent.fileName || '导出文档.docx',
+              downloadUrl: parsedContent.downloadUrl,
+              documentId: parsedContent.documentId || parsedContent.recordId,
+            };
+
+            // Update content to be more user-friendly
+            content = '✅ 文档已生成，点击下方卡片预览或下载';
+          } else {
+            content = noFreshRecordMessage;
+          }
         }
         // Handle nested data format with single record
         else if (parsedContent.data && parsedContent.data.recordId) {
           const record = parsedContent.data;
-          exportRecord = {
-            recordId: record.recordId,
-            fileName: record.fileName || '导出文档.docx',
-            downloadUrl: record.downloadUrl,
-            documentId: record.documentId || record.recordId,
-          };
-
-          // Update content to be more user-friendly
-          content = '✅ 文档已生成，点击下方卡片预览或下载';
+          if (isWorkflowRecordFresh(record, timestamp)) {
+            exportRecord = {
+              recordId: record.recordId,
+              fileName: record.fileName || '导出文档.docx',
+              downloadUrl: record.downloadUrl,
+              documentId: record.documentId || record.recordId,
+            };
+
+            // Update content to be more user-friendly
+            content = '✅ 文档已生成，点击下方卡片预览或下载';
+          } else {
+            content = noFreshRecordMessage;
+          }
         }
       } catch {
         // Content looks like JSON but failed to parse
@@ -267,28 +313,35 @@ export const triggerDocumentWorkflow = async (
     // Check for export record in top-level response
     if (!exportRecord && data.exportRecord) {
       // Single export record format
-      exportRecord = {
-        recordId: data.exportRecord.recordId,
-        fileName: data.exportRecord.fileName,
-        downloadUrl: data.exportRecord.downloadUrl,
-        documentId: data.exportRecord.documentId,
-      };
-      content = '✅ 文档已生成，点击下方卡片预览或下载';
+      if (typeof data.exportRecord.createdAt !== 'number' || data.exportRecord.createdAt >= timestamp - 5_000) {
+        exportRecord = {
+          recordId: data.exportRecord.recordId,
+          fileName: data.exportRecord.fileName,
+          downloadUrl: data.exportRecord.downloadUrl,
+          documentId: data.exportRecord.documentId,
+        };
+        content = '✅ 文档已生成，点击下方卡片预览或下载';
+      }
     } else if (!exportRecord && data.records && data.records.length > 0) {
       // Records array format (take the first one)
-      const record = data.records[0];
-      exportRecord = {
-        recordId: record.recordId,
-        fileName: record.fileName,
-        downloadUrl: record.downloadUrl,
-        documentId: record.documentId,
-      };
-      content = '✅ 文档已生成，点击下方卡片预览或下载';
+      const record = selectWorkflowRecord(data.records, timestamp);
+      if (record) {
+        exportRecord = {
+          recordId: record.recordId,
+          fileName: record.fileName,
+          downloadUrl: record.downloadUrl,
+          documentId: record.documentId,
+        };
+        content = '✅ 文档已生成，点击下方卡片预览或下载';
+      }
     }
 
     if (exportRecord?.downloadUrl) {
       exportRecord.downloadUrl = normalizeExportDownloadUrl(exportRecord.downloadUrl);
     }
+    if (exportRecord?.fileName) {
+      exportRecord.fileName = makeUniqueExportFileName(exportRecord.fileName, timestamp);
+    }
 
     return {
       content,

src/stores/chatStore.ts

@@ -22,7 +22,7 @@
 
 import { create } from 'zustand';
 import type { ChatStoreState } from '../types/store';
-import type { ChatMessage, ChatSession, ExportRecordInfo } from '../types/chat';
+import type { ChatMessage, ChatSession, ChatSendOptions, ExportRecordInfo } from '../types/chat';
 import { v4 as uuidv4 } from 'uuid';
 import { message, Modal } from 'antd';
 import { sendChatCompletion, createTextMessage } from '../services/aiChatService';
@@ -189,7 +189,8 @@ const generateSessionTitle = (firstMessage: string): string => {
 const getAIResponse = async (
   userMessage: string,
   sessionId: string,
-  messageHistory: ChatMessage[]
+  messageHistory: ChatMessage[],
+  options?: ChatSendOptions,
 ): Promise<{ response: string; shouldExport: boolean; title: string }> => {
   // Build message history for API
   const apiMessages = messageHistory
@@ -205,6 +206,10 @@ const getAIResponse = async (
     stream: false,
     detail: false,
     messages: apiMessages,
+    agentId: options?.agentId,
+    model: options?.model,
+    tools: options?.tools,
+    fileUrls: options?.fileUrls,
   });
 
   // Check if the response indicates document generation
@@ -308,6 +313,15 @@ export const useChatStore = create<ChatStoreState>((set, get) => ({
 
     return sessionId;
   },
+  updateSessionSettings: (sessionId, settings) => {
+    const updatedSessions = get().sessions.map((session) =>
+      session.id === sessionId
+        ? { ...session, settings: { ...session.settings, ...settings }, updatedAt: Date.now() }
+        : session
+    );
+    set({ sessions: updatedSessions });
+    scheduleSessionsStorageSave(updatedSessions);
+  },
 
   /**
    * Load an existing session by ID
@@ -400,7 +414,7 @@ export const useChatStore = create<ChatStoreState>((set, get) => ({
    * @param content - User message content
    * @throws {Error} When AI service call fails
    */
-  sendMessage: async (content: string) => {
+  sendMessage: async (content: string, options?: ChatSendOptions) => {
     try {
       // Create session if not exists
       let sessionId = get().currentSessionId;
@@ -504,7 +518,7 @@ export const useChatStore = create<ChatStoreState>((set, get) => ({
         }
       } else {
         // Use regular AI service for normal chat
-        const aiResult = await getAIResponse(content, sessionId, get().messages);
+        const aiResult = await getAIResponse(content, sessionId, get().messages, options);
         aiResponse = aiResult.response;
         exportRecord = undefined;
       }

src/types/chat.ts

@@ -32,6 +32,13 @@ export interface ChatMessage {
   exportRecord?: ExportRecordInfo;
 }
 
+export interface ChatSendOptions {
+  agentId?: string | null;
+  model?: string;
+  tools?: string[];
+  fileUrls?: Array<{ uid: string; name: string; url: string }>;
+}
+
 /**
  * Chat session interface
  */
@@ -48,4 +55,5 @@ export interface ChatSession {
   updatedAt: number;
   /** List of export records associated with this session */
   exportRecords: ExportRecordInfo[];
+  settings?: Record<string, unknown>;
 }

src/types/mod-chat.d.ts

@@ -0,0 +1,37 @@
+declare module 'mod_chat/App' {
+  import type { ComponentType } from 'react';
+
+  interface ChatHostSendOptions {
+    agentId: string | null;
+    model: string;
+    tools: string[];
+    fileUrls: Array<{ uid: string; name: string; url: string }>;
+  }
+
+  interface ModChatProps {
+    layoutMode?: 'full-page' | 'embedded-widget';
+    hostBridge?: {
+      messages: Array<{
+        id: string;
+        role: 'user' | 'assistant';
+        content: string;
+        createdAt: number;
+        exportRecord?: { documentId?: string; fileName?: string; downloadUrl?: string };
+      }>;
+      isLoading: boolean;
+      onSendMessage: (content: string, options?: ChatHostSendOptions) => Promise<void>;
+      sessions: Array<{ id: string; title: string; updatedAt: number; settings?: Record<string, unknown> }>;
+      activeSessionId: string | null;
+      onCreateSession: () => void;
+      onSelectSession: (sessionId: string) => void;
+      onDeleteSession: (sessionId: string) => Promise<void>;
+      onRenameSession: (sessionId: string, title: string) => void;
+      onUpdateSessionSettings: (sessionId: string, settings: Record<string, unknown>) => void;
+      onPreviewDocument?: (documentId: string, documentName?: string) => void;
+      onDownloadDocument?: (downloadUrl: string, fileName?: string) => Promise<void>;
+    };
+  }
+
+  const ModChatApp: ComponentType<ModChatProps>;
+  export default ModChatApp;
+}

src/types/store.ts

@@ -3,7 +3,7 @@
  */
 
 import type { Document, DocumentListItem, CreateDocumentRequest } from './document';
-import type { ChatMessage, ChatSession } from './chat';
+import type { ChatMessage, ChatSession, ChatSendOptions } from './chat';
 import type { SaveStatus } from './ui';
 import type { ListFilters, PaginationInfo } from './api';
 
@@ -60,13 +60,15 @@ export interface ChatStoreState {
   /** Delete a session by ID (calls backend API to delete documents) */
   deleteSession: (sessionId: string) => Promise<void>;
   /** Send a message to AI and get response */
-  sendMessage: (content: string) => Promise<void>;
+  sendMessage: (content: string, options?: ChatSendOptions) => Promise<void>;
   /** Add a message to the current session */
   addMessage: (message: ChatMessage) => void;
   /** Clear all messages in current session */
   clearMessages: () => void;
   /** Update session title */
   updateSessionTitle: (sessionId: string, title: string) => void;
+  /** Update host-owned session settings */
+  updateSessionSettings: (sessionId: string, settings: Record<string, unknown>) => void;
 }
 
 /**

vite.config.ts

@@ -1,15 +1,35 @@
 import { defineConfig, loadEnv } from 'vite';
 import react from '@vitejs/plugin-react';
 import { visualizer } from 'rollup-plugin-visualizer';
+import federation from '@originjs/vite-plugin-federation';
 
 // https://vite.dev/config/
 export default defineConfig(({ mode }) => {
   const env = loadEnv(mode, process.cwd(), '');
   const apiTarget = env.VITE_API_BASE_URL || 'http://localhost:8000';
+  const modChatApiTarget = env.VITE_MOD_CHAT_API_BASE_URL || apiTarget;
 
   return {
   plugins: [
     react(),
+    federation({
+      name: 'ax_frontend_app',
+      remotes: {
+        mod_chat: env.VITE_MOD_CHAT_REMOTE_URL || 'http://localhost:5172/assets/remoteEntry.js',
+      },
+      shared: {
+        react: { requiredVersion: false },
+        'react-dom': { requiredVersion: false },
+        'react/jsx-runtime': {
+          packagePath: './src/react-jsx-runtime.ts',
+          requiredVersion: false,
+        },
+        'react/jsx-dev-runtime': {
+          packagePath: './src/react-jsx-dev-runtime.ts',
+          requiredVersion: false,
+        },
+      },
+    }),
     
     // Bundle 分析工具（通过 ANALYZE=true 环境变量启用）
     process.env.ANALYZE === 'true' && visualizer({
@@ -65,6 +85,30 @@ export default defineConfig(({ mode }) => {
         target: apiTarget,
         changeOrigin: true,
       },
+      '/composer': {
+        target: modChatApiTarget,
+        changeOrigin: true,
+      },
+      '/registry': {
+        target: env.VITE_MOD_CHAT_REGISTRY_API_BASE_URL || modChatApiTarget,
+        changeOrigin: true,
+      },
+      '/agents': {
+        target: modChatApiTarget,
+        changeOrigin: true,
+      },
+      '/models': {
+        target: modChatApiTarget,
+        changeOrigin: true,
+      },
+      '/tools': {
+        target: modChatApiTarget,
+        changeOrigin: true,
+      },
+      '/sessions': {
+        target: modChatApiTarget,
+        changeOrigin: true,
+      },
     },
   },
 
@@ -77,6 +121,30 @@ export default defineConfig(({ mode }) => {
         target: apiTarget,
         changeOrigin: true,
       },
+      '/composer': {
+        target: modChatApiTarget,
+        changeOrigin: true,
+      },
+      '/registry': {
+        target: env.VITE_MOD_CHAT_REGISTRY_API_BASE_URL || modChatApiTarget,
+        changeOrigin: true,
+      },
+      '/agents': {
+        target: modChatApiTarget,
+        changeOrigin: true,
+      },
+      '/models': {
+        target: modChatApiTarget,
+        changeOrigin: true,
+      },
+      '/tools': {
+        target: modChatApiTarget,
+        changeOrigin: true,
+      },
+      '/sessions': {
+        target: modChatApiTarget,
+        changeOrigin: true,
+      },
     },
   },