wtfai 1.0.0

package/README.md

@@ -0,0 +1,376 @@
+# wtfai
+
+Agent 工作流 SDK，为第三方 Web 开发者提供简洁的 API 来集成工作流执行、文件上传和会话管理功能。
+
+## 安装
+
+```bash
+npm install wtfai
+# 或
+pnpm add wtfai
+```
+
+## 快速开始
+
+```typescript
+import Wtfai from 'wtfai'
+
+// 1. 创建客户端
+const client = new Wtfai({
+  baseUrl: 'https://api.example.com',
+})
+
+// 2. 创建会话
+const session = client.createSession('workflow-id')
+
+// 3. 监听状态变化
+session.on('stateChange', (state) => {
+  console.log('消息列表:', state.messages)
+  console.log('是否执行中:', state.isExecuting)
+})
+
+// 4. 发送消息
+await session.send({ content: '你好' })
+```
+
+## API 文档
+
+### Wtfai
+
+SDK 主入口类。
+
+#### 构造函数
+
+```typescript
+const client = new Wtfai({
+  baseUrl: string,    // 必填，API 服务器地址
+  timeout?: number,   // 可选，请求超时时间（毫秒）
+  headers?: Record<string, string>,  // 可选，自定义请求头
+  tenantSecret?: string, // 可选，租户密钥 (⚠️ 仅用于调试，禁止在生产环境使用)
+})
+```
+
+#### 方法
+
+##### `getWorkflows(page?: number, pageSize?: number)`
+
+获取工作流列表。
+
+```typescript
+// 分页获取工作流，默认 page=1, pageSize=10
+const { items, total } = await client.getWorkflows(1, 20)
+console.log(`共 ${total} 个工作流`)
+```
+
+##### `getWorkflow(id: string)`
+
+获取工作流详情。
+
+```typescript
+const workflow = await client.getWorkflow('workflow-id')
+console.log(workflow.name, workflow.description)
+```
+
+##### `createSession(workflowId: string, options?: SessionOptions)`
+
+创建工作流会话。
+
+```typescript
+// 新会话
+const session = client.createSession('workflow-id')
+
+// 恢复已有会话
+const session = client.createSession('workflow-id', {
+  threadId: 'existing-thread-id',
+})
+```
+
+---
+
+### WorkflowSession
+
+工作流会话类，管理消息状态和执行流程。
+
+#### 方法
+
+##### `on(event, listener)`
+
+监听事件。
+
+```typescript
+session.on('start', ({ threadId }) => {
+  // 工作流开始执行，获取到 threadId
+})
+
+session.on('nodeStart', ({ nodeId }) => {
+  // 节点开始执行
+})
+
+session.on('nodeEnd', ({ nodeId, variables, messages }) => {
+  // 节点执行结束
+})
+
+session.on('token', ({ nodeId, content, isReasoning }) => {
+  // 收到流式 token（用于打字机效果）
+})
+
+session.on('loading', ({ nodeId, message }) => {
+  // 收到 loading 事件，用于更新加载状态
+  console.log('Loading:', message)
+})
+
+session.on('complete', () => {
+  // 工作流执行完成
+})
+
+session.on('error', ({ message }) => {
+  // 发生错误
+})
+
+session.on('stateChange', (state) => {
+  // 状态变化（推荐使用此事件更新 UI）
+  // state.messages: SimpleMessage[]
+  // state.isExecuting: boolean
+  // state.threadId?: string
+  // state.currentNodeId?: string
+})
+```
+
+##### `off(event, listener)`
+
+移除事件监听。
+
+```typescript
+const onToken = (data) => console.log(data)
+session.on('token', onToken)
+
+// 不需要时移除监听
+session.off('token', onToken)
+```
+
+##### `send(input: SendInput)`
+
+发送消息执行工作流。
+
+```typescript
+// 发送纯文本
+await session.send({
+  content: '你好',
+})
+
+// 发送带图片的消息（自动压缩上传）
+await session.send({
+  content: '请分析这张图片',
+  images: [imageFile],  // File[]
+})
+
+// 发送带文档的消息（自动上传）
+await session.send({
+  content: '请总结这份文档',
+  documents: [pdfFile],  // File[]
+})
+
+// 使用已上传的 URL
+await session.send({
+  content: '你好',
+  imageUrls: ['https://example.com/image.jpg'],
+  documentInfos: [{
+    url: 'https://example.com/doc.pdf',
+    filename: 'document.pdf',
+    mimeType: 'application/pdf',
+  }],
+})
+```
+
+##### `restore()`
+
+恢复历史会话（需要在创建 session 时传入 threadId）。
+
+```typescript
+const session = client.createSession('workflow-id', {
+  threadId: 'existing-thread-id',
+})
+await session.restore()
+// 会触发 stateChange 事件，包含历史消息
+```
+
+##### `getState()`
+
+获取当前状态快照。
+
+```typescript
+const state = session.getState()
+console.log(state.messages)
+console.log(state.isExecuting)
+```
+
+##### `abort()`
+
+中止当前执行。
+
+```typescript
+session.abort()
+```
+
+---
+
+### UploadService
+
+文件上传服务（通过 `client.upload` 访问）。
+
+##### `uploadFile(params)`
+
+上传文件。
+
+```typescript
+const url = await client.upload.uploadFile({
+  file: file,
+  resourceType: 'conversation',  // 'conversation' | 'workflow' | 'knowledge-base'
+  onProgress: (percent) => {
+    console.log(`上传进度: ${percent * 100}%`)
+  },
+})
+```
+
+##### `uploadImage(file, resourceType, onProgress?)`
+
+上传图片（自动压缩）。
+
+```typescript
+const url = await client.upload.uploadImage(
+  imageFile,
+  'conversation',
+  (percent) => console.log(`${percent * 100}%`),
+)
+```
+
+---
+
+## 类型定义
+
+### SimpleMessage
+
+消息类型（与后端保持一致）。
+
+```typescript
+interface SimpleMessage {
+  type: 'human' | 'ai' | 'system'
+  content: string | Array<{ type: string; [key: string]: any }>
+  id?: string
+  images?: string[]
+  videos?: string[]
+  documents?: Array<{ filename: string; url: string }>
+}
+```
+
+### SessionState
+
+会话状态类型。
+
+```typescript
+interface SessionState {
+  threadId?: string
+  messages: SimpleMessage[]
+  isExecuting: boolean
+  currentNodeId?: string
+}
+```
+
+### SendInput
+
+发送消息输入类型。
+
+```typescript
+interface SendInput {
+  content?: string
+  images?: File[]
+  imageUrls?: string[]
+  documents?: File[]
+  documentInfos?: Array<{
+    url: string
+    filename: string
+    mimeType: string
+  }>
+}
+```
+
+---
+
+## 完整示例
+
+### React 聊天组件
+
+```tsx
+import { useState, useEffect, useRef } from 'react'
+import Wtfai, { type SimpleMessage, type WorkflowSession } from 'wtfai'
+
+const client = new W't'fa'i({
+  baseUrl: 'https://api.example.com',
+})
+
+function ChatComponent({ workflowId }: { workflowId: string }) {
+  const [messages, setMessages] = useState<SimpleMessage[]>([])
+  const [isExecuting, setIsExecuting] = useState(false)
+  const [input, setInput] = useState('')
+  const sessionRef = useRef<WorkflowSession | null>(null)
+
+  useEffect(() => {
+    return () => {
+      sessionRef.current?.abort()
+    }
+  }, [])
+
+  const handleSend = async () => {
+    if (!input.trim() || isExecuting) return
+
+    const session = client.createSession(workflowId)
+    sessionRef.current = session
+
+    session.on('stateChange', (state) => {
+      setMessages([...state.messages])
+      setIsExecuting(state.isExecuting)
+    })
+
+    session.on('error', ({ message }) => {
+      alert(`错误: ${message}`)
+    })
+
+    try {
+      await session.send({ content: input })
+      setInput('')
+    } catch (error) {
+      console.error(error)
+    }
+  }
+
+  return (
+    <div>
+      <div className="messages">
+        {messages.map((msg, i) => (
+          <div key={i} className={msg.type}>
+            {typeof msg.content === 'string' ? msg.content : '...'}
+          </div>
+        ))}
+        {isExecuting && <div>思考中...</div>}
+      </div>
+      <input
+        value={input}
+        onChange={(e) => setInput(e.target.value)}
+        disabled={isExecuting}
+      />
+      <button onClick={handleSend} disabled={isExecuting}>
+        发送
+      </button>
+    </div>
+  )
+}
+```
+
+---
+
+## 注意事项
+
+1. **图片自动压缩**：通过 `session.send({ images: [...] })` 上传的图片会自动压缩到 1920px 以内，质量 0.8
+2. **会话管理**：每次调用 `send()` 都会更新 `threadId`，如需保存会话请在 `start` 事件中获取
+3. **错误处理**：建议始终监听 `error` 事件处理异常情况
+4. **资源清理**：组件卸载时调用 `session.abort()` 避免内存泄漏

package/dist/client.d.ts

@@ -0,0 +1,55 @@
+import type { Workflow, WorkflowListResponse } from '@our-llm/shared/workflow.types';
+import type { OurLLMClientConfig, SessionOptions } from './types';
+import { WorkflowSession } from './session';
+import { UploadService } from './upload';
+/**
+ * Wtfai 客户端
+ *
+ * @example
+ * ```typescript
+ * import Wtfai from 'wtfai'
+ *
+ * const client = new Wtfai({
+ *   baseUrl: 'https://api.example.com',
+ * })
+ *
+ * // 获取工作流
+ * const workflow = await client.getWorkflow('workflow-id')
+ *
+ * // 获取工作流列表
+ * const workflows = await client.getWorkflows(1, 10)
+ *
+ * // 创建会话
+ * const session = client.createSession('workflow-id')
+ *
+ * // 监听状态变化
+ * session.on('stateChange', (state) => {
+ *   console.log('Messages:', state.messages)
+ * })
+ *
+ * // 发送消息
+ * await session.send({ content: '你好' })
+ * ```
+ */
+export declare class Wtfai {
+    private readonly baseUrl;
+    private readonly uploadService;
+    /**
+     * 文件上传服务
+     */
+    readonly upload: UploadService;
+    private readonly headers;
+    constructor(config: OurLLMClientConfig);
+    /**
+     * 获取工作流列表
+     */
+    getWorkflows(page?: number, pageSize?: number): Promise<WorkflowListResponse>;
+    /**
+     * 获取工作流详情
+     */
+    getWorkflow(id: string): Promise<Workflow>;
+    /**
+     * 创建工作流会话
+     */
+    createSession(workflowId: string, options?: SessionOptions): WorkflowSession;
+}

package/dist/client.js

@@ -0,0 +1,43 @@
+import { WorkflowSession } from "./session.js";
+import { UploadService } from "./upload.js";
+class Wtfai {
+    baseUrl;
+    uploadService;
+    upload;
+    headers;
+    constructor(config){
+        this.baseUrl = config.baseUrl.replace(/\/$/, '');
+        const headers = {
+            ...config.headers
+        };
+        if (config.tenantSecret) {
+            console.warn('%c[OurLLM SDK] ⚠️ Warning: tenantSecret is provided. This should ONLY be used for debugging purposes. DO NOT use in production.', 'color: red; font-weight: bold; font-size: 14px;');
+            headers['x-tenant-secret'] = config.tenantSecret;
+        }
+        this.headers = headers;
+        this.uploadService = new UploadService(this.baseUrl, this.headers);
+        this.upload = this.uploadService;
+    }
+    async getWorkflows(page = 1, pageSize = 10) {
+        const params = new URLSearchParams({
+            current: String(page),
+            pageSize: String(pageSize)
+        });
+        const response = await fetch(`${this.baseUrl}/workflows?${params}`, {
+            headers: this.headers
+        });
+        if (!response.ok) throw new Error('获取工作流列表失败');
+        return response.json();
+    }
+    async getWorkflow(id) {
+        const response = await fetch(`${this.baseUrl}/workflows/${id}`, {
+            headers: this.headers
+        });
+        if (!response.ok) throw new Error('获取工作流详情失败');
+        return response.json();
+    }
+    createSession(workflowId, options) {
+        return new WorkflowSession(workflowId, this.baseUrl, this.uploadService, this.headers, options);
+    }
+}
+export { Wtfai };

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import { Wtfai } from './client';
+export default Wtfai;
+export { WorkflowSession } from './session';
+export { UploadService } from './upload';
+export type { OurLLMClientConfig, SessionOptions, SessionState, SessionEventListeners, SendInput, UploadParams, CompressOptions, WorkflowInfo, } from './types';
+export type { SimpleMessage } from '@our-llm/shared/workflow-events';
+export type { Workflow, WorkflowConfig } from '@our-llm/shared/workflow.types';

package/dist/index.js

@@ -0,0 +1,5 @@
+import { Wtfai } from "./client.js";
+import { WorkflowSession } from "./session.js";
+import { UploadService } from "./upload.js";
+const src = Wtfai;
+export { UploadService, WorkflowSession, src as default };

package/dist/session.d.ts

@@ -0,0 +1,48 @@
+import type { SessionOptions, SessionState, SessionEventListeners, SendInput } from './types';
+import { UploadService } from './upload';
+/**
+ * 工作流会话
+ * 管理单个工作流的执行状态和消息
+ */
+export declare class WorkflowSession {
+    private readonly workflowId;
+    private readonly baseUrl;
+    private readonly uploadService;
+    private readonly headers;
+    private state;
+    private listeners;
+    private abortController?;
+    constructor(workflowId: string, baseUrl: string, uploadService: UploadService, headers?: Record<string, string>, options?: SessionOptions);
+    /**
+     * 监听事件
+     */
+    on<K extends keyof SessionEventListeners>(event: K, listener: SessionEventListeners[K]): this;
+    /**
+     * 移除事件监听
+     */
+    off<K extends keyof SessionEventListeners>(event: K, listener: SessionEventListeners[K]): this;
+    /**
+     * 触发事件
+     */
+    private emit;
+    /**
+     * 更新状态并触发 stateChange 事件
+     */
+    private updateState;
+    /**
+     * 获取当前状态快照
+     */
+    getState(): SessionState;
+    /**
+     * 恢复历史会话
+     */
+    restore(): Promise<void>;
+    /**
+     * 发送消息执行工作流
+     */
+    send(input: SendInput): Promise<void>;
+    /**
+     * 中止执行
+     */
+    abort(): void;
+}

package/dist/session.js

@@ -0,0 +1,245 @@
+import { executeWorkflowSSE } from "./sse.js";
+import { v7 } from "uuid";
+class WorkflowSession {
+    workflowId;
+    baseUrl;
+    uploadService;
+    headers;
+    state = {
+        messages: [],
+        isExecuting: false
+    };
+    listeners = new Map();
+    abortController;
+    constructor(workflowId, baseUrl, uploadService, headers = {}, options = {}){
+        this.workflowId = workflowId;
+        this.baseUrl = baseUrl;
+        this.uploadService = uploadService;
+        this.headers = headers;
+        if (options.threadId) this.state.threadId = options.threadId;
+        else this.state.threadId = v7();
+    }
+    on(event, listener) {
+        if (!this.listeners.has(event)) this.listeners.set(event, new Set());
+        this.listeners.get(event).add(listener);
+        return this;
+    }
+    off(event, listener) {
+        this.listeners.get(event)?.delete(listener);
+        return this;
+    }
+    emit(event, ...args) {
+        const listeners = this.listeners.get(event);
+        if (listeners) Array.from(listeners).forEach((listener)=>{
+            listener(...args);
+        });
+    }
+    updateState(updates) {
+        this.state = {
+            ...this.state,
+            ...updates
+        };
+        this.emit('stateChange', {
+            ...this.state
+        });
+    }
+    getState() {
+        return {
+            ...this.state
+        };
+    }
+    async restore() {
+        if (!this.state.threadId) throw new Error('无法恢复会话：未提供 threadId');
+        const response = await fetch(`${this.baseUrl}/workflows/${this.workflowId}/state?threadId=${this.state.threadId}`, {
+            headers: this.headers
+        });
+        if (!response.ok) throw new Error('获取工作流状态失败');
+        const data = await response.json();
+        this.updateState({
+            messages: data.messages
+        });
+    }
+    async send(input) {
+        if (this.state.isExecuting) throw new Error('工作流正在执行中');
+        this.updateState({
+            isExecuting: true,
+            currentNodeId: void 0
+        });
+        try {
+            const contentParts = [];
+            if (input.content) contentParts.push({
+                type: 'text',
+                text: input.content
+            });
+            if (input.images && input.images.length > 0) {
+                const imageUrls = await Promise.all(input.images.map((file)=>this.uploadService.uploadImage(file, 'conversation')));
+                for (const url of imageUrls)contentParts.push({
+                    type: 'image',
+                    url
+                });
+            }
+            if (input.imageUrls) for (const url of input.imageUrls)contentParts.push({
+                type: 'image',
+                url
+            });
+            if (input.documents && input.documents.length > 0) {
+                const docInfos = await Promise.all(input.documents.map(async (file)=>{
+                    const url = await this.uploadService.uploadFile({
+                        file,
+                        resourceType: 'conversation'
+                    });
+                    return {
+                        url,
+                        filename: file.name,
+                        mimeType: file.type
+                    };
+                }));
+                for (const doc of docInfos)contentParts.push({
+                    type: 'document',
+                    url: doc.url,
+                    filename: doc.filename,
+                    mimeType: doc.mimeType
+                });
+            }
+            if (input.documentInfos) for (const doc of input.documentInfos)contentParts.push({
+                type: 'document',
+                url: doc.url,
+                filename: doc.filename,
+                mimeType: doc.mimeType
+            });
+            const executionInput = {
+                messages: [
+                    {
+                        content: contentParts
+                    }
+                ]
+            };
+            const uploadedImages = contentParts.filter((p)=>'image' === p.type && 'url' in p).map((p)=>p.url);
+            const uploadedDocs = contentParts.filter((p)=>'document' === p.type).map((p)=>({
+                    filename: p.filename,
+                    url: p.url || '#'
+                }));
+            const userMessage = {
+                type: 'human',
+                content: input.content || '',
+                images: uploadedImages.length > 0 ? uploadedImages : void 0,
+                documents: uploadedDocs.length > 0 ? uploadedDocs : void 0
+            };
+            this.updateState({
+                messages: [
+                    ...this.state.messages,
+                    userMessage
+                ]
+            });
+            let currentAiMessage = null;
+            let currentAiMessageIndex = -1;
+            this.abortController = await executeWorkflowSSE(`${this.baseUrl}/workflows/${this.workflowId}/execute`, {
+                input: executionInput,
+                threadId: this.state.threadId
+            }, {
+                onWorkflowStart: (data)=>{
+                    this.updateState({
+                        threadId: data.t
+                    });
+                    this.emit('start', {
+                        threadId: data.t
+                    });
+                },
+                onNodeStart: (data)=>{
+                    this.updateState({
+                        currentNodeId: data.n
+                    });
+                    this.emit('nodeStart', {
+                        nodeId: data.n
+                    });
+                },
+                onNodeEnd: (data)=>{
+                    if (data.m && data.m.length > 0) {
+                        const newMessages = [
+                            ...this.state.messages
+                        ];
+                        for (const msg of data.m)if ('human' !== msg.type) newMessages.push(msg);
+                        this.updateState({
+                            messages: newMessages
+                        });
+                    }
+                    this.emit('nodeEnd', {
+                        nodeId: data.n,
+                        variables: data.v,
+                        messages: data.m
+                    });
+                },
+                onToken: (data)=>{
+                    if (!currentAiMessage) {
+                        currentAiMessage = {
+                            type: 'ai',
+                            content: ''
+                        };
+                        const newMessages = [
+                            ...this.state.messages,
+                            currentAiMessage
+                        ];
+                        currentAiMessageIndex = newMessages.length - 1;
+                        this.updateState({
+                            messages: newMessages
+                        });
+                    }
+                    currentAiMessage.content = currentAiMessage.content + data.c;
+                    const updatedMessages = [
+                        ...this.state.messages
+                    ];
+                    updatedMessages[currentAiMessageIndex] = {
+                        ...currentAiMessage
+                    };
+                    this.updateState({
+                        messages: updatedMessages
+                    });
+                    this.emit('token', {
+                        nodeId: data.n,
+                        content: data.c,
+                        isReasoning: 1 === data.r
+                    });
+                },
+                onLoading: (data)=>{
+                    this.emit('loading', {
+                        nodeId: data.n,
+                        message: data.m
+                    });
+                },
+                onComplete: ()=>{
+                    this.updateState({
+                        isExecuting: false,
+                        currentNodeId: void 0
+                    });
+                    this.emit('complete');
+                },
+                onError: (error)=>{
+                    this.updateState({
+                        isExecuting: false,
+                        currentNodeId: void 0
+                    });
+                    this.emit('error', error);
+                }
+            }, this.headers);
+        } catch (error) {
+            this.updateState({
+                isExecuting: false,
+                currentNodeId: void 0
+            });
+            this.emit('error', {
+                message: String(error)
+            });
+            throw error;
+        }
+    }
+    abort() {
+        if (this.abortController) {
+            this.abortController.abort();
+            this.updateState({
+                isExecuting: false,
+                currentNodeId: void 0
+            });
+        }
+    }
+}
+export { WorkflowSession };

package/dist/sse.d.ts

@@ -0,0 +1,19 @@
+import type { WorkflowStartData, NodeStartData, NodeEndData, TokenData, LoadingData } from '@our-llm/shared/workflow-events';
+/**
+ * SSE 事件回调
+ */
+export interface SSECallbacks {
+    onWorkflowStart?: (data: WorkflowStartData) => void;
+    onNodeStart?: (data: NodeStartData) => void;
+    onNodeEnd?: (data: NodeEndData) => void;
+    onToken?: (data: TokenData) => void;
+    onLoading?: (data: LoadingData) => void;
+    onComplete?: () => void;
+    onError?: (error: {
+        message: string;
+    }) => void;
+}
+/**
+ * 执行工作流的 SSE 连接
+ */
+export declare function executeWorkflowSSE(url: string, body: unknown, callbacks: SSECallbacks, headers?: Record<string, string>): Promise<AbortController>;

package/dist/sse.js

@@ -0,0 +1,60 @@
+import { fetchEventSource } from "@microsoft/fetch-event-source";
+async function executeWorkflowSSE(url, body, callbacks, headers = {}) {
+    const ctrl = new AbortController();
+    await fetchEventSource(url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            ...headers
+        },
+        body: JSON.stringify(body),
+        signal: ctrl.signal,
+        onmessage (msg) {
+            const eventType = msg.event;
+            if ('ok' === eventType) {
+                callbacks.onComplete?.();
+                ctrl.abort();
+            } else if ('err' === eventType) {
+                const data = JSON.parse(msg.data);
+                callbacks.onError?.({
+                    message: data.m
+                });
+                ctrl.abort();
+            } else try {
+                const data = JSON.parse(msg.data);
+                switch(eventType){
+                    case 'ws':
+                        callbacks.onWorkflowStart?.(data);
+                        break;
+                    case 'ns':
+                        callbacks.onNodeStart?.(data);
+                        break;
+                    case 'ne':
+                        callbacks.onNodeEnd?.(data);
+                        break;
+                    case 'tk':
+                        callbacks.onToken?.(data);
+                        break;
+                    case 'l':
+                        callbacks.onLoading?.(data);
+                        break;
+                }
+            } catch (e) {
+                console.error('[SDK] Failed to parse SSE data', e);
+            }
+        },
+        onerror (err) {
+            callbacks.onError?.({
+                message: String(err)
+            });
+            ctrl.abort();
+            throw err;
+        },
+        onclose () {
+            callbacks.onComplete?.();
+            ctrl.abort();
+        }
+    });
+    return ctrl;
+}
+export { executeWorkflowSSE };

package/dist/types.d.ts

@@ -0,0 +1,134 @@
+/**
+ * SDK 配置类型
+ */
+export interface OurLLMClientConfig {
+    /** API 服务器地址 */
+    baseUrl: string;
+    /** 请求超时时间（毫秒） */
+    timeout?: number;
+    /** 自定义请求头 */
+    headers?: Record<string, string>;
+    /** 租户密钥 (仅用于调试，禁止在生产环境使用) */
+    tenantSecret?: string;
+}
+/**
+ * 会话选项
+ */
+export interface SessionOptions {
+    /** 已有的线程 ID，用于恢复历史会话 */
+    threadId?: string;
+}
+/**
+ * 上传参数
+ */
+export interface UploadParams {
+    /** 要上传的文件 */
+    file: File;
+    /** 资源类型 */
+    resourceType: 'conversation' | 'workflow' | 'knowledge-base';
+    /** 上传进度回调 */
+    onProgress?: (percent: number) => void;
+}
+/**
+ * 图片压缩选项
+ */
+export interface CompressOptions {
+    /** 压缩质量 0-1，默认 0.8 */
+    quality?: number;
+    /** 最大宽度，默认 1920 */
+    maxWidth?: number;
+    /** 最大高度，默认 1920 */
+    maxHeight?: number;
+    /** 超过此大小（字节）的图片会被转换为 JPEG，默认 1MB */
+    convertSize?: number;
+}
+/**
+ * 发送消息的输入
+ */
+export interface SendInput {
+    /** 文本内容 */
+    content?: string;
+    /** 图片文件列表（会自动压缩并上传） */
+    images?: File[];
+    /** 已上传的图片 URL 列表 */
+    imageUrls?: string[];
+    /** 文档文件列表（会自动上传） */
+    documents?: File[];
+    /** 已上传的文档信息列表 */
+    documentInfos?: Array<{
+        url: string;
+        filename: string;
+        mimeType: string;
+    }>;
+}
+/**
+ * 上传临时凭证
+ */
+export interface UploadCredentials {
+    credentials: {
+        tmpSecretId: string;
+        tmpSecretKey: string;
+        sessionToken: string;
+    };
+    startTime: number;
+    expiredTime: number;
+    bucket: string;
+    region: string;
+    key: string;
+    cdnDomain?: string;
+}
+/**
+ * 会话事件类型
+ */
+export type SessionEventType = 'start' | 'nodeStart' | 'nodeEnd' | 'token' | 'loading' | 'complete' | 'error' | 'stateChange';
+/**
+ * 会话事件监听器类型映射
+ */
+export interface SessionEventListeners {
+    start: (data: {
+        threadId: string;
+    }) => void;
+    nodeStart: (data: {
+        nodeId: string;
+    }) => void;
+    nodeEnd: (data: {
+        nodeId: string;
+        variables?: Record<string, unknown>;
+        messages?: import('@our-llm/shared/workflow-events').SimpleMessage[];
+    }) => void;
+    token: (data: {
+        nodeId: string;
+        content: string;
+        isReasoning?: boolean;
+    }) => void;
+    loading: (data: {
+        nodeId: string;
+        message: string;
+    }) => void;
+    complete: () => void;
+    error: (error: {
+        message: string;
+    }) => void;
+    stateChange: (state: SessionState) => void;
+}
+/**
+ * 会话状态
+ */
+export interface SessionState {
+    /** 线程 ID */
+    threadId?: string;
+    /** 消息列表 */
+    messages: import('@our-llm/shared/workflow-events').SimpleMessage[];
+    /** 是否正在执行 */
+    isExecuting: boolean;
+    /** 当前执行节点 ID */
+    currentNodeId?: string;
+}
+/**
+ * 工作流基本信息
+ */
+export interface WorkflowInfo {
+    id: string;
+    name: string;
+    description: string;
+}

package/dist/upload.d.ts

@@ -0,0 +1,25 @@
+import type { UploadParams } from './types';
+/**
+ * 文件上传服务
+ */
+export declare class UploadService {
+    private readonly baseUrl;
+    private readonly headers;
+    constructor(baseUrl: string, headers?: Record<string, string>);
+    /**
+     * 压缩图片
+     */
+    private compressImage;
+    /**
+     * 获取 COS 实例
+     */
+    private getCosInstance;
+    /**
+     * 上传文件
+     */
+    uploadFile(params: UploadParams): Promise<string>;
+    /**
+     * 上传图片（自动压缩）
+     */
+    uploadImage(file: File, resourceType: 'conversation' | 'workflow' | 'knowledge-base', onProgress?: (percent: number) => void): Promise<string>;
+}

package/dist/upload.js

@@ -0,0 +1,103 @@
+import cos_js_sdk_v5 from "cos-js-sdk-v5";
+import compressorjs from "compressorjs";
+class UploadService {
+    baseUrl;
+    headers;
+    constructor(baseUrl, headers = {}){
+        this.baseUrl = baseUrl;
+        this.headers = headers;
+    }
+    compressImage(file, options = {}) {
+        const { quality = 0.8, maxWidth = 1920, maxHeight = 1920, convertSize = 1000000 } = options;
+        return new Promise((resolve)=>{
+            new compressorjs(file, {
+                quality,
+                maxWidth,
+                maxHeight,
+                convertSize,
+                success: (result)=>{
+                    let filename = file.name;
+                    if (result.type !== file.type) {
+                        const ext = 'image/jpeg' === result.type ? '.jpg' : '.webp';
+                        filename = file.name.replace(/\.[^.]+$/, ext);
+                    }
+                    const compressedFile = new File([
+                        result
+                    ], filename, {
+                        type: result.type,
+                        lastModified: Date.now()
+                    });
+                    console.log(`[SDK] 图片压缩: ${file.name} ${(file.size / 1024).toFixed(1)}KB -> ${(compressedFile.size / 1024).toFixed(1)}KB`);
+                    resolve(compressedFile);
+                },
+                error: (err)=>{
+                    console.warn(`[SDK] 图片压缩失败，使用原图: ${file.name}`, err);
+                    resolve(file);
+                }
+            });
+        });
+    }
+    async getCosInstance(params) {
+        const response = await fetch(`${this.baseUrl}/workflows/upload/credentials`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...this.headers
+            },
+            body: JSON.stringify(params)
+        });
+        if (!response.ok) throw new Error('获取上传凭证失败');
+        const data = await response.json();
+        const cos = new cos_js_sdk_v5({
+            getAuthorization: (_options, callback)=>{
+                callback({
+                    TmpSecretId: data.credentials.tmpSecretId,
+                    TmpSecretKey: data.credentials.tmpSecretKey,
+                    SecurityToken: data.credentials.sessionToken,
+                    StartTime: data.startTime,
+                    ExpiredTime: data.expiredTime
+                });
+            }
+        });
+        return {
+            cos,
+            key: data.key,
+            bucket: data.bucket,
+            region: data.region,
+            cdnDomain: data.cdnDomain
+        };
+    }
+    async uploadFile(params) {
+        const { file, resourceType, onProgress } = params;
+        const { cos, key, bucket, region, cdnDomain } = await this.getCosInstance({
+            resourceType,
+            filename: file.name
+        });
+        return new Promise((resolve, reject)=>{
+            cos.putObject({
+                Bucket: bucket,
+                Region: region,
+                Key: key,
+                Body: file,
+                onProgress: (progressData)=>{
+                    if (onProgress) onProgress(progressData.percent);
+                }
+            }, (err, _data)=>{
+                if (err) reject(err);
+                else {
+                    const url = cdnDomain ? `https://${cdnDomain}/${key}` : `https://${bucket}.cos.${region}.myqcloud.com/${key}`;
+                    resolve(url);
+                }
+            });
+        });
+    }
+    async uploadImage(file, resourceType, onProgress) {
+        const compressedFile = await this.compressImage(file);
+        return this.uploadFile({
+            file: compressedFile,
+            resourceType,
+            onProgress
+        });
+    }
+}
+export { UploadService };

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "wtfai",
+  "version": "1.0.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@eslint/js": "^9.39.2",
+    "@rsbuild/plugin-react": "^1.4.2",
+    "@rslib/core": "^0.19.1",
+    "@types/react": "^19.2.7",
+    "eslint": "^9.39.2",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "globals": "^17.0.0",
+    "prettier": "^3.7.4",
+    "react": "^19.2.3",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.51.0"
+  },
+  "peerDependencies": {
+    "react": ">=16.9.0",
+    "react-dom": ">=16.9.0"
+  },
+  "dependencies": {
+    "@microsoft/fetch-event-source": "^2.0.1",
+    "compressorjs": "^1.2.1",
+    "cos-js-sdk-v5": "^1.10.1",
+    "uuid": "^13.0.0",
+    "@our-llm/shared": "2.0.0"
+  },
+  "scripts": {
+    "build": "rslib build",
+    "dev": "rslib build --watch",
+    "format": "prettier --write .",
+    "lint": "eslint ."
+  }
+}