@yh-ui/ai-sdk 0.1.21

package/dist/index.d.ts

@@ -0,0 +1,55 @@
+/**
+ * YH-UI AI SDK Utilities
+ *
+ * 提供基础的 AI 工具函数和类型定义
+ * 同时完全兼容 Vercel AI SDK
+ */
+export { generateText, streamText, generateObject, streamObject, embed, embedMany, experimental_generateImage, experimental_generateSpeech, experimental_transcribe, tool, jsonSchema, zodSchema, customProvider, createProviderRegistry, wrapLanguageModel, extractReasoningMiddleware, simulateStreamingMiddleware, defaultSettingsMiddleware, smoothStream, simulateReadableStream, generateId, createIdGenerator, cosineSimilarity, createDataStream, createDataStreamResponse, formatAssistantStreamPart, formatDataStreamPart, parseAssistantStreamPart, parseDataStreamPart, pipeDataStreamToResponse, processDataStream, processTextStream, convertToCoreMessages, appendClientMessage, appendResponseMessages, coreMessageSchema, coreSystemMessageSchema, coreUserMessageSchema, coreAssistantMessageSchema, coreToolMessageSchema, LangChainAdapter, LlamaIndexAdapter } from 'ai';
+export { AISDKError, APICallError, AssistantResponse, DownloadError, EmptyResponseBodyError, InvalidArgumentError, InvalidDataContentError, InvalidMessageRoleError, InvalidPromptError, InvalidResponseDataError, InvalidStreamPartError, InvalidToolArgumentsError, JSONParseError, LoadAPIKeyError, MCPClientError, MessageConversionError, NoContentGeneratedError, NoImageGeneratedError, NoObjectGeneratedError, NoOutputSpecifiedError, NoSuchModelError, NoSuchProviderError, NoSuchToolError, Output, RetryError, StreamData, ToolCallRepairError, ToolExecutionError, TypeValidationError, UnsupportedFunctionalityError, UnsupportedModelVersionError } from 'ai';
+export type { BaseChatModel, BaseChatModelCallOptions, BaseMessage, AIMessage as LCAIMessage, HumanMessage as LCHumanMessage, SystemMessage as LCSystemMessage, ToolMessage as LCToolMessage, LangChainMessage, LangChainConfig, UseLangChainChatOptions, UseLangChainChatReturn, UseLangChainStreamOptions, UseLangChainStreamReturn } from './langchain';
+export { AIMessage, HumanMessage, SystemMessage, ToolMessage } from './langchain';
+export { useLangChainChat, useLangChainStream, createLangChainChain, langChainRuntime } from './langchain';
+export type { StreamableValue, ConversationMessage, ConversationConfig, ToolCallHandler, ProviderAdapter, ModelConfig, UseAIChatOptions, UseAIChatReturn, UseAIStreamOptions, UseAIStreamReturn, AIContextValue, ToolCall, XRequestConfig, XRequestCallbacks, AIMiddleware, CacheConfig, RetryConfig, Conversation, UseConversationsOptions, ProviderPreset } from './vue';
+export { createStreamableValue, useStreamableValue, useConversation, useConversations, useAIChat, useAIStream, createYHFunctionTool, createProviderAdapter, createAIContext, XRequest, createXRequest, registerMiddleware, clearCache, getProviderPreset, PROVIDER_PRESETS, createVercelAIProvider } from './vue';
+export { useReActAgent, createPlanExecuteAgent, type AgentConfig, type AgentTool, type AgentStep, type AgentResult, type StopCondition } from './future';
+export { createMultiModalMessage, createImageContent, createImageUrlContent, createAudioContent, createVideoContent, type MultiModalContent, type MultiModalMessage, type VisionAnalysisOptions } from './future';
+export { createRAGSystem, type RAGConfig, type RAGResult, type DocumentChunk } from './future';
+export { createChainOfThought, type CoTConfig, type ReasoningStep } from './future';
+export { createContextCompressor, type CompressionConfig, type CompressionResult } from './future';
+export { createCostTracker, type CostConfig, type CostTracking, type TokenUsage } from './future';
+export { createTracer, type TraceEvent, type TraceSpan } from './future';
+export { createOTelConsoleExporter, createLangSmithExporter, createObservabilityManager, toOTelSpan, type OTelSpan, type OTelExportPayload, type LangSmithRun, type LangSmithClientConfig, type TraceExporter } from './observability';
+export { createSafetyFilter, type SafetyRule, type SafetyResult } from './future';
+export { fromZodSchema, createJSONSchema, schema, parseStructuredOutput, type SchemaDefinition, type SchemaProperty } from './future';
+export { createInMemoryVectorStore, type IVectorStore, type VectorDocument, type VectorSearchResult, type VectorStoreConfig, type PineconeVectorStoreConfig, type WeaviateVectorStoreConfig, type QdrantVectorStoreConfig } from './vector-store';
+export { createTextLoader, loadMarkdown, chunkText, createFileLoader, type LoadedDocument, type DocumentLoaderOptions, type PDFLoader, type DOCXLoader } from './loaders';
+export { createMemoryCache, createLocalStorageCache, createSessionStorageCache, type CacheAdapter, type RedisCacheConfig } from './cache-adapter';
+export { createRateLimiter, createRateLimitMiddleware, type RateLimitConfig, type RateLimitMiddleware } from './rate-limit';
+export { createProductionRAG, type ProductionRAGConfig } from './rag-production';
+export { createEnhancedAgent, createReflexionAgent, createReWOOAgent, createChain, createParallelChain, type ReasoningMode, type EnhancedAgentConfig, type ReflexionConfig, type ReWOOConfig, type ChainStep, type Chain } from './agent-enhanced';
+export { useMCPClient, useMCPTools, type MCPConnectionConfig, type MCPClientState, type MCPTool, type UseMCPClientOptions, type UseMCPClientReturn, type UseMCPToolsOptions, type UseMCPToolsReturn, type MCPServerState } from './mcp';
+export { MCPServer, useMCPServer, createMCPServerHTTPHandler, type MCPServerTool, type MCPToolContent, type MCPServerConfig, type MCPServerOptions, type MCPServerTransport, type UseMCPServerOptions, type UseMCPServerReturn, type MCPJSONRPCRequest, type MCPJSONRPCResponse } from './mcp-server';
+export interface AIProvider {
+    name: string;
+    baseUrl?: string;
+    apiKey?: string;
+    defaultModel?: string;
+}
+export interface ChatOptions {
+    model: string;
+    temperature?: number;
+    maxTokens?: number;
+    topP?: number;
+    messages: Array<{
+        role: string;
+        content: string;
+    }>;
+}
+/**
+ * Create a simple AI chat completion
+ */
+export declare function createChatCompletion(provider: AIProvider, options: ChatOptions): Promise<string>;
+/**
+ * Create a streaming AI chat completion
+ */
+export declare function createStreamingChatCompletion(provider: AIProvider, options: ChatOptions): AsyncGenerator<string>;

package/dist/index.mjs

@@ -0,0 +1,217 @@
+export {
+  generateText,
+  streamText,
+  generateObject,
+  streamObject,
+  embed,
+  embedMany,
+  experimental_generateImage,
+  experimental_generateSpeech,
+  experimental_transcribe,
+  tool,
+  jsonSchema,
+  zodSchema,
+  customProvider,
+  createProviderRegistry,
+  wrapLanguageModel,
+  extractReasoningMiddleware,
+  simulateStreamingMiddleware,
+  defaultSettingsMiddleware,
+  smoothStream,
+  simulateReadableStream,
+  generateId,
+  createIdGenerator,
+  cosineSimilarity,
+  createDataStream,
+  createDataStreamResponse,
+  formatAssistantStreamPart,
+  formatDataStreamPart,
+  parseAssistantStreamPart,
+  parseDataStreamPart,
+  pipeDataStreamToResponse,
+  processDataStream,
+  processTextStream,
+  convertToCoreMessages,
+  appendClientMessage,
+  appendResponseMessages,
+  coreMessageSchema,
+  coreSystemMessageSchema,
+  coreUserMessageSchema,
+  coreAssistantMessageSchema,
+  coreToolMessageSchema,
+  LangChainAdapter,
+  LlamaIndexAdapter
+} from "ai";
+export {
+  AISDKError,
+  APICallError,
+  AssistantResponse,
+  DownloadError,
+  EmptyResponseBodyError,
+  InvalidArgumentError,
+  InvalidDataContentError,
+  InvalidMessageRoleError,
+  InvalidPromptError,
+  InvalidResponseDataError,
+  InvalidStreamPartError,
+  InvalidToolArgumentsError,
+  JSONParseError,
+  LoadAPIKeyError,
+  MCPClientError,
+  MessageConversionError,
+  NoContentGeneratedError,
+  NoImageGeneratedError,
+  NoObjectGeneratedError,
+  NoOutputSpecifiedError,
+  NoSuchModelError,
+  NoSuchProviderError,
+  NoSuchToolError,
+  Output,
+  RetryError,
+  StreamData,
+  ToolCallRepairError,
+  ToolExecutionError,
+  TypeValidationError,
+  UnsupportedFunctionalityError,
+  UnsupportedModelVersionError
+} from "ai";
+export { AIMessage, HumanMessage, SystemMessage, ToolMessage } from "./langchain.mjs";
+export {
+  useLangChainChat,
+  useLangChainStream,
+  createLangChainChain,
+  langChainRuntime
+} from "./langchain.mjs";
+export {
+  createStreamableValue,
+  useStreamableValue,
+  useConversation,
+  useConversations,
+  useAIChat,
+  useAIStream,
+  createYHFunctionTool,
+  createProviderAdapter,
+  createAIContext,
+  XRequest,
+  createXRequest,
+  registerMiddleware,
+  clearCache,
+  getProviderPreset,
+  PROVIDER_PRESETS,
+  createVercelAIProvider
+} from "./vue/index.mjs";
+export {
+  useReActAgent,
+  createPlanExecuteAgent
+} from "./future.mjs";
+export {
+  createMultiModalMessage,
+  createImageContent,
+  createImageUrlContent,
+  createAudioContent,
+  createVideoContent
+} from "./future.mjs";
+export { createRAGSystem } from "./future.mjs";
+export { createChainOfThought } from "./future.mjs";
+export { createContextCompressor } from "./future.mjs";
+export { createCostTracker } from "./future.mjs";
+export { createTracer } from "./future.mjs";
+export {
+  createOTelConsoleExporter,
+  createLangSmithExporter,
+  createObservabilityManager,
+  toOTelSpan
+} from "./observability.mjs";
+export { createSafetyFilter } from "./future.mjs";
+export {
+  fromZodSchema,
+  createJSONSchema,
+  schema,
+  parseStructuredOutput
+} from "./future.mjs";
+export {
+  createInMemoryVectorStore
+} from "./vector-store.mjs";
+export {
+  createTextLoader,
+  loadMarkdown,
+  chunkText,
+  createFileLoader
+} from "./loaders.mjs";
+export {
+  createMemoryCache,
+  createLocalStorageCache,
+  createSessionStorageCache
+} from "./cache-adapter.mjs";
+export {
+  createRateLimiter,
+  createRateLimitMiddleware
+} from "./rate-limit.mjs";
+export { createProductionRAG } from "./rag-production.mjs";
+export {
+  createEnhancedAgent,
+  createReflexionAgent,
+  createReWOOAgent,
+  createChain,
+  createParallelChain
+} from "./agent-enhanced.mjs";
+export {
+  useMCPClient,
+  useMCPTools
+} from "./mcp.mjs";
+export {
+  MCPServer,
+  useMCPServer,
+  createMCPServerHTTPHandler
+} from "./mcp-server.mjs";
+export async function createChatCompletion(provider, options) {
+  const response = await fetch(`${provider.baseUrl}/chat/completions`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...provider.apiKey && { Authorization: `Bearer ${provider.apiKey}` }
+    },
+    body: JSON.stringify(options)
+  });
+  if (!response.ok) {
+    throw new Error(`AI API Error: ${response.status}`);
+  }
+  const data = await response.json();
+  return data.choices?.[0]?.message?.content || "";
+}
+export async function* createStreamingChatCompletion(provider, options) {
+  const response = await fetch(`${provider.baseUrl}/chat/completions`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...provider.apiKey && { Authorization: `Bearer ${provider.apiKey}` }
+    },
+    body: JSON.stringify({
+      stream: true,
+      ...options
+    })
+  });
+  if (!response.ok || !response.body) {
+    throw new Error(`AI API Error: ${response.status}`);
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    const chunk = decoder.decode(value, { stream: true });
+    const lines = chunk.split("\n").filter((line) => line.trim() !== "");
+    for (const line of lines) {
+      if (line.startsWith("data: ")) {
+        const data = line.slice(6);
+        if (data === "[DONE]") return;
+        try {
+          const parsed = JSON.parse(data);
+          const content = parsed.choices?.[0]?.delta?.content;
+          if (content) yield content;
+        } catch {
+        }
+      }
+    }
+  }
+}

package/dist/langchain.cjs

@@ -0,0 +1,363 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "AIMessage", {
+  enumerable: true,
+  get: function () {
+    return _messages.AIMessage;
+  }
+});
+Object.defineProperty(exports, "HumanMessage", {
+  enumerable: true,
+  get: function () {
+    return _messages.HumanMessage;
+  }
+});
+Object.defineProperty(exports, "SystemMessage", {
+  enumerable: true,
+  get: function () {
+    return _messages.SystemMessage;
+  }
+});
+Object.defineProperty(exports, "ToolMessage", {
+  enumerable: true,
+  get: function () {
+    return _messages.ToolMessage;
+  }
+});
+exports.createLangChainChain = createLangChainChain;
+exports.langChainRuntime = void 0;
+exports.useLangChainChat = useLangChainChat;
+exports.useLangChainStream = useLangChainStream;
+var _vue = require("vue");
+var _messages = require("@langchain/core/messages");
+const langChainRuntime = exports.langChainRuntime = {
+  /**
+   * 同步调用模型
+   */
+  async invoke(model, input, options) {
+    const messages = [];
+    if (options?.systemMessage) {
+      messages.push(new _messages.SystemMessage(options.systemMessage));
+    }
+    if (typeof input === "string") {
+      messages.push(new _messages.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 _messages.SystemMessage(options.systemMessage));
+    }
+    if (typeof input === "string") {
+      messages.push(new _messages.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 _messages.AIMessage(fullContent);
+  },
+  /**
+   * 带工具调用的流式调用
+   */
+  async streamWithTools(model, input, tools, options) {
+    const messages = [];
+    if (options?.systemMessage) {
+      messages.push(new _messages.SystemMessage(options.systemMessage));
+    }
+    if (typeof input === "string") {
+      messages.push(new _messages.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 _messages.AIMessage(fullContent),
+      toolCalls: toolCalls.length > 0 ? toolCalls : void 0
+    };
+  }
+};
+function useLangChainChat(options) {
+  const {
+    model,
+    initialMessages = [],
+    systemMessage,
+    maxHistory = 20,
+    streaming = false,
+    onChunk,
+    onFinish,
+    onError
+  } = options;
+  const messages = (0, _vue.ref)([...initialMessages]);
+  const input = (0, _vue.ref)("");
+  const isLoading = (0, _vue.ref)(false);
+  const error = (0, _vue.ref)(null);
+  const toLangChainMessages = msgs => {
+    return msgs.map(msg => {
+      switch (msg.role) {
+        case "user":
+          return new _messages.HumanMessage(msg.content);
+        case "assistant":
+          return new _messages.AIMessage(msg.content);
+        case "system":
+          return new _messages.SystemMessage(msg.content);
+        case "tool":
+          return new _messages.ToolMessage({
+            content: msg.content,
+            tool_call_id: msg.toolCallId || ""
+          });
+        default:
+          return new _messages.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 _messages.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
+  };
+}
+function useLangChainStream(options) {
+  const {
+    model,
+    systemMessage
+  } = options;
+  const content = (0, _vue.ref)("");
+  const isStreaming = (0, _vue.ref)(false);
+  const error = (0, _vue.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 _messages.SystemMessage(systemMessage));
+      }
+      for (const msg of history) {
+        switch (msg.role) {
+          case "user":
+            messages.push(new _messages.HumanMessage(msg.content));
+            break;
+          case "assistant":
+            messages.push(new _messages.AIMessage(msg.content));
+            break;
+          case "system":
+            messages.push(new _messages.SystemMessage(msg.content));
+            break;
+        }
+      }
+      messages.push(new _messages.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;
+  };
+  (0, _vue.onUnmounted)(() => {
+    stop();
+  });
+  return {
+    content,
+    isStreaming,
+    error,
+    start,
+    stop
+  };
+}
+function createLangChainChain(model, config) {
+  return {
+    /**
+     * 同步调用
+     */
+    async invoke(input) {
+      const messages = [];
+      if (config?.systemMessage) {
+        messages.push(new _messages.SystemMessage(config.systemMessage));
+      }
+      messages.push(new _messages.HumanMessage(input));
+      const response = await model.invoke(messages);
+      return response.content;
+    },
+    /**
+     * 流式调用
+     */
+    async *stream(input) {
+      const messages = [];
+      if (config?.systemMessage) {
+        messages.push(new _messages.SystemMessage(config.systemMessage));
+      }
+      messages.push(new _messages.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 _messages.SystemMessage(config.systemMessage));
+      }
+      messages.push(new _messages.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 _messages.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
+      };
+    }
+  };
+}