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

package/dist/index.js

@@ -0,0 +1,561 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AIClient: () => AIClient,
+  BaseModelProvider: () => BaseModelProvider,
+  ErrorType: () => ErrorType,
+  FinalStatus: () => FinalStatus,
+  GeneratingStatus: () => GeneratingStatus,
+  OpenAIProvider: () => OpenAIProvider,
+  STATUS: () => STATUS,
+  StreamEventType: () => StreamEventType,
+  extractTextFromResponse: () => extractTextFromResponse,
+  formatMessages: () => formatMessages,
+  useMessage: () => useMessage
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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
+var import_vue = require("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 = (0, import_vue.ref)([...initialMessages]);
+  const inputMessage = (0, import_vue.ref)("");
+  const useStream = (0, import_vue.ref)(useStreamByDefault);
+  let abortController = null;
+  const messageState = (0, import_vue.reactive)({
+    status: "init" /* INIT */,
+    errorMsg: null
+  });
+  const chat = async (abortController2) => {
+    const response = await client.chat({
+      messages: (0, import_vue.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: (0, import_vue.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
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AIClient,
+  BaseModelProvider,
+  ErrorType,
+  FinalStatus,
+  GeneratingStatus,
+  OpenAIProvider,
+  STATUS,
+  StreamEventType,
+  extractTextFromResponse,
+  formatMessages,
+  useMessage
+});