@opentiny/next 0.0.1 → 0.1.1

package/README.md

@@ -1 +1,437 @@
-OpenTiny NEXT
+# OpenTiny NEXT
+
+OpenTiny NEXT 是一个基于 Model Context Protocol（MCP）的 TypeScript 库，提供了多种传输方式来支持 MCP 客户端与服务端的通信。本库支持三种主要的传输方式：
+
+1. MessageChannel API - 用于浏览器内部不同上下文之间的通信
+2. SSE (Server-Sent Events) Client Proxy - 基于 HTTP 长连接实现单向数据推送的 Client 连接代理
+3. Streamable HTTP Client Proxy - 通过分块传输编码实现任意数据的流式传输的 Client 连接代理
+
+## 安装
+
+```bash
+npm install @opentiny/next
+```
+
+## 客户端 API (client.js)
+
+客户端 API 主要用于在浏览器环境中的 MCP 通信。
+
+### MessageChannel API
+
+#### 在同一浏览器窗口内互相通信的场景
+
+使用 `createTransportPair` 创建一对可互通的 Transport 服务的和客户端实例来进行通信。
+
+```typescript
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { createTransportPair } from '@opentiny/next';
+
+// 创建一对可互通的 Transport 实例
+const [serverTransport, clientTransport] = createTransportPair();
+
+// 创建 MCP 服务端和客户端实例
+const capabilities = { prompts: {}, resources: {}, tools: {}, logging: {} };
+const server = new McpServer({ name: 'mcp-server', version: '1.0.0' }, { capabilities });
+const client = new Client({ name: 'mcp-client', version: '1.0.0' }, { capabilities });
+
+// 建立服务端和客户端的通信连接
+await server.connect(serverTransport);
+await client.connect(clientTransport);
+
+// 将客户端实例存储到状态中
+state.client = client;
+```
+
+#### 在浏览器主线程与iframe、Web Worker等互相通信的场景
+
+使用 `MessageChannelServerTransport` 和 `MessageChannelClientTransport` 创建用于监听的 Transport 服务端实例，以及用于连接的 Transport 客户端实例来进行通信。
+
+以下是在浏览器主线程的代码：
+
+```typescript
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { MessageChannelServerTransport } from '@opentiny/next';
+
+// 创建用于监听的 Transport 服务端实例
+const serverTransport = new MessageChannelServerTransport('endpoint');
+
+// 创建 MCP 服务端实例
+const capabilities = { prompts: {}, resources: {}, tools: {}, logging: {} };
+const server = new McpServer({ name: 'mcp-server', version: '1.0.0' }, { capabilities });
+
+// 监听 endpoint 端点，等待客户端连接
+await serverTransport.listen();
+
+// 建立服务端和客户端的通信连接
+await server.connect(serverTransport);
+```
+
+以下是在 iframe、Web Worker 的代码：
+
+```typescript
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { MessageChannelClientTransport } from '@opentiny/next';
+
+// 创建用于连接的 Transport 客户端实例
+const clientTransport = new MessageChannelClientTransport('endpoint');
+
+// 创建 MCP 客户端实例
+const capabilities = { prompts: {}, resources: {}, tools: {}, logging: {} };
+const client = new Client({ name: 'mcp-client', version: '1.0.0' }, { capabilities });
+
+// 建立服务端和客户端的通信连接
+await client.connect(clientTransport);
+
+// 将客户端实例存储到状态中
+state.client = client;
+```
+
+请注意：创建 `MessageChannelServerTransport` 实例必须在创建 `MessageChannelClientTransport` 实例之前，确保客户端连接之前服务端已经开始监听。由于 iframe、Web Worker 等代码运行通常在浏览器主线程之后，所以上述示例代码执行顺序一般是先创建 `MessageChannelServerTransport` 实例，后创建 `MessageChannelClientTransport` 实例。
+
+### SSE (Server-Sent Events) Client Proxy
+
+使用 `MessageChannel API` 创建的 `Client` 客户端实例运行在浏览器环境中，为了能够被后端服务的 AI 调用，需要借助 `createSseProxy` 方法创建该 `Client` 的代理。
+
+```typescript
+import { createSseProxy, ProxySSEClientTransport } from '@opentiny/next';
+import type { Client } from '@modelcontextprotocol/sdk/client/index.js';
+
+// 定义页面的状态
+const state: {
+  sseTransport: ProxySSEClientTransport | undefined;
+  client: Client | undefined;
+} = {
+  sseTransport: undefined,
+  client: undefined
+};
+
+// 使用 SSE 代理连接到服务端
+const connectSseProxy = async () => {
+  if (!state.sseTransport) {
+    const { transport, sessionId } = await createSseProxy({
+      client: state.client as Client,
+      url: location + 'agent/sse',
+      token: process.env.USER_TOKEN as string
+    });
+
+    state.sseTransport = transport;
+  }
+};
+
+// 使用 SSE 代理调用工具方法
+const callSseProxy = async (question: string) => {
+  if (!state.sseTransport) {
+    console.error('You need to connect SSE Proxy first!');
+    return;
+  }
+
+  const sessionId = state.sseTransport.sessionId;
+  return await request('/question', { question, sessionId });
+};
+
+// 发送 HTTP 请求
+const request = async (url: string, data: string) => {
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${process.env.USER_TOKEN}`
+    },
+    body: JSON.stringify(data)
+  });
+
+  if (!response.ok) {
+    throw new Error(response.statusText);
+  }
+
+  return await response.json();
+};
+```
+
+请注意：在调用 `callSseProxy` 之前需要调用 `connectSseProxy`，只有代理连接成功后，后端服务的 AI 才能通过该代理调用浏览器环境下的 `Client` 客户端的工具方法。为了让后端服务能够找到当前浏览器的 `Client` 客户端连接，需要向后端服务传递 `sseTransport` 的 `sessionId`。
+
+### Streamable HTTP Client Proxy
+
+使用 `MessageChannel API` 创建的 `Client` 客户端实例运行在浏览器环境中，为了能够被后端服务的 AI 调用，需要借助 `createStreamProxy` 方法创建该 `Client` 的代理。
+
+```typescript
+import { createStreamProxy, ProxyStreamClientTransport } from '@opentiny/next';
+import type { Client } from '@modelcontextprotocol/sdk/client/index.js';
+
+// 定义页面的状态
+const state: {
+  streamTransport: ProxyStreamClientTransport | undefined;
+  client: Client | undefined;
+} = {
+  streamTransport: undefined,
+  client: undefined
+};
+
+// 使用 Stream 代理连接到服务端
+const connectStreamProxy = async () => {
+  if (!state.streamTransport) {
+    const { transport, sessionId } = await createStreamProxy({
+      client: state.client as Client,
+      url: location + 'agent/mcp',
+      token: process.env.USER_TOKEN as string
+    });
+
+    state.streamTransport = transport;
+  }
+};
+
+// 使用 Streamable HTTP 代理调用工具方法
+const callStreamProxy = async (question: string) => {
+  if (!state.streamTransport) {
+    console.error('You need to connect Streamable HTTP Proxy first!');
+    return;
+  }
+
+  const sessionId = state.streamTransport.sessionId;
+  return await request('/question', { question, sessionId });
+};
+
+// 关闭 Streamable HTTP 代理连接
+const closeStreamProxy = async () => {
+  if (state.streamTransport) {
+    await state.streamTransport.terminateSession();
+    state.streamTransport = undefined;
+  }
+};
+
+// 在页面窗口装载时注册关闭 Streamable HTTP 连接的事件
+window.addEventListener('beforeunload', closeStreamProxy);
+
+// 在页面窗口卸载时移除注册关闭 Streamable HTTP 连接的事件
+window.removeEventListener('beforeunload', closeStreamProxy);
+```
+
+请注意：在调用 `callStreamProxy` 之前需要调用 `connectStreamProxy`，只有代理连接成功后，后端服务的 AI 才能通过该代理调用浏览器环境下的 `Client` 客户端的工具方法。为了让后端服务能够找到当前浏览器的 `Client` 客户端连接，需要向后端服务传递 `streamTransport` 的 `sessionId`。
+
+与 `SSE` 的连接可以自动关闭不同，`Streamable HTTP` 的连接需要手动关闭，即要调用 `streamTransport.terminateSession()` 方法来中断连接。
+
+## 服务端 API (server.js)
+
+服务端 API 主要用于在 Node.js 环境中创建 MCP 服务端，处理来自客户端的连接请求。
+
+### SSE (Server-Sent Events) Server Proxy
+
+以下是 Express 环境 Node.js 服务端连接代理的示例代码：
+
+```typescript
+import express from 'express';
+import session from 'express-session';
+import cors from 'cors';
+import { auth, useProxyHandles } from '@opentiny/next/server.js';
+import type { Request, Response } from 'express';
+import type { Client } from '@modelcontextprotocol/sdk/client/index.js';
+
+const { handleSseProxy, handleSseInspector, handleSseMessage, clients } = useProxyHandles();
+
+const app = express();
+
+// 启用跨域资源共享
+app.use(cors());
+
+// 获取代理背后真实的 IP 地址
+app.set('trust proxy', 1);
+
+// 配置 session 中间件，支持会话管理
+app.use(
+  session({
+    secret: process.env.SECRET_KEY as string, // 会话密钥
+    cookie: { maxAge: 60000 }, // 会话有效期
+    resave: false,
+    saveUninitialized: true
+  })
+);
+
+// 获取所有客户端的 sessionId
+app.get('/list', async (req: Request, res: Response) => {
+  const sessions: Record<string, object> = {};
+  for (const sessionId in clients) {
+    const { user, device, type } = clients[sessionId];
+    sessions[sessionId] = { user, device, type };
+  }
+  res.json(sessions);
+});
+
+// 启用认证中间件
+app.use(auth({ secret: process.env.SECRET_KEY as string }));
+
+// MCP inspector url http://localhost:5173/agent/inspector?sessionId=
+app.get('/inspector', async (req: Request, res: Response) => {
+  try {
+    await handleSseInspector(req, res, '/agent/messages');
+  } catch (error) {
+    console.error('AI Agent inspector error:', (error as Error).message);
+  }
+});
+
+// SSE 端点，支持 inspector 和 proxy 两种模式，inspector url http://localhost:8001/sse?sessionId=
+app.get('/sse', async (req: Request, res: Response) => {
+  try {
+    if (req.query.sessionId) {
+      await handleSseInspector(req, res, '/messages');
+    } else {
+      await handleSseProxy(req, res, '/agent/messages');
+    }
+  } catch (error) {
+    console.error('AI Agent proxy error:', (error as Error).message);
+  }
+});
+
+// 消息转发端点，根据 sessionId 找到对应 transport 处理消息
+app.post('/messages', async (req: Request, res: Response) => {
+  try {
+    await handleSseMessage(req, res);
+  } catch (error) {
+    console.error('AI Agent message error:', (error as Error).message);
+  }
+});
+
+// 用户提问端点，支持带 sessionId 的上下文调用
+app.post('/question', express.json(), async (req: Request, res: Response) => {
+  try {
+    const sessionId = req.body.sessionId as string;
+    const client = clients[sessionId]?.client;
+    const question = req.body.question as string;
+    const answer = await ask(question, client); // 需自行实现 AI 调用 Client 的工具
+    res.json({ answer });
+  } catch (error) {
+    console.error('AI Agent question error:', (error as Error).message);
+  }
+});
+
+app.listen(8001, () => {
+  console.log('AI Agent listening on port 8001');
+});
+```
+
+### Streamable HTTP Server Proxy
+
+以下是 Express 环境 Node.js 服务端连接代理的示例代码：
+
+```typescript
+import express from 'express';
+import session from 'express-session';
+import cors from 'cors';
+import { auth, useProxyHandles } from '@opentiny/next/server.js';
+import type { Request, Response } from 'express';
+import type { Client } from '@modelcontextprotocol/sdk/client/index.js';
+
+const { handleStreamRequest, handleStreamInspector, clients } = useProxyHandles();
+
+const app = express();
+
+// 启用跨域资源共享
+app.use(cors());
+
+// 获取代理背后真实的 IP 地址
+app.set('trust proxy', 1);
+
+// 配置 session 中间件，支持会话管理
+app.use(
+  session({
+    secret: process.env.SECRET_KEY as string, // 会话密钥
+    cookie: { maxAge: 60000 }, // 会话有效期
+    resave: false,
+    saveUninitialized: true
+  })
+);
+
+// 获取所有客户端的 sessionId
+app.get('/list', async (req: Request, res: Response) => {
+  const sessions: Record<string, object> = {};
+  for (const sessionId in clients) {
+    const { user, device, type } = clients[sessionId];
+    sessions[sessionId] = { user, device, type };
+  }
+  res.json(sessions);
+});
+
+// 启用认证中间件
+app.use(auth({ secret: process.env.SECRET_KEY as string }));
+
+// 处理 Streamable HTTP 服务端 POST/GET/DELETE 连接
+// 可以使用 MCP inspector 连接调试，方式与 SSE 连接相同，如下：
+// http://localhost:8001/mcp?sessionId= 或 http://localhost:5173/agent/mcp?sessionId=
+app.all('/mcp', express.json(), async (req: Request, res: Response) => {
+  try {
+    if (req.query.sessionId) {
+      await handleStreamInspector(req, res);
+    } else {
+      await handleStreamRequest(req, res);
+    }
+  } catch (error) {
+    console.error('AI Agent mcp error:', (error as Error).message);
+  }
+});
+
+// 用户提问端点，支持带 sessionId 的上下文调用
+app.post('/question', express.json(), async (req: Request, res: Response) => {
+  try {
+    const sessionId = req.body.sessionId as string;
+    const client = clients[sessionId]?.client;
+    const question = req.body.question as string;
+    const answer = await ask(question, client); // 需自行实现 AI 调用 Client 的工具
+    res.json({ answer });
+  } catch (error) {
+    console.error('AI Agent question error:', (error as Error).message);
+  }
+});
+
+app.listen(8001, () => {
+  console.log('AI Agent listening on port 8001');
+});
+```
+
+## Vite 工程配置示例
+
+以上示例代码均基于 Vite 工程配置运行，增加了环境变量以及代理转发等，以下是 `vite.config.ts` 示例：
+
+```typescript
+import { defineConfig } from 'vite';
+import vue from '@vitejs/plugin-vue';
+import dotenv from 'dotenv';
+import path from 'path';
+
+// Vite 配置文件
+export default defineConfig(() => {
+  // 加载 .env 文件中的环境变量
+  dotenv.config({ path: '.env' });
+
+  return {
+    // 注入环境变量到前端代码
+    define: {
+      'process.env': {
+        USER_TOKEN: process.env.USER_TOKEN
+      }
+    },
+    plugins: [vue()],
+    server: {
+      proxy: {
+        // 代理 /agent 开头的请求到本地 8001 端口（AI Agent 服务）
+        '/agent': {
+          target: 'http://localhost:8001',
+          changeOrigin: true,
+          rewrite: (path) => path.replace(/^\/agent/, '')
+        }
+      }
+    }
+  };
+});
+```
+
+## 注意事项
+
+1. 确保在服务端使用时安装 `express` 作为依赖
+2. 使用 JWT 令牌认证时，请保护好密钥
+3. 在生产环境中，应该设置适当的 CORS 配置
+4. SSE 连接会保持打开状态，请确保适当处理资源释放
+5. 使用 Streamable HTTP 时，记得在会话结束时调用 `terminateSession()` 方法关闭连接
+
+## 许可证
+
+MIT

package/client.d.ts

@@ -0,0 +1,237 @@
+import { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
+import { AuthInfo } from '@modelcontextprotocol/sdk/server/auth/types.js';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { SSEClientTransport, SSEClientTransportOptions } from '@modelcontextprotocol/sdk/client/sse.js';
+import { StreamableHTTPClientTransport, StreamableHTTPClientTransportOptions } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+
+/**
+ * MessageChannelTransport 是一个用于在浏览器上下文之间传输消息的类。
+ * 它使用 MessageChannel API 来实现不同上下文（如 iframe、worker、标签页、窗口等）之间的通信。
+ * 该类提供了初始化、发送消息、关闭通道等功能。
+ */
+declare class MessageChannelTransport {
+    protected _port: MessagePort | undefined;
+    protected _sessionId: string | undefined;
+    protected _started: boolean;
+    protected _closed: boolean;
+    onclose?: () => void;
+    onerror?: (error: Error) => void;
+    onmessage?: (message: JSONRPCMessage, extra?: {
+        authInfo?: AuthInfo;
+    }) => void;
+    /**
+     * 构造函数，初始化 MessageChannelTransport。
+     *
+     * @param port - 用于通信的 MessagePort。
+     * @param sessionId - 会话 ID。
+     */
+    constructor(port?: MessagePort, sessionId?: string);
+    /**
+     * 初始化 MessageChannelTransport。
+     * 该方法会创建一个新的 MessageChannel，并将其端口传递给指定的全局对象。
+     * 如果传输已关闭，则抛出错误。
+     */
+    start(): Promise<void>;
+    /**
+     * 发送消息到 MessagePort。
+     * 如果传输已关闭，则抛出错误。
+     *
+     * @param message - 要发送的 JSON-RPC 消息。
+     */
+    send(message: JSONRPCMessage): Promise<void>;
+    /**
+     * 关闭 MessageChannelTransport。
+     * 该方法会关闭 MessagePort，并触发关闭回调。
+     * 如果传输已关闭，则不执行任何操作。
+     */
+    close(): Promise<void>;
+    /**
+     * 获取当前会话的 sessionId。
+     */
+    get sessionId(): string;
+}
+/**
+ * 在浏览器端实现基于 MessageChannel API 的客户端传输类，
+ * 用于不同浏览器上下文（如 iframe、worker、标签页、窗口等）之间通信。
+ */
+declare class MessageChannelClientTransport extends MessageChannelTransport {
+    private _endpoint;
+    private _globalObject;
+    /**
+     * 创建一个监听通信的服务端实例。
+     *
+     * @param endpoint - 用于通信的端点。
+     * @param [globalObject] - 用于通信的全局对象（可选，默认当前全局对象）。
+     */
+    constructor(endpoint: string, globalObject?: object);
+}
+/**
+ * 在浏览器端实现基于 MessageChannel API 的服务端传输类，
+ * 用于不同浏览器上下文（如 iframe、worker、标签页、窗口等）之间通信。
+ */
+declare class MessageChannelServerTransport extends MessageChannelTransport {
+    private _endpoint;
+    private _globalObject;
+    private _listen;
+    /**
+     * 创建一个监听通信的服务端实例。
+     *
+     * @param endpoint - 用于通信的端点。
+     * @param [globalObject] - 用于通信的全局对象（可选，默认当前全局对象）。
+     */
+    constructor(endpoint: string, globalObject?: object);
+    /**
+     * 监听等待客户端连接。
+     * 该方法会返回一个 Promise，当客户端连接时解析。
+     */
+    listen(): Promise<void>;
+}
+/**
+ * 创建一对 MessageChannelTransport 实例，返回两个端口的传输实例。
+ * 这两个实例可以用于在不同的浏览器上下文之间进行通信。
+ *
+ * @returns 返回一对 MessageChannelTransport 实例。
+ */
+declare const createTransportPair: () => [MessageChannelTransport, MessageChannelTransport];
+
+/**
+ * ProxySSEClientTransport（SSE 代理客户端传输类）
+ * 该类用于通过 Server-Sent Events（SSE）协议从服务端接收消息，主要应用于浏览器等客户端环境，实现与服务端的实时消息通信。
+ * 消息到达时会自动调用 forward.js 进行 method 分发交由代理处理。
+ */
+declare class ProxySSEClientTransport extends SSEClientTransport {
+    _client: Client;
+    /**
+     * 构造函数
+     * @param url - SSE 服务端地址
+     * @param opts - 传输配置参数（如认证、请求头等）
+     * @param client - 客户端代理实例
+     */
+    constructor(url: URL, opts: SSEClientTransportOptions, client: Client);
+    /**
+     * 启动 SSE 连接或进行认证
+     * 重写父类方法，增加消息自动分发处理逻辑
+     *
+     * 收到 SSE 消息后，自动解析并转发到 forward.js 进行 method 分发。
+     * 若 forward 返回 undefined，则调用自定义 onmessage 回调。
+     */
+    _startOrAuth(): Promise<void>;
+    /**
+     * 获取当前会话 sessionId
+     */
+    get sessionId(): string;
+}
+
+/**
+ * SSE 连接的启动或认证选项
+ */
+interface StartSSEOptions {
+    resumptionToken?: string;
+    onresumptiontoken?: (token: string) => void;
+    replayMessageId?: string | number;
+}
+/**
+ * ProxyStreamClientTransport（Streamable HTTP 代理客户端传输类）
+ * 该类用于通过 Streamable HTTP 协议从服务端接收消息，主要应用于浏览器等客户端环境，实现与服务端的实时消息通信。
+ * 消息到达时会自动调用 forward.js 进行 method 分发和业务处理。
+ */
+declare class ProxyStreamClientTransport extends StreamableHTTPClientTransport {
+    _client: Client;
+    /**
+     * 构造函数
+     * @param url - Streamable HTTP 服务端地址
+     * @param opts - 传输配置参数（如认证、请求头等）
+     * @param client - 客户端代理实例
+     */
+    constructor(url: URL, opts: StreamableHTTPClientTransportOptions, client: Client);
+    /**
+     * 处理 SSE 数据流
+     * 重写父类方法，增加消息自动分发处理逻辑
+     *
+     * 收到 SSE 消息后，自动解析并转发到 forward.js 进行 method 分发。
+     * 若 forward 返回 undefined，则调用自定义 onmessage 回调。
+     *
+     * @param stream - SSE 可读数据流
+     * @param options - 启动 SSE 的配置参数
+     */
+    _handleSseStream(stream: ReadableStream, options: StartSSEOptions): void;
+}
+
+/**
+ * 客户端代理选项接口
+ */
+interface ClientProxyOption {
+    /**
+     * MCP 客户端实例
+     */
+    client: Client;
+    /**
+     * 代理服务器的 URL
+     */
+    url: string;
+    /**
+     * 代理服务器的身份验证令牌
+     */
+    token: string;
+}
+/**
+ * 创建一个 SSE 客户端代理
+ *
+ * @param options - 客户端代理选项
+ * @returns - 返回一个包含 transport 和 sessionId 的对象
+ */
+declare const createSseProxy: (option: ClientProxyOption) => Promise<{
+    transport: ProxySSEClientTransport;
+    sessionId: string;
+}>;
+/**
+ * 创建一个 Streamable HTTP 客户端代理
+ *
+ * @param options - 客户端代理选项
+ * @returns - 返回一个包含 transport 和 sessionId 的对象
+ */
+declare const createStreamProxy: (option: ClientProxyOption) => Promise<{
+    transport: ProxyStreamClientTransport;
+    sessionId: string;
+}>;
+
+/**
+ * 生成 SSEClientTransport 构造函数所需的第二个可选参数（传输配置）。
+ * 用于为 SSE 连接和 HTTP 请求统一设置认证头（Authorization）。
+ *
+ * @param token - 用于认证的 Bearer Token。
+ * @returns 返回传输配置对象，包含 requestInit 和 eventSourceInit 两部分：
+ *   - requestInit：fetch 请求的初始化配置，自动带上认证头。
+ *   - eventSourceInit：自定义 fetch 方法，确保 SSE 连接也带上认证头。
+ */
+declare const sseOptions: (token: string) => {
+    requestInit: {
+        headers: {
+            Authorization: string;
+        };
+    };
+    eventSourceInit: {
+        fetch: (input: string | URL, init?: RequestInit) => Promise<Response>;
+    };
+};
+
+/**
+ * 生成 StreamableHTTPServerTransport 构造函数所需的第二个可选参数（传输配置）。
+ * 用于为 Streamable HTTP 连接和 HTTP 请求统一设置认证头（Authorization）。
+ *
+ * @param token - 用于认证的 Bearer Token。
+ * @param sessionId - 可选的 sessionId，用于标识会话。
+ * @returns 返回传输配置对象，包含以下内容：
+ *   - requestInit：fetch 请求的初始化配置，自动带上认证头，并设置 Streamable HTTP 代理的会话 ID。
+ */
+declare const streamOptions: (token: string, sessionId?: `${string}-${string}-${string}-${string}-${string}`) => {
+    requestInit: {
+        headers: {
+            Authorization: string;
+            "stream-session-id": string;
+        };
+    };
+};
+
+export { MessageChannelClientTransport, MessageChannelServerTransport, MessageChannelTransport, ProxySSEClientTransport, ProxyStreamClientTransport, createSseProxy, createStreamProxy, createTransportPair, sseOptions, streamOptions };
+export type { ClientProxyOption };