@yh-ui/ai-sdk 0.1.21

package/dist/vue/index.mjs

@@ -0,0 +1,913 @@
+import { ref, shallowRef, computed, onUnmounted } from "vue";
+export function createStreamableValue(initialValue) {
+  const value = shallowRef(initialValue);
+  const loading = ref(true);
+  const error = shallowRef(null);
+  return { value, loading, error };
+}
+export function useStreamableValue(streamable) {
+  const isLoading = computed(() => streamable.loading.value);
+  const data = computed(() => streamable.value.value);
+  const err = computed(() => streamable.error.value);
+  return {
+    value: data,
+    loading: isLoading,
+    error: err
+  };
+}
+const globalMiddlewares = [];
+export function registerMiddleware(middleware) {
+  globalMiddlewares.push(middleware);
+  return () => {
+    const index = globalMiddlewares.indexOf(middleware);
+    if (index > -1) {
+      globalMiddlewares.splice(index, 1);
+    }
+  };
+}
+const cacheStorage = /* @__PURE__ */ new Map();
+function generateCacheKey(config) {
+  const { url, method = "POST", body, params } = config;
+  const keyData = { url, method, body, params };
+  return `yh-ai-cache-${JSON.stringify(keyData)}`;
+}
+function getCache(config, cacheConfig) {
+  if (!cacheConfig.enabled) return null;
+  const key = cacheConfig.key || generateCacheKey(config);
+  const cached = cacheStorage.get(key);
+  if (cached && cached.expiry > Date.now()) {
+    return cached.data;
+  }
+  if (cached) {
+    cacheStorage.delete(key);
+  }
+  return null;
+}
+function setCache(config, cacheConfig, data) {
+  if (!cacheConfig.enabled) return;
+  const key = cacheConfig.key || generateCacheKey(config);
+  const ttl = cacheConfig.ttl || 5 * 60 * 1e3;
+  cacheStorage.set(key, {
+    data,
+    expiry: Date.now() + ttl
+  });
+}
+export function clearCache() {
+  const now = Date.now();
+  for (const [key, value] of cacheStorage.entries()) {
+    if (value.expiry < now) {
+      cacheStorage.delete(key);
+    }
+  }
+}
+export async function XRequest(config, callbacks, options) {
+  const { middlewares = [], cache = {}, retry = {} } = options || {};
+  const allMiddlewares = [...globalMiddlewares, ...middlewares];
+  const mergedCallbacks = {
+    onStart: callbacks?.onStart,
+    onResponse: callbacks?.onResponse,
+    onChunk: callbacks?.onChunk,
+    onFinish: callbacks?.onFinish,
+    onError: callbacks?.onError,
+    onFinally: callbacks?.onFinally
+  };
+  let finalConfig = { ...config };
+  for (const mw of allMiddlewares) {
+    if (mw.onRequest) {
+      finalConfig = await mw.onRequest(finalConfig);
+    }
+  }
+  mergedCallbacks.onStart?.(finalConfig);
+  if (!finalConfig.stream && cache.enabled) {
+    const cachedData = getCache(finalConfig, cache);
+    if (cachedData) {
+      mergedCallbacks.onFinish?.(cachedData, cachedData);
+      mergedCallbacks.onFinally?.();
+      return cachedData;
+    }
+  }
+  let url = finalConfig.url;
+  if (finalConfig.params) {
+    const searchParams = new URLSearchParams(finalConfig.params);
+    url += `?${searchParams.toString()}`;
+  }
+  const maxRetries = retry.enabled === true ? retry.maxRetries || 3 : 0;
+  const retryDelay = retry.retryDelay || 1e3;
+  const retryCondition = retry.retryCondition || ((error) => {
+    const msg = error.message.toLowerCase();
+    return msg.includes("fetch") || msg.includes("network");
+  });
+  let lastError = null;
+  let attempt = 0;
+  while (true) {
+    try {
+      attempt++;
+      const response = await fetch(url, {
+        method: finalConfig.method || "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...finalConfig.headers
+        },
+        body: finalConfig.body ? JSON.stringify(finalConfig.body) : void 0,
+        signal: finalConfig.timeout ? AbortSignal.timeout(finalConfig.timeout) : void 0
+      });
+      mergedCallbacks.onResponse?.(response);
+      if (finalConfig.stream && response.body) {
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let fullContent = "";
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          const chunk = decoder.decode(value, { stream: true });
+          let processedChunk = chunk;
+          for (const mw of allMiddlewares) {
+            if (mw.onChunk) {
+              processedChunk = mw.onChunk(processedChunk, finalConfig);
+            }
+          }
+          fullContent += processedChunk;
+          mergedCallbacks.onChunk?.(processedChunk, { done: false });
+        }
+        mergedCallbacks.onFinish?.(fullContent, { done: true });
+        if (cache.enabled) {
+          setCache(finalConfig, cache, fullContent);
+        }
+        mergedCallbacks.onFinally?.();
+        return fullContent;
+      }
+      const data = await response.json();
+      let processedData = data;
+      for (const mw of allMiddlewares) {
+        if (mw.onResponse) {
+          processedData = mw.onResponse(processedData, finalConfig);
+        }
+      }
+      if (cache.enabled) {
+        setCache(finalConfig, cache, processedData);
+      }
+      mergedCallbacks.onFinish?.(processedData, processedData);
+      mergedCallbacks.onFinally?.();
+      return processedData;
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (attempt <= maxRetries && retryCondition(lastError)) {
+        await new Promise((resolve) => setTimeout(resolve, retryDelay * attempt));
+        continue;
+      }
+      for (const mw of allMiddlewares) {
+        if (mw.onError) {
+          lastError = mw.onError(lastError, finalConfig);
+        }
+      }
+      mergedCallbacks.onError?.(lastError);
+      mergedCallbacks.onFinally?.();
+      throw lastError;
+    }
+  }
+  mergedCallbacks.onFinally?.();
+  throw lastError;
+}
+export function createXRequest(defaultConfig = {}, defaultOptions) {
+  return (config, callbacks) => {
+    return XRequest({ ...defaultConfig, ...config }, callbacks, defaultOptions);
+  };
+}
+export function useConversation(config = {}) {
+  const { maxHistory = 50, persist = false, storageKey = "yh-ai-conversation" } = config;
+  const messages = ref([]);
+  const loadHistory = () => {
+    if (persist) {
+      const stored = localStorage.getItem(storageKey);
+      if (stored) {
+        try {
+          messages.value = JSON.parse(stored);
+        } catch {
+          messages.value = [];
+        }
+      }
+    }
+  };
+  const saveHistory = () => {
+    if (persist) {
+      localStorage.setItem(storageKey, JSON.stringify(messages.value));
+    }
+  };
+  const addMessage = (message) => {
+    const newMessage = {
+      ...message,
+      id: `msg-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    messages.value = [...messages.value, newMessage].slice(-maxHistory);
+    saveHistory();
+    return newMessage;
+  };
+  const clearHistory = () => {
+    messages.value = [];
+    if (persist) {
+      localStorage.removeItem(storageKey);
+    }
+  };
+  loadHistory();
+  return {
+    messages,
+    addMessage,
+    clearHistory,
+    loadHistory,
+    saveHistory
+  };
+}
+function generateId() {
+  return `conv-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+}
+function generateTitle(messages) {
+  const firstUserMessage = messages.find((m) => m.role === "user");
+  if (firstUserMessage) {
+    const content = firstUserMessage.content;
+    return content.length > 30 ? content.slice(0, 30) + "..." : content;
+  }
+  return "\u65B0\u4F1A\u8BDD";
+}
+export function useConversations(options = {}) {
+  const {
+    maxConversations = 50,
+    persist = false,
+    storageKey = "yh-ai-conversations",
+    autoTitle = true
+  } = options;
+  const conversations = ref([]);
+  const currentId = ref(null);
+  const currentConversation = computed(() => {
+    return conversations.value.find((c) => c.id === currentId.value) || null;
+  });
+  const currentMessages = computed(() => {
+    return currentConversation.value?.messages || [];
+  });
+  const loadConversations = () => {
+    if (persist) {
+      try {
+        const stored = localStorage.getItem(storageKey);
+        if (stored) {
+          const parsed = JSON.parse(stored);
+          conversations.value = parsed.conversations || [];
+          currentId.value = parsed.currentId || null;
+          if (currentId.value && !conversations.value.find((c) => c.id === currentId.value)) {
+            currentId.value = conversations.value[0]?.id || null;
+          }
+        }
+      } catch {
+        conversations.value = [];
+        currentId.value = null;
+      }
+    }
+  };
+  const saveConversations = () => {
+    if (persist) {
+      localStorage.setItem(
+        storageKey,
+        JSON.stringify({
+          conversations: conversations.value,
+          currentId: currentId.value
+        })
+      );
+    }
+  };
+  const create = (initialMessages = []) => {
+    const now = /* @__PURE__ */ new Date();
+    const newConversation = {
+      id: generateId(),
+      title: autoTitle ? generateTitle(initialMessages) : "\u65B0\u4F1A\u8BDD",
+      messages: initialMessages,
+      createdAt: now,
+      updatedAt: now
+    };
+    conversations.value = [newConversation, ...conversations.value].slice(0, maxConversations);
+    currentId.value = newConversation.id;
+    saveConversations();
+    return newConversation.id;
+  };
+  const remove = (id) => {
+    const index = conversations.value.findIndex((c) => c.id === id);
+    if (index === -1) return;
+    conversations.value = conversations.value.filter((c) => c.id !== id);
+    if (currentId.value === id) {
+      currentId.value = conversations.value[0]?.id || null;
+    }
+    saveConversations();
+  };
+  const select = (id) => {
+    if (conversations.value.find((c) => c.id === id)) {
+      currentId.value = id;
+      saveConversations();
+    }
+  };
+  const updateTitle = (id, title) => {
+    const conversation = conversations.value.find((c) => c.id === id);
+    if (conversation) {
+      conversation.title = title;
+      conversation.updatedAt = /* @__PURE__ */ new Date();
+      saveConversations();
+    }
+  };
+  const addMessage = (message) => {
+    if (!currentId.value) {
+      create();
+    }
+    const conversation = conversations.value.find((c) => c.id === currentId.value);
+    if (conversation) {
+      const newMessage = {
+        ...message,
+        id: `msg-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+        createdAt: /* @__PURE__ */ new Date()
+      };
+      conversation.messages.push(newMessage);
+      if (autoTitle && conversation.messages.length <= 2) {
+        conversation.title = generateTitle(conversation.messages);
+      }
+      conversation.updatedAt = /* @__PURE__ */ new Date();
+      saveConversations();
+      return newMessage;
+    }
+    return null;
+  };
+  const clearCurrent = () => {
+    const conversation = conversations.value.find((c) => c.id === currentId.value);
+    if (conversation) {
+      conversation.messages = [];
+      conversation.updatedAt = /* @__PURE__ */ new Date();
+      saveConversations();
+    }
+  };
+  loadConversations();
+  if (conversations.value.length === 0) {
+    create();
+  }
+  return {
+    conversations,
+    currentId,
+    currentConversation,
+    currentMessages,
+    create,
+    remove,
+    select,
+    updateTitle,
+    addMessage,
+    clearCurrent
+  };
+}
+export function useAIChat(options) {
+  const {
+    api,
+    initialMessages = [],
+    headers = {},
+    body = {},
+    stream = false,
+    streamInterval = 20,
+    tools = [],
+    onRequest,
+    onResponse,
+    onChunk,
+    onToolCall,
+    onToolResult,
+    onFinish,
+    onError
+  } = options;
+  const messages = ref([...initialMessages]);
+  const input = ref("");
+  const isLoading = ref(false);
+  const isStreaming = ref(false);
+  const error = ref(null);
+  const currentMessage = ref(null);
+  let abortController = null;
+  const append = (content, role = "user") => {
+    const newMessage = {
+      id: `msg-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      role,
+      content,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    messages.value = [...messages.value, newMessage];
+    return newMessage;
+  };
+  const updateLastMessage = (updates) => {
+    if (messages.value.length > 0) {
+      const lastIndex = messages.value.length - 1;
+      messages.value = messages.value.map(
+        (msg, i) => i === lastIndex ? { ...msg, ...updates } : msg
+      );
+    }
+  };
+  const reload = () => {
+    messages.value = [...initialMessages];
+    input.value = "";
+    error.value = null;
+    currentMessage.value = null;
+    if (abortController) {
+      abortController.abort();
+      abortController = null;
+    }
+  };
+  const stop = () => {
+    if (abortController) {
+      abortController.abort();
+      abortController = null;
+    }
+    isStreaming.value = false;
+  };
+  const executeTools = async (toolCalls) => {
+    const results = [];
+    for (const toolCall of toolCalls) {
+      const tool = tools.find((t) => t.name === toolCall.name);
+      if (tool) {
+        try {
+          onToolCall?.({ name: toolCall.name, args: toolCall.arguments });
+          const result = await tool.execute(toolCall.arguments);
+          onToolResult?.(toolCall.name, result);
+          results.push({
+            id: `tool-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+            role: "tool",
+            content: typeof result === "string" ? result : JSON.stringify(result),
+            name: toolCall.name,
+            toolCallId: toolCall.id,
+            createdAt: /* @__PURE__ */ new Date()
+          });
+        } catch (err) {
+          results.push({
+            id: `tool-error-${Date.now()}`,
+            role: "tool",
+            content: `Error: ${err instanceof Error ? err.message : String(err)}`,
+            name: toolCall.name,
+            toolCallId: toolCall.id,
+            createdAt: /* @__PURE__ */ new Date()
+          });
+        }
+      }
+    }
+    return results;
+  };
+  const sendMessageStream = async (content) => {
+    if (!content.trim() || isStreaming.value) return;
+    error.value = null;
+    isStreaming.value = true;
+    isLoading.value = true;
+    append(content, "user");
+    input.value = "";
+    const assistantMessage = append("", "assistant");
+    currentMessage.value = assistantMessage;
+    abortController = new AbortController();
+    try {
+      onRequest?.(content);
+      const allMessages = messages.value.map((m) => ({
+        role: m.role,
+        content: m.content,
+        ...m.name && { name: m.name },
+        ...m.toolCallId && { tool_call_id: m.toolCallId }
+      }));
+      const response = await fetch(api, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...headers
+        },
+        body: JSON.stringify({
+          messages: allMessages,
+          stream: true,
+          tools: tools.length > 0 ? tools.map((t) => ({
+            type: "function",
+            function: {
+              name: t.name,
+              description: t.description || "",
+              parameters: t.parameters || {}
+            }
+          })) : void 0,
+          ...body
+        }),
+        signal: abortController.signal
+      });
+      onResponse?.(response);
+      if (!response.ok || !response.body) {
+        throw new Error(`API Error: ${response.status} ${response.statusText}`);
+      }
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let fullContent = "";
+      let currentToolCalls = [];
+      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]") {
+              continue;
+            }
+            try {
+              const parsed = JSON.parse(data);
+              if (parsed.choices?.[0]?.delta?.content) {
+                const delta = parsed.choices[0].delta.content;
+                fullContent += delta;
+                currentMessage.value = { ...assistantMessage, content: fullContent };
+                updateLastMessage({ content: fullContent });
+                onChunk?.(delta, currentMessage.value);
+              }
+              if (parsed.choices?.[0]?.delta?.tool_calls) {
+                const toolCalls = parsed.choices[0].delta.tool_calls;
+                for (const tc of toolCalls) {
+                  const existingIndex = currentToolCalls.findIndex((t) => t.id === tc.id);
+                  if (existingIndex >= 0) {
+                    currentToolCalls[existingIndex] = {
+                      ...currentToolCalls[existingIndex],
+                      arguments: {
+                        ...currentToolCalls[existingIndex].arguments,
+                        ...tc.function?.arguments && JSON.parse(tc.function.arguments)
+                      }
+                    };
+                  } else if (tc.id && tc.function?.name) {
+                    currentToolCalls.push({
+                      id: tc.id,
+                      type: "function",
+                      name: tc.function.name,
+                      arguments: tc.function.arguments ? JSON.parse(tc.function.arguments) : {}
+                    });
+                  }
+                }
+                updateLastMessage({ toolCalls: [...currentToolCalls] });
+              }
+            } catch {
+            }
+          }
+        }
+        if (streamInterval > 0) {
+          await new Promise((resolve) => setTimeout(resolve, streamInterval));
+        }
+      }
+      if (currentToolCalls.length > 0) {
+        updateLastMessage({ toolCalls: currentToolCalls });
+        const toolResults = await executeTools(currentToolCalls);
+        for (const result of toolResults) {
+          messages.value.push(result);
+        }
+        const finalMessages = messages.value.map((m) => ({
+          role: m.role,
+          content: m.content,
+          ...m.name && { name: m.name },
+          ...m.toolCallId && { tool_call_id: m.toolCallId }
+        }));
+        const finalResponse = await fetch(api, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...headers
+          },
+          body: JSON.stringify({
+            messages: finalMessages,
+            ...body
+          })
+        });
+        if (finalResponse.ok) {
+          const finalData = await finalResponse.json();
+          const finalContent = finalData.content || finalData.message?.content || "";
+          updateLastMessage({ content: finalContent });
+          currentMessage.value = { ...assistantMessage, content: finalContent };
+        }
+      }
+      const finalMessage = messages.value[messages.value.length - 1];
+      onFinish?.(finalMessage);
+    } catch (err) {
+      if (err.name !== "AbortError") {
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        error.value = errorObj;
+        onError?.(errorObj);
+      }
+    } finally {
+      isLoading.value = false;
+      isStreaming.value = false;
+      abortController = null;
+    }
+  };
+  const sendMessage = async (content) => {
+    if (stream) {
+      return sendMessageStream(content);
+    }
+    if (!content.trim() || isLoading.value) return;
+    error.value = null;
+    isLoading.value = true;
+    append(content, "user");
+    input.value = "";
+    try {
+      onRequest?.(content);
+      const allMessages = messages.value.map((m) => ({
+        role: m.role,
+        content: m.content,
+        ...m.name && { name: m.name },
+        ...m.toolCallId && { tool_call_id: m.toolCallId }
+      }));
+      const response = await fetch(api, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...headers
+        },
+        body: JSON.stringify({
+          messages: allMessages,
+          tools: tools.length > 0 ? tools.map((t) => ({
+            type: "function",
+            function: {
+              name: t.name,
+              description: t.description || "",
+              parameters: t.parameters || {}
+            }
+          })) : void 0,
+          ...body
+        })
+      });
+      onResponse?.(response);
+      if (!response.ok) {
+        throw new Error(`API Error: ${response.status} ${response.statusText}`);
+      }
+      const data = await response.json();
+      let toolCalls = data.tool_calls || [];
+      let finalContent = data.content || data.message?.content || "";
+      if (toolCalls.length > 0) {
+        const toolResults = await executeTools(toolCalls);
+        for (const result of toolResults) {
+          messages.value.push(result);
+        }
+        const finalMessages = messages.value.map((m) => ({
+          role: m.role,
+          content: m.content,
+          ...m.name && { name: m.name },
+          ...m.toolCallId && { tool_call_id: m.toolCallId }
+        }));
+        const finalResponse = await fetch(api, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...headers
+          },
+          body: JSON.stringify({
+            messages: finalMessages,
+            ...body
+          })
+        });
+        if (finalResponse.ok) {
+          const finalData = await finalResponse.json();
+          finalContent = finalData.content || finalData.message?.content || "";
+        }
+      }
+      const assistantMessage = append(finalContent, "assistant");
+      if (toolCalls.length > 0) {
+        updateLastMessage({ toolCalls });
+      }
+      onFinish?.(assistantMessage);
+    } catch (err) {
+      const errorObj = err instanceof Error ? err : new Error(String(err));
+      error.value = errorObj;
+      onError?.(errorObj);
+    } finally {
+      isLoading.value = false;
+    }
+  };
+  return {
+    messages,
+    input,
+    isLoading,
+    isStreaming,
+    error,
+    currentMessage,
+    sendMessage,
+    sendMessageStream,
+    stop,
+    append,
+    updateLastMessage,
+    reload
+  };
+}
+export function useAIStream(options) {
+  const { api, initialContent = "", onChunk, onFinish, onError } = options;
+  const content = shallowRef(initialContent);
+  const isStreaming = ref(false);
+  const error = ref(null);
+  let abortController = null;
+  const start = async (prompt) => {
+    if (isStreaming.value) {
+      stop();
+    }
+    error.value = null;
+    isStreaming.value = true;
+    content.value = "";
+    abortController = new AbortController();
+    try {
+      const response = await fetch(api, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ prompt }),
+        signal: abortController.signal
+      });
+      if (!response.ok || !response.body) {
+        throw new Error(`Stream 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 });
+        content.value += chunk;
+        onChunk?.(chunk);
+      }
+      onFinish?.(content.value);
+    } catch (err) {
+      if (err.name !== "AbortError") {
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        error.value = errorObj;
+        onError?.(errorObj);
+      }
+    } finally {
+      isStreaming.value = false;
+      abortController = null;
+    }
+  };
+  const stop = () => {
+    if (abortController) {
+      abortController.abort();
+      isStreaming.value = false;
+    }
+  };
+  onUnmounted(() => {
+    stop();
+  });
+  return {
+    content,
+    isStreaming,
+    error,
+    start,
+    stop
+  };
+}
+export function createYHFunctionTool(tool) {
+  return {
+    type: "function",
+    name: tool.name,
+    description: tool.description || "",
+    parameters: tool.parameters || {},
+    execute: tool.execute
+  };
+}
+export const PROVIDER_PRESETS = {
+  openai: {
+    name: "openai",
+    baseUrl: "https://api.openai.com/v1",
+    defaultModel: "gpt-4",
+    supportsStreaming: true,
+    supportsFunctionCalling: true
+  },
+  anthropic: {
+    name: "anthropic",
+    baseUrl: "https://api.anthropic.com/v1",
+    defaultModel: "claude-3-5-sonnet-20241022",
+    supportsStreaming: true,
+    supportsFunctionCalling: true
+  },
+  google: {
+    name: "google",
+    baseUrl: "https://generativelanguage.googleapis.com/v1",
+    defaultModel: "gemini-1.5-pro",
+    supportsStreaming: true,
+    supportsFunctionCalling: true
+  },
+  deepseek: {
+    name: "deepseek",
+    baseUrl: "https://api.deepseek.com/v1",
+    defaultModel: "deepseek-chat",
+    supportsStreaming: true,
+    supportsFunctionCalling: true
+  },
+  ollama: {
+    name: "ollama",
+    baseUrl: "http://localhost:11434/v1",
+    defaultModel: "llama2",
+    supportsStreaming: true,
+    supportsFunctionCalling: false
+  },
+  azure: {
+    name: "azure",
+    baseUrl: "",
+    // 需要配置
+    defaultModel: "",
+    supportsStreaming: true,
+    supportsFunctionCalling: true,
+    needsProjectId: true
+  },
+  moonshot: {
+    name: "moonshot",
+    baseUrl: "https://api.moonshot.cn/v1",
+    defaultModel: "moonshot-v1-8k",
+    supportsStreaming: true,
+    supportsFunctionCalling: true
+  },
+  minimax: {
+    name: "minimax",
+    baseUrl: "https://api.minimax.chat/v1",
+    defaultModel: "abab6.5s-chat",
+    supportsStreaming: true,
+    supportsFunctionCalling: true
+  },
+  zhipu: {
+    name: "zhipu",
+    baseUrl: "https://open.bigmodel.cn/api/paas/v4",
+    defaultModel: "glm-4",
+    supportsStreaming: true,
+    supportsFunctionCalling: true
+  },
+  siliconflow: {
+    name: "siliconflow",
+    baseUrl: "https://api.siliconflow.cn/v1",
+    defaultModel: "Qwen/Qwen2-7B-Instruct",
+    supportsStreaming: true,
+    supportsFunctionCalling: true
+  },
+  together: {
+    name: "together",
+    baseUrl: "https://api.together.ai/v1",
+    defaultModel: "meta-llama/Llama-3-70b-chat-hf",
+    supportsStreaming: true,
+    supportsFunctionCalling: true
+  },
+  novita: {
+    name: "novita",
+    baseUrl: "https://api.novita.ai/v3",
+    defaultModel: "meta-llama/llama-3.1-70b-instruct",
+    supportsStreaming: true,
+    supportsFunctionCalling: true
+  }
+};
+export function getProviderPreset(name) {
+  return PROVIDER_PRESETS[name.toLowerCase()];
+}
+export function createProviderAdapter(config) {
+  let finalConfig;
+  if ("provider" in config && !("baseUrl" in config)) {
+    const preset = PROVIDER_PRESETS[config.provider.toLowerCase()];
+    if (!preset) {
+      throw new Error(`Unknown provider: ${config.provider}`);
+    }
+    finalConfig = {
+      name: preset.name,
+      baseUrl: preset.baseUrl,
+      defaultModel: preset.defaultModel,
+      apiKey: config.apiKey
+    };
+  } else {
+    finalConfig = config;
+  }
+  return {
+    ...finalConfig,
+    createChat: (model) => {
+      const modelConfig = typeof model === "string" ? { model } : model || {};
+      return {
+        provider: finalConfig.name,
+        baseUrl: finalConfig.baseUrl,
+        apiKey: finalConfig.apiKey,
+        ...modelConfig
+      };
+    }
+  };
+}
+export function createVercelAIProvider(provider, config) {
+  return {
+    languageModel: (modelId) => {
+      return {
+        provider,
+        modelId,
+        config
+      };
+    }
+  };
+}
+const AIContextKey = Symbol("yh-ai-context");
+export function createAIContext(initialProvider, initialModel) {
+  const sessionId = ref(null);
+  const provider = ref(initialProvider || null);
+  const modelConfig = ref({ model: initialModel || "gpt-4" });
+  return {
+    sessionId,
+    provider,
+    modelConfig,
+    setSession: (id) => {
+      sessionId.value = id;
+    },
+    setProvider: (p) => {
+      provider.value = p;
+    },
+    setModel: (config) => {
+      modelConfig.value = config;
+    }
+  };
+}
+export { AIContextKey };