@opentiny/tiny-robot-kit 0.2.0-alpha.0

package/dist/index.mjs

@@ -0,0 +1,524 @@
+// src/providers/base.ts
+var BaseModelProvider = class {
+  /**
+   * @param config AI模型配置
+   */
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * 更新配置
+   * @param config 新的AI模型配置
+   */
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  /**
+   * 获取当前配置
+   * @returns AI模型配置
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * 验证请求参数
+   * @param request 聊天请求参数
+   */
+  validateRequest(request) {
+    if (!request.messages || !Array.isArray(request.messages) || request.messages.length === 0) {
+      throw new Error("\u8BF7\u6C42\u5FC5\u987B\u5305\u542B\u81F3\u5C11\u4E00\u6761\u6D88\u606F");
+    }
+    for (const message of request.messages) {
+      if (!message.role || !message.content) {
+        throw new Error("\u6BCF\u6761\u6D88\u606F\u5FC5\u987B\u5305\u542B\u89D2\u8272\u548C\u5185\u5BB9");
+      }
+    }
+  }
+};
+
+// src/types.ts
+var ErrorType = /* @__PURE__ */ ((ErrorType2) => {
+  ErrorType2["NETWORK_ERROR"] = "network_error";
+  ErrorType2["AUTHENTICATION_ERROR"] = "authentication_error";
+  ErrorType2["RATE_LIMIT_ERROR"] = "rate_limit_error";
+  ErrorType2["SERVER_ERROR"] = "server_error";
+  ErrorType2["MODEL_ERROR"] = "model_error";
+  ErrorType2["TIMEOUT_ERROR"] = "timeout_error";
+  ErrorType2["UNKNOWN_ERROR"] = "unknown_error";
+  return ErrorType2;
+})(ErrorType || {});
+var StreamEventType = /* @__PURE__ */ ((StreamEventType2) => {
+  StreamEventType2["DATA"] = "data";
+  StreamEventType2["ERROR"] = "error";
+  StreamEventType2["DONE"] = "done";
+  return StreamEventType2;
+})(StreamEventType || {});
+
+// src/error.ts
+function createError(error) {
+  return {
+    type: error.type || "unknown_error" /* UNKNOWN_ERROR */,
+    message: error.message || "\u672A\u77E5\u9519\u8BEF",
+    statusCode: error.statusCode,
+    originalError: error.originalError
+  };
+}
+function handleRequestError(error) {
+  if (!error.response) {
+    return createError({
+      type: "network_error" /* NETWORK_ERROR */,
+      message: "\u7F51\u7EDC\u8FDE\u63A5\u9519\u8BEF\uFF0C\u8BF7\u68C0\u67E5\u60A8\u7684\u7F51\u7EDC\u8FDE\u63A5",
+      originalError: error
+    });
+  }
+  if (error.response) {
+    const { status, data } = error.response;
+    if (status === 401 || status === 403) {
+      return createError({
+        type: "authentication_error" /* AUTHENTICATION_ERROR */,
+        message: "\u8EAB\u4EFD\u9A8C\u8BC1\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u60A8\u7684API\u5BC6\u94A5",
+        statusCode: status,
+        originalError: error
+      });
+    }
+    if (status === 429) {
+      return createError({
+        type: "rate_limit_error" /* RATE_LIMIT_ERROR */,
+        message: "\u8D85\u51FAAPI\u8C03\u7528\u9650\u5236\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5",
+        statusCode: status,
+        originalError: error
+      });
+    }
+    if (status >= 500) {
+      return createError({
+        type: "server_error" /* SERVER_ERROR */,
+        message: "\u670D\u52A1\u5668\u9519\u8BEF\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5",
+        statusCode: status,
+        originalError: error
+      });
+    }
+    return createError({
+      type: "unknown_error" /* UNKNOWN_ERROR */,
+      message: data?.error?.message || `\u8BF7\u6C42\u5931\u8D25\uFF0C\u72B6\u6001\u7801: ${status}`,
+      statusCode: status,
+      originalError: error
+    });
+  }
+  if (error.code === "ECONNABORTED") {
+    return createError({
+      type: "timeout_error" /* TIMEOUT_ERROR */,
+      message: "\u8BF7\u6C42\u8D85\u65F6\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5",
+      originalError: error
+    });
+  }
+  return createError({
+    type: "unknown_error" /* UNKNOWN_ERROR */,
+    message: error.message || "\u53D1\u751F\u672A\u77E5\u9519\u8BEF",
+    originalError: error
+  });
+}
+
+// src/utils.ts
+async function handleSSEStream(response, handler, signal) {
+  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;
+      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 {
+          const dataMatch = line.match(/^data: (.+)$/m);
+          if (!dataMatch) continue;
+          const data = JSON.parse(dataMatch[1]);
+          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;
+  }
+}
+function formatMessages(messages) {
+  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)
+    };
+  });
+}
+function extractTextFromResponse(response) {
+  if (!response.choices || !response.choices.length) {
+    return "";
+  }
+  return response.choices[0].message?.content || "";
+}
+
+// src/providers/openai.ts
+var OpenAIProvider = class extends BaseModelProvider {
+  /**
+   * @param config AI模型配置
+   */
+  constructor(config) {
+    super(config);
+    this.defaultModel = "gpt-3.5-turbo";
+    this.baseURL = config.apiUrl || "https://api.openai.com/v1";
+    this.apiKey = config.apiKey || "";
+    if (config.defaultModel) {
+      this.defaultModel = config.defaultModel;
+    }
+    if (!this.apiKey) {
+      console.warn("API key is not provided. Authentication will likely fail.");
+    }
+  }
+  /**
+   * 发送聊天请求并获取响应
+   * @param request 聊天请求参数
+   * @returns 聊天响应
+   */
+  async chat(request) {
+    try {
+      this.validateRequest(request);
+      const requestData = {
+        model: request.options?.model || this.config.defaultModel || this.defaultModel,
+        messages: request.messages,
+        ...request.options,
+        stream: false
+      };
+      const response = await fetch(`${this.baseURL}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify(requestData)
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`HTTP error! status: ${response.status}, details: ${errorText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      throw handleRequestError(error);
+    }
+  }
+  /**
+   * 发送流式聊天请求并通过处理器处理响应
+   * @param request 聊天请求参数
+   * @param handler 流式响应处理器
+   */
+  async chatStream(request, handler) {
+    const { signal, ...options } = request.options || {};
+    try {
+      this.validateRequest(request);
+      const requestData = {
+        model: request.options?.model || this.config.defaultModel || this.defaultModel,
+        messages: request.messages,
+        ...options,
+        stream: true
+      };
+      const response = await fetch(`${this.baseURL}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`,
+          Accept: "text/event-stream"
+        },
+        body: JSON.stringify(requestData),
+        signal
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`HTTP error! status: ${response.status}, details: ${errorText}`);
+      }
+      await handleSSEStream(response, handler, signal);
+    } catch (error) {
+      if (signal?.aborted) return;
+      handler.onError(handleRequestError(error));
+    }
+  }
+  /**
+   * 更新配置
+   * @param config 新的AI模型配置
+   */
+  updateConfig(config) {
+    super.updateConfig(config);
+    if (config.apiUrl) {
+      this.baseURL = config.apiUrl;
+    }
+    if (config.apiKey) {
+      this.apiKey = config.apiKey;
+    }
+    if (config.defaultModel) {
+      this.defaultModel = config.defaultModel;
+    }
+  }
+};
+
+// src/client.ts
+var AIClient = class {
+  /**
+   * 构造函数
+   * @param config AI模型配置
+   */
+  constructor(config) {
+    this.config = config;
+    this.provider = this.createProvider(config);
+  }
+  /**
+   * 创建提供商实例
+   * @param config AI模型配置
+   * @returns 提供商实例
+   */
+  createProvider(config) {
+    if (config.provider === "custom" && "providerImplementation" in config) {
+      return config.providerImplementation;
+    }
+    switch (config.provider) {
+      case "deepseek":
+        const defaultConfig = {
+          defaultModel: "deepseek-chat",
+          apiUrl: "https://api.deepseek.com/v1"
+        };
+        return new OpenAIProvider({ ...defaultConfig, ...config });
+      case "openai":
+      default:
+        return new OpenAIProvider(config);
+    }
+  }
+  /**
+   * 发送聊天请求并获取响应
+   * @param request 聊天请求参数
+   * @returns 聊天响应
+   */
+  async chat(request) {
+    return this.provider.chat(request);
+  }
+  /**
+   * 发送流式聊天请求并通过处理器处理响应
+   * @param request 聊天请求参数
+   * @param handler 流式响应处理器
+   */
+  async chatStream(request, handler) {
+    const streamRequest = {
+      ...request,
+      options: {
+        ...request.options,
+        stream: true
+      }
+    };
+    return this.provider.chatStream(streamRequest, handler);
+  }
+  /**
+   * 获取当前配置
+   * @returns AI模型配置
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * 更新配置
+   * @param config 新的AI模型配置
+   */
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+    if (config.provider && config.provider !== this.config.provider) {
+      this.provider = this.createProvider(this.config);
+    } else {
+      this.provider.updateConfig(this.config);
+    }
+  }
+};
+
+// src/vue/useMessage.ts
+import { reactive, ref, toRaw } from "vue";
+var STATUS = /* @__PURE__ */ ((STATUS2) => {
+  STATUS2["INIT"] = "init";
+  STATUS2["PROCESSING"] = "processing";
+  STATUS2["STREAMING"] = "streaming";
+  STATUS2["FINISHED"] = "finished";
+  STATUS2["ABORTED"] = "aborted";
+  STATUS2["ERROR"] = "error";
+  return STATUS2;
+})(STATUS || {});
+var GeneratingStatus = ["processing" /* PROCESSING */, "streaming" /* STREAMING */];
+var FinalStatus = ["finished" /* FINISHED */, "aborted" /* ABORTED */, "error" /* ERROR */];
+function useMessage(options) {
+  const { client, useStreamByDefault = true, errorMessage = "\u8BF7\u6C42\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5", initialMessages = [] } = options;
+  const messages = ref([...initialMessages]);
+  const inputMessage = ref("");
+  const useStream = ref(useStreamByDefault);
+  let abortController = null;
+  const messageState = reactive({
+    status: "init" /* INIT */,
+    errorMsg: null
+  });
+  const chat = async (abortController2) => {
+    const response = await client.chat({
+      messages: toRaw(messages.value),
+      options: {
+        stream: false,
+        signal: abortController2.signal
+      }
+    });
+    const assistantMessage = {
+      role: "assistant",
+      content: response.choices[0].message.content
+    };
+    messages.value.push(assistantMessage);
+  };
+  const streamChat = async (abortController2) => {
+    await client.chatStream(
+      {
+        messages: toRaw(messages.value),
+        options: {
+          stream: true,
+          signal: abortController2.signal
+        }
+      },
+      {
+        onData: (data) => {
+          messageState.status = "streaming" /* 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 = "error" /* ERROR */;
+          messageState.errorMsg = errorMessage;
+          console.error("Stream request error:", error);
+        },
+        onDone: () => {
+          messageState.status = "finished" /* FINISHED */;
+        }
+      }
+    );
+  };
+  const chatRequest = async () => {
+    messageState.status = "processing" /* PROCESSING */;
+    messageState.errorMsg = null;
+    abortController = new AbortController();
+    try {
+      if (useStream.value) {
+        await streamChat(abortController);
+      } else {
+        await chat(abortController);
+      }
+      messageState.status = "finished" /* FINISHED */;
+    } catch (error) {
+      messageState.errorMsg = errorMessage;
+      messageState.status = "error" /* ERROR */;
+      console.error("Send message error:", error);
+    } finally {
+      abortController = null;
+    }
+  };
+  const sendMessage = async (content = inputMessage.value, clearInput = true) => {
+    if (!content?.trim() || GeneratingStatus.includes(messageState.status)) {
+      return;
+    }
+    const userMessage = {
+      role: "user",
+      content
+    };
+    messages.value.push(userMessage);
+    if (clearInput) {
+      inputMessage.value = "";
+    }
+    await chatRequest();
+  };
+  const abortRequest = () => {
+    if (abortController) {
+      abortController.abort();
+      abortController = null;
+      messageState.status = "aborted" /* ABORTED */;
+    }
+  };
+  const retryRequest = async (msgIndex) => {
+    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) => {
+    messages.value.push(message);
+  };
+  return {
+    messages,
+    messageState,
+    inputMessage,
+    useStream,
+    sendMessage,
+    clearMessages,
+    addMessage,
+    abortRequest,
+    retryRequest
+  };
+}
+export {
+  AIClient,
+  BaseModelProvider,
+  ErrorType,
+  FinalStatus,
+  GeneratingStatus,
+  OpenAIProvider,
+  STATUS,
+  StreamEventType,
+  extractTextFromResponse,
+  formatMessages,
+  useMessage
+};

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@opentiny/tiny-robot-kit",
+  "version": "0.2.0-alpha.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "AI大模型请求与数据处理工具包",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch"
+  },
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^22.13.17",
+    "tsup": "^8.0.1",
+    "typescript": "^5.8.2"
+  },
+  "peerDependencies": {
+    "vue": ">=3.0.0"
+  },
+  "gitHead": "3517724651afbbb05b1be20487a9f3341c06133c"
+}

package/src/client.ts

@@ -0,0 +1,101 @@
+/**
+ * AI客户端类
+ * 负责根据配置选择合适的提供商并处理请求
+ */
+
+import type { AIModelConfig, ChatCompletionRequest, ChatCompletionResponse, StreamHandler } from './types'
+import type { BaseModelProvider } from './providers/base'
+import { OpenAIProvider } from './providers/openai'
+
+/**
+ * AI客户端类
+ */
+export class AIClient {
+  private provider: BaseModelProvider
+  private config: AIModelConfig
+
+  /**
+   * 构造函数
+   * @param config AI模型配置
+   */
+  constructor(config: AIModelConfig) {
+    this.config = config
+    this.provider = this.createProvider(config)
+  }
+
+  /**
+   * 创建提供商实例
+   * @param config AI模型配置
+   * @returns 提供商实例
+   */
+  private createProvider(config: AIModelConfig): BaseModelProvider {
+    // 如果提供了自定义提供商实现，直接使用
+    if (config.provider === 'custom' && 'providerImplementation' in config) {
+      return (config as { providerImplementation: BaseModelProvider }).providerImplementation
+    }
+
+    // 根据提供商类型创建对应的提供商实例
+    switch (config.provider) {
+      case 'deepseek':
+        const defaultConfig = {
+          defaultModel: 'deepseek-chat',
+          apiUrl: 'https://api.deepseek.com/v1',
+        }
+        return new OpenAIProvider({ ...defaultConfig, ...config })
+      case 'openai':
+      default:
+        return new OpenAIProvider(config)
+    }
+  }
+
+  /**
+   * 发送聊天请求并获取响应
+   * @param request 聊天请求参数
+   * @returns 聊天响应
+   */
+  async chat(request: ChatCompletionRequest): Promise<ChatCompletionResponse> {
+    return this.provider.chat(request)
+  }
+
+  /**
+   * 发送流式聊天请求并通过处理器处理响应
+   * @param request 聊天请求参数
+   * @param handler 流式响应处理器
+   */
+  async chatStream(request: ChatCompletionRequest, handler: StreamHandler): Promise<void> {
+    // 确保请求中启用了流式响应
+    const streamRequest = {
+      ...request,
+      options: {
+        ...request.options,
+        stream: true,
+      },
+    }
+
+    return this.provider.chatStream(streamRequest, handler)
+  }
+
+  /**
+   * 获取当前配置
+   * @returns AI模型配置
+   */
+  getConfig(): AIModelConfig {
+    return { ...this.config }
+  }
+
+  /**
+   * 更新配置
+   * @param config 新的AI模型配置
+   */
+  updateConfig(config: Partial<AIModelConfig>): void {
+    this.config = { ...this.config, ...config }
+
+    // 如果提供商类型发生变化，重新创建提供商实例
+    if (config.provider && config.provider !== this.config.provider) {
+      this.provider = this.createProvider(this.config)
+    } else {
+      // 否则只更新提供商配置
+      this.provider.updateConfig(this.config)
+    }
+  }
+}