@opentiny/tiny-robot-kit 0.2.0-alpha.2 → 0.2.0-alpha.3

package/src/utils.ts

@@ -1,125 +0,0 @@
-/**
- * 工具函数模块
- * 提供一些实用的辅助函数
- */
-
-import type { ChatMessage, ChatCompletionResponse, ChatCompletionStreamResponse, StreamHandler } from './types'
-
-/**
- * 处理SSE流式响应
- * @param response fetch响应对象
- * @param handler 流处理器
- */
-export async function handleSSEStream(response: Response, handler: StreamHandler, signal?: AbortSignal): Promise<void> {
-  // 获取ReadableStream
-  const reader = response.body?.getReader()
-  if (!reader) {
-    throw new Error('Response body is null')
-  }
-
-  // 处理流式数据
-  const decoder = new TextDecoder()
-  let buffer = ''
-
-  if (signal) {
-    signal.addEventListener(
-      'abort',
-      () => {
-        reader.cancel().catch((err) => console.error('Error cancelling reader:', err))
-      },
-      { once: true },
-    )
-  }
-
-  try {
-    while (true) {
-      if (signal?.aborted) {
-        await reader.cancel()
-        break
-      }
-
-      const { done, value } = await reader.read()
-      if (done) break
-
-      // 解码二进制数据
-      const chunk = decoder.decode(value, { stream: true })
-      buffer += chunk
-
-      // 处理完整的SSE消息
-      const lines = buffer.split('\n\n')
-      buffer = lines.pop() || ''
-
-      for (const line of lines) {
-        if (line.trim() === '') continue
-        if (line.trim() === 'data: [DONE]') {
-          handler.onDone()
-          continue
-        }
-
-        try {
-          // 解析SSE消息
-          const dataMatch = line.match(/^data: (.+)$/m)
-          if (!dataMatch) continue
-
-          const data = JSON.parse(dataMatch[1]) as ChatCompletionStreamResponse
-          handler.onData(data)
-        } catch (error) {
-          console.error('Error parsing SSE message:', error)
-        }
-      }
-    }
-
-    if (buffer.trim() === 'data: [DONE]' || signal?.aborted) {
-      handler.onDone()
-    }
-  } catch (error) {
-    if (signal?.aborted) return
-    throw error
-  }
-}
-
-/**
- * 格式化消息
- * 将各种格式的消息转换为标准的ChatMessage格式
- * @param messages 消息数组
- * @returns 标准格式的消息数组
- */
-export function formatMessages(messages: Array<ChatMessage | string>): ChatMessage[] {
-  return messages.map((msg) => {
-    // 如果已经是标准格式，直接返回
-    if (typeof msg === 'object' && 'role' in msg && 'content' in msg) {
-      return {
-        role: msg.role,
-        content: String(msg.content),
-        ...(msg.name ? { name: msg.name } : {}),
-      }
-    }
-
-    // 如果是字符串，默认为用户消息
-    if (typeof msg === 'string') {
-      return {
-        role: 'user',
-        content: msg,
-      }
-    }
-
-    // 其他情况，尝试转换为字符串
-    return {
-      role: 'user',
-      content: String(msg),
-    }
-  })
-}
-
-/**
- * 从响应中提取文本内容
- * @param response 聊天完成响应
- * @returns 文本内容
- */
-export function extractTextFromResponse(response: ChatCompletionResponse): string {
-  if (!response.choices || !response.choices.length) {
-    return ''
-  }
-
-  return response.choices[0].message?.content || ''
-}

package/src/vue/conversation/useConversation.ts

@@ -1,365 +0,0 @@
-/**
- * useConversation composable
- * 提供会话管理和持久化功能
- */
-
-import { reactive, watch } from 'vue'
-import type { ChatMessage } from '../../types'
-import { useMessage, type UseMessageReturn } from '../message/useMessage'
-import type { AIClient } from '../../client'
-
-/**
- * 会话接口
- */
-export interface Conversation {
-  /** 会话ID */
-  id: string
-  /** 会话标题 */
-  title: string
-  /** 创建时间 */
-  createdAt: number
-  /** 更新时间 */
-  updatedAt: number
-  /** 自定义元数据 */
-  metadata?: Record<string, unknown>
-  /** 会话消息 */
-  messages: ChatMessage[]
-}
-
-/**
- * 存储策略接口
- */
-export interface ConversationStorageStrategy {
-  /** 保存会话列表 */
-  saveConversations: (conversations: Conversation[]) => Promise<void> | void
-  /** 加载会话列表 */
-  loadConversations: () => Promise<Conversation[]> | Conversation[]
-}
-
-/**
- * 本地存储策略
- */
-export class LocalStorageStrategy implements ConversationStorageStrategy {
-  private storageKey: string
-
-  constructor(storageKey: string = 'tiny-robot-ai-conversations') {
-    this.storageKey = storageKey
-  }
-
-  saveConversations(conversations: Conversation[]): void {
-    try {
-      localStorage.setItem(this.storageKey, JSON.stringify(conversations))
-    } catch (error) {
-      console.error('保存会话失败:', error)
-    }
-  }
-
-  loadConversations(): Conversation[] {
-    try {
-      const data = localStorage.getItem(this.storageKey)
-      return data ? JSON.parse(data) : []
-    } catch (error) {
-      console.error('加载会话失败:', error)
-      return []
-    }
-  }
-}
-
-/**
- * 会话状态接口
- */
-export interface ConversationState {
-  /** 会话列表 */
-  conversations: Conversation[]
-  /** 当前会话ID */
-  currentId: string | null
-  /** 是否正在加载 */
-  loading: boolean
-}
-
-/**
- * useConversation选项接口
- */
-export interface UseConversationOptions {
-  /** AI客户端实例 */
-  client: AIClient
-  /** 存储策略 */
-  storage?: ConversationStorageStrategy
-  /** 是否自动保存 */
-  autoSave?: boolean
-  /** 是否默认使用流式响应 */
-  useStreamByDefault?: boolean
-  /** 错误消息模板 */
-  errorMessage?: string
-}
-
-/**
- * useConversation返回值接口
- */
-export interface UseConversationReturn {
-  /** 会话状态 */
-  state: ConversationState
-  /** 消息管理 */
-  messageManager: UseMessageReturn
-  /** 创建新会话 */
-  createConversation: (title?: string, metadata?: Record<string, unknown>) => string
-  /** 切换会话 */
-  switchConversation: (id: string) => void
-  /** 删除会话 */
-  deleteConversation: (id: string) => void
-  /** 更新会话标题 */
-  updateTitle: (id: string, title: string) => void
-  /** 更新会话元数据 */
-  updateMetadata: (id: string, metadata: Record<string, unknown>) => void
-  /** 保存会话 */
-  saveConversations: () => Promise<void>
-  /** 加载会话 */
-  loadConversations: () => Promise<void>
-  /** 生成会话标题 */
-  generateTitle: (id: string) => Promise<string>
-  /** 获取当前会话 */
-  getCurrentConversation: () => Conversation | null
-}
-
-/**
- * 生成唯一ID
- */
-function generateId(): string {
-  return Date.now().toString(36) + Math.random().toString(36).substring(2, 9)
-}
-
-/**
- * useConversation composable
- * 提供会话管理和持久化功能
- *
- * @param options useConversation选项
- * @returns UseConversationReturn
- */
-export function useConversation(options: UseConversationOptions): UseConversationReturn {
-  const {
-    client,
-    storage = new LocalStorageStrategy(),
-    autoSave = true,
-    useStreamByDefault = true,
-    errorMessage = '请求失败，请稍后重试',
-  } = options
-
-  // 会话状态
-  const state = reactive<ConversationState>({
-    conversations: [],
-    currentId: null,
-    loading: false,
-  })
-
-  // 消息管理
-  const messageManager = useMessage({
-    client,
-    useStreamByDefault,
-    errorMessage,
-    initialMessages: [],
-  })
-
-  // 监听消息变化，自动更新会话
-  watch(
-    () => messageManager.messages.value,
-    (messages: ChatMessage[]) => {
-      if (state.currentId && messages.length > 0) {
-        const index = state.conversations.findIndex((row: Conversation) => row.id === state.currentId)
-        if (index !== -1) {
-          state.conversations[index].messages = [...messages]
-          state.conversations[index].updatedAt = Date.now()
-          if (autoSave) {
-            saveConversations()
-          }
-        }
-      }
-    },
-    { deep: true },
-  )
-
-  /**
-   * 创建新会话
-   */
-  const createConversation = (title: string = '新会话', metadata: Record<string, unknown> = {}): string => {
-    const id = generateId()
-    const newConversation: Conversation = {
-      id,
-      title,
-      createdAt: Date.now(),
-      updatedAt: Date.now(),
-      messages: [],
-      metadata,
-    }
-
-    state.conversations.unshift(newConversation)
-    switchConversation(id)
-
-    if (autoSave) {
-      saveConversations()
-    }
-
-    return id
-  }
-
-  /**
-   * 切换会话
-   */
-  const switchConversation = (id: string): void => {
-    const conversation = state.conversations.find((conv: Conversation) => conv.id === id)
-    if (conversation) {
-      state.currentId = id
-      messageManager.clearMessages()
-      if (conversation.messages.length > 0) {
-        conversation.messages.forEach((msg: ChatMessage) => messageManager.addMessage(msg))
-      }
-    }
-  }
-
-  /**
-   * 删除会话
-   */
-  const deleteConversation = (id: string): void => {
-    const index = state.conversations.findIndex((conv: Conversation) => conv.id === id)
-    if (index !== -1) {
-      state.conversations.splice(index, 1)
-
-      // 如果删除的是当前会话，切换到第一个会话或清空
-      if (state.currentId === id) {
-        if (state.conversations.length > 0) {
-          switchConversation(state.conversations[0].id)
-        } else {
-          state.currentId = null
-          messageManager.clearMessages()
-        }
-      }
-
-      if (autoSave) {
-        saveConversations()
-      }
-    }
-  }
-
-  /**
-   * 更新会话标题
-   */
-  const updateTitle = (id: string, title: string): void => {
-    const conversation = state.conversations.find((conv: Conversation) => conv.id === id)
-    if (conversation) {
-      conversation.title = title
-      conversation.updatedAt = Date.now()
-
-      if (autoSave) {
-        saveConversations()
-      }
-    }
-  }
-
-  /**
-   * 更新会话元数据
-   */
-  const updateMetadata = (id: string, metadata: Record<string, unknown>): void => {
-    const conversation = state.conversations.find((conv: Conversation) => conv.id === id)
-    if (conversation) {
-      conversation.metadata = { ...conversation.metadata, ...metadata }
-      conversation.updatedAt = Date.now()
-
-      if (autoSave) {
-        saveConversations()
-      }
-    }
-  }
-
-  /**
-   * 保存会话
-   */
-  const saveConversations = async (): Promise<void> => {
-    try {
-      await storage.saveConversations(state.conversations)
-    } catch (error) {
-      console.error('保存会话失败:', error)
-    }
-  }
-
-  /**
-   * 加载会话
-   */
-  const loadConversations = async (): Promise<void> => {
-    state.loading = true
-    try {
-      const conversations = await storage.loadConversations()
-      state.conversations = conversations
-
-      // 如果有会话，默认选中第一个
-      if (conversations.length > 0 && !state.currentId) {
-        switchConversation(conversations[0].id)
-      }
-    } catch (error) {
-      console.error('加载会话失败:', error)
-    } finally {
-      state.loading = false
-    }
-  }
-
-  /**
-   * 生成会话标题
-   * 基于会话内容自动生成标题
-   */
-  const generateTitle = async (id: string): Promise<string> => {
-    const conversation = state.conversations.find((conv: Conversation) => conv.id === id)
-    if (!conversation || conversation.messages.length < 2) {
-      return conversation?.title || '新会话'
-    }
-
-    try {
-      // 构建生成标题的提示
-      const prompt: ChatMessage = {
-        role: 'system',
-        content:
-          '请根据以下对话内容，生成一个简短的标题（不超过20个字符）。只需要返回标题文本，不需要任何解释或额外内容。',
-      }
-
-      // 获取前几条消息用于生成标题
-      const contextMessages = conversation.messages.slice(0, Math.min(4, conversation.messages.length))
-
-      const response = await client.chat({
-        messages: [prompt, ...contextMessages],
-        options: {
-          stream: false,
-          max_tokens: 30,
-        },
-      })
-
-      const title = response.choices[0].message.content.trim()
-      updateTitle(id, title)
-      return title
-    } catch (error) {
-      console.error('生成标题失败:', error)
-      return conversation.title
-    }
-  }
-
-  /**
-   * 获取当前会话
-   */
-  const getCurrentConversation = (): Conversation | null => {
-    if (!state.currentId) return null
-    return state.conversations.find((conv: Conversation) => conv.id === state.currentId) || null
-  }
-
-  // 初始加载会话
-  loadConversations()
-
-  return {
-    state,
-    messageManager,
-    createConversation,
-    switchConversation,
-    deleteConversation,
-    updateTitle,
-    updateMetadata,
-    saveConversations,
-    loadConversations,
-    generateTitle,
-    getCurrentConversation,
-  }
-}

package/src/vue/index.ts

@@ -1,2 +0,0 @@
-export * from './message/useMessage'
-export * from './conversation/useConversation'

package/src/vue/message/useMessage.ts

@@ -1,227 +0,0 @@
-/**
- * useMessage composable
- * 提供消息管理和状态控制功能
- */
-
-import { reactive, Reactive, ref, toRaw, type Ref } from 'vue'
-import type { ChatMessage } from '../../types'
-import type { AIClient } from '../../client'
-
-export enum STATUS {
-  INIT = 'init', // 初始状态
-  PROCESSING = 'processing', // AI请求正在处理中, 还未响应，显示加载动画
-  STREAMING = 'streaming', // 流式响应中分块数据返回中
-  FINISHED = 'finished', // AI请求已完成
-  ABORTED = 'aborted', // 用户中止请求
-  ERROR = 'error', // AI请求发生错误
-}
-
-export const GeneratingStatus = [STATUS.PROCESSING, STATUS.STREAMING]
-export const FinalStatus = [STATUS.FINISHED, STATUS.ABORTED, STATUS.ERROR]
-
-/**
- * 消息状态接口
- */
-export interface MessageState {
-  status: STATUS
-  errorMsg: string | null
-}
-
-/**
- * useMessage选项接口
- */
-export interface UseMessageOptions {
-  /** AI客户端实例 */
-  client: AIClient
-  /** 是否默认使用流式响应 */
-  useStreamByDefault?: boolean
-  /** 错误消息模板 */
-  errorMessage?: string
-  /** 初始消息列表 */
-  initialMessages?: ChatMessage[]
-}
-
-/**
- * useMessage返回值接口
- */
-export interface UseMessageReturn {
-  messages: Ref<ChatMessage[]>
-  /** 消息状态 */
-  messageState: Reactive<MessageState>
-  /** 输入消息 */
-  inputMessage: Ref<string>
-  /** 是否使用流式响应 */
-  useStream: Ref<boolean>
-  /** 发送消息 */
-  sendMessage: (content?: string, clearInput?: boolean) => Promise<void>
-  /** 清空消息 */
-  clearMessages: () => void
-  /** 添加消息 */
-  addMessage: (message: ChatMessage) => void
-  /** 中止请求 */
-  abortRequest: () => void
-  /** 重试请求 */
-  retryRequest: (msgIndex: number) => Promise<void>
-}
-
-/**
- * useMessage composable
- * 提供消息管理和状态控制功能
- *
- * @param options useMessage选项
- * @returns UseMessageReturn
- */
-export function useMessage(options: UseMessageOptions): UseMessageReturn {
-  const { client, useStreamByDefault = true, errorMessage = '请求失败，请稍后重试', initialMessages = [] } = options
-
-  // 消息列表
-  const messages = ref<ChatMessage[]>([...initialMessages])
-
-  // 输入消息
-  const inputMessage = ref('')
-
-  // 是否使用流式响应
-  const useStream = ref(useStreamByDefault)
-
-  // 请求控制器
-  let abortController: AbortController | null = null
-
-  // 消息状态
-  const messageState = reactive<MessageState>({
-    status: STATUS.INIT,
-    errorMsg: null,
-  })
-
-  // 普通请求
-  const chat = async (abortController: AbortController) => {
-    const response = await client.chat({
-      messages: toRaw(messages.value),
-      options: {
-        stream: false,
-        signal: abortController.signal,
-      },
-    })
-
-    const assistantMessage: ChatMessage = {
-      role: 'assistant',
-      content: response.choices[0].message.content,
-    }
-    messages.value.push(assistantMessage)
-  }
-
-  // 流式请求
-  const streamChat = async (abortController: AbortController) => {
-    await client.chatStream(
-      {
-        messages: toRaw(messages.value),
-        options: {
-          stream: true,
-          signal: abortController.signal,
-        },
-      },
-      {
-        onData: (data) => {
-          messageState.status = STATUS.STREAMING
-          if (messages.value[messages.value.length - 1].role === 'user') {
-            messages.value.push({ role: 'assistant', content: '' })
-          }
-          const choice = data.choices?.[0]
-          if (choice && choice.delta.content) {
-            messages.value[messages.value.length - 1].content += choice.delta.content
-          }
-        },
-        onError: (error) => {
-          messageState.status = STATUS.ERROR
-          messageState.errorMsg = errorMessage
-          console.error('Stream request error:', error)
-        },
-        onDone: () => {
-          messageState.status = STATUS.FINISHED
-        },
-      },
-    )
-  }
-
-  const chatRequest = async () => {
-    // 更新状态
-    messageState.status = STATUS.PROCESSING
-    messageState.errorMsg = null
-
-    // 创建中止控制器
-    abortController = new AbortController()
-
-    try {
-      if (useStream.value) {
-        await streamChat(abortController)
-      } else {
-        await chat(abortController)
-      }
-      messageState.status = STATUS.FINISHED
-    } catch (error) {
-      messageState.errorMsg = errorMessage
-      messageState.status = STATUS.ERROR
-      console.error('Send message error:', error)
-    } finally {
-      abortController = null
-    }
-  }
-
-  // 发送消息
-  const sendMessage = async (content: string = inputMessage.value, clearInput: boolean = true) => {
-    if (!content?.trim() || GeneratingStatus.includes(messageState.status)) {
-      return
-    }
-
-    const userMessage: ChatMessage = {
-      role: 'user',
-      content,
-    }
-    messages.value.push(userMessage)
-    if (clearInput) {
-      inputMessage.value = ''
-    }
-
-    await chatRequest()
-  }
-
-  // 中止请求
-  const abortRequest = () => {
-    if (abortController) {
-      abortController.abort()
-      abortController = null
-      messageState.status = STATUS.ABORTED
-    }
-  }
-
-  // 重试请求
-  const retryRequest = async (msgIndex: number) => {
-    if (msgIndex === 0 || !messages.value[msgIndex] || messages.value[msgIndex].role === 'user') {
-      return
-    }
-    messages.value.splice(msgIndex)
-    await chatRequest()
-  }
-
-  //清空消息
-  const clearMessages = () => {
-    messages.value = []
-    messageState.errorMsg = null
-  }
-
-  // 添加消息
-  const addMessage = (message: ChatMessage) => {
-    messages.value.push(message)
-  }
-
-  return {
-    messages,
-    messageState,
-    inputMessage,
-    useStream,
-    sendMessage,
-    clearMessages,
-    addMessage,
-    abortRequest,
-    retryRequest,
-  }
-}