@yh-ui/ai-sdk 0.1.21

package/dist/langchain.d.ts

@@ -0,0 +1,232 @@
+/**
+ * LangChain Integration for YH-UI
+ *
+ * 提供与 LangChain 的深度集成
+ * 支持流式输出、函数调用、对话历史管理
+ */
+import { type Ref } from 'vue';
+import type { BaseMessage } from '@langchain/core/messages';
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import { HumanMessage, AIMessage } from '@langchain/core/messages';
+export interface LangChainMessage {
+    id: string;
+    role: 'user' | 'assistant' | 'system' | 'tool';
+    content: string;
+    name?: string;
+    toolCallId?: string;
+    createdAt?: Date;
+    additionalKwargs?: Record<string, unknown>;
+}
+export interface LangChainConfig {
+    /** LangChain ChatModel 实例 */
+    model: BaseChatModel;
+    /** 系统提示词 */
+    systemMessage?: string;
+    /** 温度参数 */
+    temperature?: number;
+    /** 最大 token 数 */
+    maxTokens?: number;
+    /** 流式输出 */
+    streaming?: boolean;
+    /** 回调函数 */
+    callbacks?: {
+        onChunk?: (chunk: string) => void;
+        onFinish?: (message: LangChainMessage) => void;
+        onError?: (error: Error) => void;
+    };
+}
+export interface UseLangChainChatOptions {
+    /** LangChain ChatModel 实例 */
+    model: BaseChatModel;
+    /** 初始消息 */
+    initialMessages?: LangChainMessage[];
+    /** 系统提示词 */
+    systemMessage?: string;
+    /** 最大历史消息数 */
+    maxHistory?: number;
+    /** 温度参数 */
+    temperature?: number;
+    /** 是否流式输出 */
+    streaming?: boolean;
+    /** 回调：收到 chunk */
+    onChunk?: (chunk: string) => void;
+    /** 回调：完成 */
+    onFinish?: (message: LangChainMessage) => void;
+    /** 回调：出错 */
+    onError?: (error: Error) => void;
+}
+export interface UseLangChainChatReturn {
+    /** 消息列表 */
+    messages: Ref<LangChainMessage[]>;
+    /** 输入内容 */
+    input: Ref<string>;
+    /** 是否正在加载 */
+    isLoading: Ref<boolean>;
+    /** 错误 */
+    error: Ref<Error | null>;
+    /** 发送消息 */
+    sendMessage: (content: string) => Promise<void>;
+    /** 清空历史 */
+    clearHistory: () => void;
+    /** 重新生成最后一条回复 */
+    reload: () => void;
+}
+export interface UseLangChainStreamOptions {
+    /** LangChain ChatModel 实例 */
+    model: BaseChatModel;
+    /** 系统提示词 */
+    systemMessage?: string;
+    /** 温度参数 */
+    temperature?: number;
+    /** 最大 token 数 */
+    maxTokens?: number;
+}
+export interface UseLangChainStreamReturn {
+    /** 当前内容 */
+    content: Ref<string>;
+    /** 是否正在流式 */
+    isStreaming: Ref<boolean>;
+    /** 错误 */
+    error: Ref<Error | null>;
+    /** 开始流式请求 */
+    start: (prompt: string, history?: LangChainMessage[]) => Promise<void>;
+    /** 停止 */
+    stop: () => void;
+}
+/**
+ * LangChain Runtime - LangChain.js 在浏览器中的运行时
+ *
+ * @example
+ * ```ts
+ * import { ChatOpenAI } from '@langchain/openai'
+ * import { langChainRuntime } from '@yh-ui/ai-sdk'
+ *
+ * const model = new ChatOpenAI({
+ *   model: 'gpt-4',
+ *   apiKey: yourApiKey
+ * })
+ *
+ * const result = await langChainRuntime.invoke(model, '你好')
+ * ```
+ */
+export declare const langChainRuntime: {
+    /**
+     * 同步调用模型
+     */
+    invoke(model: BaseChatModel, input: string | HumanMessage | BaseMessage, options?: {
+        systemMessage?: string;
+        temperature?: number;
+        maxTokens?: number;
+    }): Promise<AIMessage>;
+    /**
+     * 流式调用模型
+     */
+    stream(model: BaseChatModel, input: string | HumanMessage | BaseMessage, options?: {
+        systemMessage?: string;
+        temperature?: number;
+        maxTokens?: number;
+        onChunk?: (chunk: string) => void;
+    }): Promise<AIMessage>;
+    /**
+     * 带工具调用的流式调用
+     */
+    streamWithTools(model: BaseChatModel, input: string | HumanMessage | BaseMessage, tools: unknown[], options?: {
+        systemMessage?: string;
+        temperature?: number;
+        maxTokens?: number;
+        onChunk?: (chunk: string) => void;
+        onToolCall?: (toolCall: {
+            name: string;
+            args: Record<string, unknown>;
+        }) => void;
+    }): Promise<{
+        message: AIMessage;
+        toolCalls?: unknown[];
+    }>;
+};
+/**
+ * 使用 LangChain 进行对话
+ *
+ * @example
+ * ```ts
+ * import { ChatOpenAI } from '@langchain/openai'
+ * import { useLangChainChat } from '@yh-ui/ai-sdk'
+ *
+ * const model = new ChatOpenAI({ model: 'gpt-4' })
+ *
+ * const { messages, input, isLoading, sendMessage } = useLangChainChat({
+ *   model,
+ *   systemMessage: '你是一个有帮助的助手',
+ *   streaming: true,
+ *   onChunk: (chunk) => console.log('收到:', chunk)
+ * })
+ *
+ * await sendMessage('你好')
+ * ```
+ */
+export declare function useLangChainChat(options: UseLangChainChatOptions): UseLangChainChatReturn;
+/**
+ * 使用 LangChain 进行流式文本生成
+ *
+ * @example
+ * ```ts
+ * import { ChatOpenAI } from '@langchain/openai'
+ * import { useLangChainStream } from '@yh-ui/ai-sdk'
+ *
+ * const model = new ChatOpenAI({ model: 'gpt-4' })
+ *
+ * const { content, isStreaming, start, stop } = useLangChainStream({
+ *   model,
+ *   systemMessage: '你是一个有帮助的助手'
+ * })
+ *
+ * await start('请介绍一下 Vue 3')
+ * ```
+ */
+export declare function useLangChainStream(options: UseLangChainStreamOptions): UseLangChainStreamReturn;
+/**
+ * 创建 LangChain 对话链
+ *
+ * @example
+ * ```ts
+ * import { ChatOpenAI } from '@langchain/openai'
+ * import { createLangChainChain } from '@yh-ui/ai-sdk'
+ *
+ * const model = new ChatOpenAI({ model: 'gpt-4' })
+ *
+ * const chain = createLangChainChain(model, {
+ *   systemMessage: '你是一个有帮助的助手',
+ *   temperature: 0.7
+ * })
+ *
+ * const result = await chain.invoke('你好')
+ * ```
+ */
+export declare function createLangChainChain(model: BaseChatModel, config?: {
+    systemMessage?: string;
+    temperature?: number;
+    maxTokens?: number;
+    streaming?: boolean;
+}): {
+    /**
+     * 同步调用
+     */
+    invoke(input: string): Promise<string | (import("@langchain/core/messages").ContentBlock | import("@langchain/core/messages").ContentBlock.Text)[]>;
+    /**
+     * 流式调用
+     */
+    stream(input: string): AsyncGenerator<string | (import("@langchain/core/messages").ContentBlock | import("@langchain/core/messages").ContentBlock.Text)[], void, unknown>;
+    /**
+     * 带工具调用
+     */
+    invokeWithTools(input: string, tools: unknown[], toolHandler?: (toolName: string, args: Record<string, unknown>) => Promise<string>): Promise<{
+        message: string | (import("@langchain/core/messages").ContentBlock | import("@langchain/core/messages").ContentBlock.Text)[];
+        toolCalls: import("@langchain/core/messages").OpenAIToolCall[];
+    } | {
+        message: string | (import("@langchain/core/messages").ContentBlock | import("@langchain/core/messages").ContentBlock.Text)[];
+        toolCalls: undefined;
+    }>;
+};
+export type { BaseChatModel, BaseChatModelCallOptions } from '@langchain/core/language_models/chat_models';
+export type { BaseMessage, AIMessage as LCAIMessage, HumanMessage as LCHumanMessage, SystemMessage as LCSystemMessage, ToolMessage as LCToolMessage } from '@langchain/core/messages';
+export { AIMessage, HumanMessage, SystemMessage, ToolMessage } from '@langchain/core/messages';

package/dist/langchain.mjs

@@ -0,0 +1,319 @@
+import { ref, onUnmounted } from "vue";
+import { HumanMessage, AIMessage, SystemMessage, ToolMessage } from "@langchain/core/messages";
+export const langChainRuntime = {
+  /**
+   * 同步调用模型
+   */
+  async invoke(model, input, options) {
+    const messages = [];
+    if (options?.systemMessage) {
+      messages.push(new SystemMessage(options.systemMessage));
+    }
+    if (typeof input === "string") {
+      messages.push(new HumanMessage(input));
+    } else {
+      messages.push(input);
+    }
+    const response = await model.invoke(messages);
+    return response;
+  },
+  /**
+   * 流式调用模型
+   */
+  async stream(model, input, options) {
+    const messages = [];
+    if (options?.systemMessage) {
+      messages.push(new SystemMessage(options.systemMessage));
+    }
+    if (typeof input === "string") {
+      messages.push(new HumanMessage(input));
+    } else {
+      messages.push(input);
+    }
+    const stream = await model.stream(messages);
+    let fullContent = "";
+    for await (const chunk of stream) {
+      const content = String(chunk?.content || "");
+      fullContent += content;
+      options?.onChunk?.(content);
+    }
+    return new AIMessage(fullContent);
+  },
+  /**
+   * 带工具调用的流式调用
+   */
+  async streamWithTools(model, input, tools, options) {
+    const messages = [];
+    if (options?.systemMessage) {
+      messages.push(new SystemMessage(options.systemMessage));
+    }
+    if (typeof input === "string") {
+      messages.push(new HumanMessage(input));
+    } else {
+      messages.push(input);
+    }
+    const modelWithTools = model.bind({ tools });
+    const stream = await modelWithTools.stream(messages);
+    let fullContent = "";
+    const toolCalls = [];
+    for await (const chunk of stream) {
+      const content = String(chunk?.content || "");
+      if (content) {
+        fullContent += content;
+        options?.onChunk?.(content);
+      }
+      const additionalKwargs = chunk?.additional_kwargs;
+      if (additionalKwargs?.tool_calls) {
+        for (const tc of additionalKwargs.tool_calls) {
+          toolCalls.push(tc);
+          options?.onToolCall?.({
+            name: tc.function?.name || "",
+            args: tc.function?.arguments ? JSON.parse(tc.function.arguments) : {}
+          });
+        }
+      }
+    }
+    return {
+      message: new AIMessage(fullContent),
+      toolCalls: toolCalls.length > 0 ? toolCalls : void 0
+    };
+  }
+};
+export function useLangChainChat(options) {
+  const {
+    model,
+    initialMessages = [],
+    systemMessage,
+    maxHistory = 20,
+    streaming = false,
+    onChunk,
+    onFinish,
+    onError
+  } = options;
+  const messages = ref([...initialMessages]);
+  const input = ref("");
+  const isLoading = ref(false);
+  const error = ref(null);
+  const toLangChainMessages = (msgs) => {
+    return msgs.map((msg) => {
+      switch (msg.role) {
+        case "user":
+          return new HumanMessage(msg.content);
+        case "assistant":
+          return new AIMessage(msg.content);
+        case "system":
+          return new SystemMessage(msg.content);
+        case "tool":
+          return new ToolMessage({
+            content: msg.content,
+            tool_call_id: msg.toolCallId || ""
+          });
+        default:
+          return new HumanMessage(msg.content);
+      }
+    });
+  };
+  const addMessage = (msg) => {
+    const newMessage = {
+      ...msg,
+      id: `msg-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    messages.value = [...messages.value, newMessage].slice(-maxHistory);
+    return newMessage;
+  };
+  const sendMessage = async (content) => {
+    if (!content.trim() || isLoading.value) return;
+    error.value = null;
+    isLoading.value = true;
+    addMessage({ role: "user", content });
+    input.value = "";
+    try {
+      const langChainMessages = [];
+      if (systemMessage) {
+        langChainMessages.push(new SystemMessage(systemMessage));
+      }
+      langChainMessages.push(...toLangChainMessages(messages.value.slice(0, -1)));
+      if (streaming) {
+        const stream = await model.stream(langChainMessages);
+        const assistantMsg = addMessage({ role: "assistant", content: "" });
+        let fullContent = "";
+        for await (const chunk of stream) {
+          const chunkContent = String(chunk?.content || "");
+          fullContent += chunkContent;
+          messages.value = messages.value.map(
+            (m) => m.id === assistantMsg.id ? { ...m, content: fullContent } : m
+          );
+          onChunk?.(chunkContent);
+        }
+        onFinish?.(messages.value[messages.value.length - 1]);
+      } else {
+        const response = await model.invoke(langChainMessages);
+        const assistantMsg = addMessage({
+          role: "assistant",
+          content: String(response.content)
+        });
+        onFinish?.(assistantMsg);
+      }
+    } catch (err) {
+      const errorObj = err instanceof Error ? err : new Error(String(err));
+      error.value = errorObj;
+      onError?.(errorObj);
+    } finally {
+      isLoading.value = false;
+    }
+  };
+  const clearHistory = () => {
+    messages.value = [];
+  };
+  const reload = async () => {
+    if (messages.value.length > 0) {
+      const lastUserMsg = [...messages.value].reverse().find((m) => m.role === "user");
+      if (lastUserMsg) {
+        const userMsgIndex = messages.value.findIndex((m) => m.id === lastUserMsg.id);
+        messages.value = messages.value.slice(0, userMsgIndex + 1);
+        await sendMessage(lastUserMsg.content);
+      }
+    }
+  };
+  return {
+    messages,
+    input,
+    isLoading,
+    error,
+    sendMessage,
+    clearHistory,
+    reload
+  };
+}
+export function useLangChainStream(options) {
+  const { model, systemMessage } = options;
+  const content = ref("");
+  const isStreaming = ref(false);
+  const error = ref(null);
+  let abortController = null;
+  const start = async (prompt, history = []) => {
+    if (isStreaming.value) {
+      stop();
+    }
+    error.value = null;
+    isStreaming.value = true;
+    content.value = "";
+    try {
+      const messages = [];
+      if (systemMessage) {
+        messages.push(new SystemMessage(systemMessage));
+      }
+      for (const msg of history) {
+        switch (msg.role) {
+          case "user":
+            messages.push(new HumanMessage(msg.content));
+            break;
+          case "assistant":
+            messages.push(new AIMessage(msg.content));
+            break;
+          case "system":
+            messages.push(new SystemMessage(msg.content));
+            break;
+        }
+      }
+      messages.push(new HumanMessage(prompt));
+      const stream = await model.stream(messages);
+      for await (const chunk of stream) {
+        const chunkContent = String(chunk?.content || "");
+        content.value += chunkContent;
+      }
+    } catch (err) {
+      if (err.name !== "AbortError") {
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        error.value = errorObj;
+      }
+    } finally {
+      isStreaming.value = false;
+    }
+  };
+  const stop = () => {
+    if (abortController) {
+      ;
+      abortController.abort();
+    }
+    isStreaming.value = false;
+  };
+  onUnmounted(() => {
+    stop();
+  });
+  return {
+    content,
+    isStreaming,
+    error,
+    start,
+    stop
+  };
+}
+export function createLangChainChain(model, config) {
+  return {
+    /**
+     * 同步调用
+     */
+    async invoke(input) {
+      const messages = [];
+      if (config?.systemMessage) {
+        messages.push(new SystemMessage(config.systemMessage));
+      }
+      messages.push(new HumanMessage(input));
+      const response = await model.invoke(messages);
+      return response.content;
+    },
+    /**
+     * 流式调用
+     */
+    async *stream(input) {
+      const messages = [];
+      if (config?.systemMessage) {
+        messages.push(new SystemMessage(config.systemMessage));
+      }
+      messages.push(new HumanMessage(input));
+      const stream = await model.stream(messages);
+      for await (const chunk of stream) {
+        yield chunk?.content || "";
+      }
+    },
+    /**
+     * 带工具调用
+     */
+    async invokeWithTools(input, tools, toolHandler) {
+      const messages = [];
+      if (config?.systemMessage) {
+        messages.push(new SystemMessage(config.systemMessage));
+      }
+      messages.push(new HumanMessage(input));
+      const modelWithTools = model.bind({ tools });
+      const response = await modelWithTools.invoke(messages);
+      const toolCalls = response?.additional_kwargs?.tool_calls;
+      if (toolCalls && toolCalls.length > 0 && toolHandler) {
+        for (const tc of toolCalls) {
+          const toolName = tc.function?.name || "";
+          const args = tc.function?.arguments ? JSON.parse(tc.function.arguments) : {};
+          const toolResult = await toolHandler(toolName, args);
+          messages.push(response);
+          messages.push(
+            new ToolMessage({
+              content: toolResult,
+              tool_call_id: tc.id || ""
+            })
+          );
+          const finalResponse = await model.invoke(messages);
+          return {
+            message: finalResponse.content,
+            toolCalls
+          };
+        }
+      }
+      return {
+        message: response.content,
+        toolCalls: void 0
+      };
+    }
+  };
+}
+export { AIMessage, HumanMessage, SystemMessage, ToolMessage } from "@langchain/core/messages";

package/dist/loaders.cjs

@@ -0,0 +1,110 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.chunkText = chunkText;
+exports.createFileLoader = createFileLoader;
+exports.createTextLoader = createTextLoader;
+exports.loadMarkdown = loadMarkdown;
+function createTextLoader(content, metadata) {
+  return {
+    content: content.trim(),
+    metadata
+  };
+}
+function loadMarkdown(markdown, options = {}) {
+  const chunkSize = options.chunkSize ?? 1e3;
+  const chunkOverlap = Math.min(options.chunkOverlap ?? 200, Math.floor(chunkSize * 0.5));
+  const {
+    split = true
+  } = options;
+  if (!split) {
+    return [{
+      content: markdown.trim(),
+      metadata: {
+        type: "markdown"
+      }
+    }];
+  }
+  const blocks = [];
+  const lines = markdown.split(/\r?\n/);
+  let current = "";
+  for (const line of lines) {
+    const isHeading = /^#{1,6}\s/.test(line);
+    if (isHeading && current.length >= chunkSize) {
+      if (current.trim()) blocks.push(current.trim());
+      current = line + "\n";
+    } else {
+      current += line + "\n";
+      if (current.length >= chunkSize) {
+        if (current.trim()) blocks.push(current.trim());
+        current = current.slice(-chunkOverlap);
+      }
+    }
+  }
+  if (current.trim()) blocks.push(current.trim());
+  return blocks.map((content, i) => ({
+    content,
+    metadata: {
+      type: "markdown",
+      index: i
+    }
+  }));
+}
+function chunkText(text, options = {}) {
+  const chunkSize = options.chunkSize ?? 800;
+  const chunkOverlap = Math.min(options.chunkOverlap ?? 100, Math.floor(chunkSize * 0.5));
+  const chunks = [];
+  let start = 0;
+  while (start < text.length) {
+    const end = Math.min(start + chunkSize, text.length);
+    let slice = text.slice(start, end);
+    if (end < text.length) {
+      const lastSpace = slice.lastIndexOf(" ");
+      if (lastSpace > chunkSize / 2) slice = slice.slice(0, lastSpace + 1);
+    }
+    if (slice.trim()) {
+      chunks.push({
+        content: slice.trim(),
+        metadata: {
+          index: chunks.length
+        }
+      });
+    }
+    const nextStart = start + slice.length - chunkOverlap;
+    start = nextStart > start ? nextStart : start + slice.length;
+    if (start >= text.length) break;
+  }
+  return chunks;
+}
+function createFileLoader(options) {
+  const {
+    pdf,
+    docx,
+    chunkSize = 800,
+    chunkOverlap = 100
+  } = options;
+  return {
+    async loadFromText(content) {
+      return chunkText(content, {
+        chunkSize,
+        chunkOverlap
+      });
+    },
+    async loadFromMarkdown(content) {
+      return loadMarkdown(content, {
+        chunkSize,
+        chunkOverlap
+      });
+    },
+    async loadFromPDF(input) {
+      if (!pdf) throw new Error("PDF loader not configured. Provide options.pdf or install a PDF library.");
+      return pdf(input);
+    },
+    async loadFromDOCX(input) {
+      if (!docx) throw new Error("DOCX loader not configured. Provide options.docx or install a DOCX library.");
+      return docx(input);
+    }
+  };
+}