@shenghuabi/openai 1.0.0

package/index.mjs

@@ -0,0 +1,1015 @@
+// packages/openai/chat/service.ts
+import { inject as inject2 } from "static-injector";
+
+// packages/openai/chat/vendor/openai.ts
+import { OpenAI } from "openai";
+
+// packages/openai/chat/message.define.ts
+import * as v from "valibot";
+var ChatCompletionContentPartStr = v.object({
+  text: v.string(),
+  type: v.optional(v.literal("text"), "text")
+});
+var ChatCompletionContentPartImage = v.object({
+  image_url: v.object({
+    url: v.string(),
+    detail: v.optional(v.picklist(["auto", "low", "high"]))
+  }),
+  type: v.optional(v.literal("image_url"), "image_url")
+});
+var ChatCompletionContentPart = v.array(
+  v.union([ChatCompletionContentPartStr, ChatCompletionContentPartImage])
+);
+var SystemChatCompletionContent = v.array(
+  ChatCompletionContentPartStr
+);
+var UserChatCompletionContent = ChatCompletionContentPart;
+var AssistantChatCompletionContent = v.array(
+  ChatCompletionContentPartStr
+);
+var SystemChatMessage = v.object({
+  role: v.optional(v.literal("system"), "system"),
+  content: SystemChatCompletionContent
+});
+var UserChatMessage = v.object({
+  role: v.optional(v.literal("user"), "user"),
+  content: UserChatCompletionContent
+});
+var AssistantChatMessage = v.object({
+  role: v.optional(v.literal("assistant"), "assistant"),
+  content: AssistantChatCompletionContent,
+  thinkContent: v.optional(v.string())
+});
+var ChatMessageItemDefine = v.union([
+  SystemChatMessage,
+  UserChatMessage,
+  AssistantChatMessage
+]);
+var ChatMessageListDefine = v.array(ChatMessageItemDefine);
+
+// packages/openai/chat/vendor/openai.ts
+import * as v2 from "valibot";
+var OpenAIChat = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  instance;
+  extraBody = {};
+  extraHeaders = {};
+  init() {
+    this.instance = new OpenAI({
+      apiKey: this.options.apiKey || " ",
+      baseURL: this.options.baseURL ?? void 0
+    });
+  }
+  async #createStream(input, options) {
+    return await this.instance.chat.completions.create(input, { headers: this.extraHeaders, ...options }).catch(async (error) => {
+      if (options?.tryPull?.(error)) {
+        await options?.pullModel(this.options.model);
+        return this.#createStream(input, {
+          ...options,
+          tryPull: () => false
+        });
+      }
+      throw error;
+    });
+  }
+  async *stream(input, options) {
+    const input2 = {
+      ...input,
+      messages: v2.parse(ChatMessageListDefine, input.messages),
+      model: this.options.model,
+      stream: true,
+      max_tokens: this.options.max_tokens,
+      top_p: this.options.top_p,
+      temperature: this.options.temperature,
+      frequency_penalty: this.options.frequency_penalty,
+      presence_penalty: this.options.presence_penalty,
+      seed: this.options.seed,
+      stop: this.options.stop,
+      ...this.extraBody
+    };
+    const result = await this.#createStream(input2, options);
+    let isThinking = 0;
+    for await (const item of result) {
+      try {
+        if (!item.choices[0].finish_reason) {
+          if (typeof item.choices[0].delta.reasoning_content === "string" || typeof item.choices[0].delta.reasoning === "string") {
+            if (isThinking === 0) {
+              isThinking = 1;
+              yield "<thinking>";
+            }
+            const result2 = item.choices[0].delta.reasoning_content ?? item.choices[0].delta.reasoning;
+            if (result2) {
+              yield result2;
+            }
+          } else if (typeof item.choices[0].delta.content === "string") {
+            if (isThinking === 1) {
+              yield "</thinking>";
+              isThinking = 2;
+            }
+            const result2 = item.choices[0].delta.content;
+            if (result2) {
+              yield result2;
+            }
+          }
+        }
+      } catch (error) {
+        throw error;
+      }
+    }
+  }
+  // 工具调用,暂时不清楚怎么调用...是返回工具,还是返回对话
+  async callTool(input, options) {
+    const result = await this.instance.chat.completions.create(
+      {
+        ...input,
+        messages: v2.parse(ChatMessageListDefine, input.messages),
+        model: this.options.model,
+        max_tokens: this.options.max_tokens,
+        top_p: this.options.top_p,
+        temperature: this.options.temperature,
+        frequency_penalty: this.options.frequency_penalty,
+        presence_penalty: this.options.presence_penalty,
+        seed: this.options.seed,
+        stop: this.options.stop,
+        ...this.extraBody,
+        stream: false
+      },
+      { headers: this.extraHeaders, ...options }
+    );
+    const isTool = !!result.choices[0].message.tool_calls;
+    if (isTool) {
+      const data = result.choices[0].message.tool_calls[0].function;
+      return {
+        type: "function",
+        function: {
+          name: data.name,
+          arguments: JSON.parse(data.arguments)
+        }
+      };
+    }
+    return { type: "text", text: result.choices[0].message.content };
+  }
+};
+
+// packages/openai/chat/vendor/openai-compatible.factory.ts
+var VendorObject = {
+  "360": { options: { baseURL: "https://ai.360.cn", modelList: [] } },
+  azure: { options: { baseURL: "", modelList: [] } },
+  moonshot: { options: { baseURL: "https://api.moonshot.cn", modelList: [] } },
+  baichuan: {
+    options: { baseURL: "https://api.baichuan-ai.com", modelList: [] }
+  },
+  minimax: { options: { baseURL: "https://api.minimax.chat", modelList: [] } },
+  mistralai: { options: { baseURL: "https://api.mistral.ai", modelList: [] } },
+  groq: {
+    options: { baseURL: "https://api.groq.com/openai", modelList: [] }
+  },
+  lingyiwanwu: {
+    options: { baseURL: "https://api.lingyiwanwu.com", modelList: [] }
+  },
+  stepfun: { options: { baseURL: "https://api.stepfun.com", modelList: [] } },
+  deepseek: { options: { baseURL: "https://api.deepseek.com", modelList: [] } },
+  "together.ai": {
+    options: { baseURL: "https://api.together.xyz", modelList: [] }
+  },
+  volcengine: {
+    options: {
+      baseURL: "https://ark.cn-beijing.volces.com/api/v3",
+      modelList: []
+    }
+  },
+  novita: {
+    options: { baseURL: "https://api.novita.ai/v3/openai", modelList: [] }
+  },
+  siliconflow: {
+    options: { baseURL: "https://api.siliconflow.cn", modelList: [] }
+  },
+  // 官网明确兼容
+  // https://help.aliyun.com/zh/model-studio/developer-reference/use-qwen-by-calling-api?spm=a2c6h.13066369.question.5.3a0e527bbxeJLJ#4ec3e641c294d
+  tongyi: {
+    options: {
+      baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1",
+      modelList: []
+    }
+  },
+  // 文档上看是一样的
+  // https://open.bigmodel.cn/dev/api/normal-model/glm-4
+  zhipu: {
+    options: {
+      baseURL: "https://open.bigmodel.cn/api/paas/v4",
+      modelList: []
+    }
+  },
+  // 明确兼容
+  // https://www.xfyun.cn/doc/spark/HTTP%E8%B0%83%E7%94%A8%E6%96%87%E6%A1%A3.html#_7-%E4%BD%BF%E7%94%A8openai-sdk%E8%AF%B7%E6%B1%82%E7%A4%BA%E4%BE%8B
+  spark: {
+    options: {
+      baseURL: "https://spark-api-open.xf-yun.com/v1",
+      modelList: []
+    }
+  },
+  // 官方兼容
+  // https://cloud.tencent.com/document/product/1729/111007
+  hunyuan: {
+    options: {
+      baseURL: "https://api.hunyuan.cloud.tencent.com/v1",
+      modelList: []
+    }
+  }
+};
+function createCompatibleFactory(options) {
+  const vendorConfig = VendorObject[options.vendor];
+  return new OpenAIChat({
+    ...options,
+    baseURL: vendorConfig.options.baseURL
+  });
+}
+
+// packages/openai/chat/vendor/genmini/genmini.ts
+import { GoogleGenerativeAI } from "@google/generative-ai";
+
+// packages/openai/chat/vendor/genmini/message.define.ts
+import * as v3 from "valibot";
+import { isTruthy } from "@cyia/util";
+function messageContentTransform(list) {
+  return list.map((item) => item.type === "text" ? { text: item.text } : void 0).filter(isTruthy);
+}
+var GenminiSystemMessageDefine = v3.pipe(
+  SystemChatMessage,
+  v3.transform((item) => {
+    return {
+      role: "system",
+      parts: messageContentTransform(item.content)
+    };
+  })
+);
+var GenminiChatMessageListDefine = v3.pipe(
+  v3.array(
+    v3.union([
+      v3.pipe(
+        UserChatMessage,
+        v3.transform((item) => {
+          return {
+            role: "user",
+            parts: messageContentTransform(item.content)
+          };
+        })
+      ),
+      v3.pipe(
+        AssistantChatMessage,
+        v3.transform((item) => {
+          return {
+            role: "model",
+            parts: messageContentTransform(item.content)
+          };
+        })
+      )
+    ])
+  )
+);
+
+// packages/openai/chat/vendor/genmini/genmini.ts
+import * as v4 from "valibot";
+var GeminiChat = class extends OpenAIChat {
+  #ggai;
+  init() {
+    this.#ggai = new GoogleGenerativeAI(this.options.apiKey);
+  }
+  async *stream(input, options) {
+    const model = this.#ggai.getGenerativeModel({
+      model: this.options.model,
+      generationConfig: {
+        topP: this.options.top_p,
+        temperature: this.options.temperature,
+        maxOutputTokens: this.options.max_tokens
+      }
+    });
+    const messages = input.messages;
+    const data = {};
+    if (messages[0].role === "system") {
+      const system = messages.shift();
+      data.systemInstruction = v4.parse(GenminiSystemMessageDefine, system);
+    }
+    data.history = v4.parse(GenminiChatMessageListDefine, messages);
+    const lastMessage = data.history.pop();
+    const chat = model.startChat(data);
+    const result = await chat.sendMessageStream(lastMessage.parts, {
+      signal: options?.signal
+    });
+    for await (const chunk of result.stream) {
+      const chunkText = chunk.text();
+      yield chunkText;
+    }
+  }
+};
+
+// packages/openai/chat/vendor/anthropic/anthropic.ts
+import Anthropic from "@anthropic-ai/sdk";
+
+// packages/openai/chat/vendor/anthropic/message.define.ts
+import { isTruthy as isTruthy2 } from "@cyia/util";
+import * as v5 from "valibot";
+function baseImageSplit(str) {
+  const mimeTypeIndex = str.indexOf(";");
+  const dataStartIndex = str.indexOf(",", mimeTypeIndex);
+  return {
+    mimeType: str.slice(5, mimeTypeIndex),
+    data: str.slice(dataStartIndex + 1)
+  };
+}
+var AnthropicSystemMessageDefine = v5.pipe(
+  SystemChatCompletionContent,
+  v5.transform((list) => {
+    return list.map((item) => item.type === "text" ? item : void 0).filter(isTruthy2);
+  })
+);
+function contentConvert(part) {
+  if (part.type === "text") {
+    return part;
+  }
+  const result = baseImageSplit(part.image_url.url);
+  return {
+    type: "image",
+    source: {
+      type: "base64",
+      media_type: result.mimeType,
+      data: result.data
+    }
+  };
+}
+var UserMessageDefine = v5.pipe(
+  UserChatMessage,
+  v5.transform((item) => {
+    return {
+      ...item,
+      content: item.content.map(contentConvert)
+    };
+  })
+);
+var AssistantMessageDefine = v5.pipe(
+  AssistantChatMessage,
+  v5.transform((item) => {
+    return {
+      ...item,
+      content: item.content.map(contentConvert)
+    };
+  })
+);
+var AnthropicChatMessageListDefine = v5.array(
+  v5.union([UserMessageDefine, AssistantMessageDefine])
+);
+
+// packages/openai/chat/vendor/anthropic/anthropic.ts
+import { createAsyncGeneratorAdapter } from "@cyia/util";
+import * as v6 from "valibot";
+var AnthropicChat = class extends OpenAIChat {
+  client;
+  init() {
+    this.client = new Anthropic({ apiKey: this.options.apiKey });
+  }
+  async *stream(input, options) {
+    const body = {
+      model: this.options.model,
+      max_tokens: this.options.max_tokens,
+      top_p: this.options.top_p,
+      temperature: this.options.temperature,
+      stream: true
+    };
+    if (input.messages[0].role === "system") {
+      const system = input.messages.shift().content;
+      body.system = v6.parse(AnthropicSystemMessageDefine, system);
+    }
+    body.messages = v6.parse(AnthropicChatMessageListDefine, input.messages);
+    const result = this.client.messages.stream(body, {
+      signal: options?.signal
+    });
+    const aga = createAsyncGeneratorAdapter();
+    result.once("end", () => aga.complete());
+    result.on("text", (text) => {
+      aga.next(text);
+    });
+    for await (const item of aga.getData()) {
+      yield item;
+    }
+  }
+  async callTool(input, options) {
+    const body = {};
+    if (input.messages[0].role === "system") {
+      const system = input.messages.shift().content;
+      body.system = v6.parse(AnthropicSystemMessageDefine, system);
+    }
+    body.messages = v6.parse(AnthropicChatMessageListDefine, input.messages);
+    const result = await this.client.messages.create(
+      {
+        ...body,
+        model: this.options.model,
+        max_tokens: this.options.max_tokens,
+        top_p: this.options.top_p,
+        temperature: this.options.temperature,
+        stream: false,
+        tools: input.tools.map((item) => {
+          return {
+            name: item.function.name,
+            description: item.function.description,
+            input_schema: item.function.parameters
+          };
+        })
+      },
+      {
+        signal: options?.signal
+      }
+    );
+    const isToolResult = result.content.find(
+      (item) => item.type === "tool_use"
+    );
+    if (isToolResult) {
+      return {
+        type: "function",
+        function: {
+          name: isToolResult.name,
+          arguments: isToolResult.input
+        }
+      };
+    }
+    const text = result.content.find((item) => item.type === "text");
+    return {
+      type: "text",
+      text: text.text
+    };
+  }
+};
+
+// packages/openai/chat/util/create.ts
+function createSystemMessage() {
+  return { role: "system" };
+}
+function createUserMessage(text) {
+  return {
+    role: "user",
+    content: typeof text === "string" ? [{ type: "text", text: "" }] : void 0
+  };
+}
+function createAssistantMessage(text = "") {
+  return {
+    role: "assistant",
+    content: [{ type: "text", text }]
+  };
+}
+
+// packages/openai/chat/const.ts
+var ThinkList = [
+  "think",
+  "thinking",
+  "reason",
+  "reasoning",
+  "thought",
+  "Thought"
+];
+
+// packages/openai/chat/options.define.ts
+import {
+  asControl,
+  componentClass,
+  patchInputs,
+  patchWrappers,
+  setComponent
+} from "@piying/view-angular-core";
+import * as v7 from "valibot";
+import {
+  asVirtualGroup,
+  metadataPipe,
+  omitIntersect
+} from "@piying/valibot-visit";
+var VendorList = [
+  {
+    value: "openai",
+    label: "openai",
+    options: {
+      baseURL: "",
+      modelList: [],
+      description: "如果是openai兼容的厂商,需要设置baseURL"
+    }
+  },
+  {
+    value: "360",
+    label: "360",
+    options: { baseURL: "https://ai.360.cn", modelList: [] }
+  },
+  {
+    value: "azure",
+    label: "azure",
+    options: { baseURL: "", modelList: [] }
+  },
+  {
+    value: "moonshot",
+    label: "moonshot",
+    options: { baseURL: "https://api.moonshot.cn", modelList: [] }
+  },
+  {
+    value: "baichuan",
+    label: "baichuan",
+    options: { baseURL: "https://api.baichuan-ai.com", modelList: [] }
+  },
+  {
+    value: "minimax",
+    label: "minimax",
+    options: { baseURL: "https://api.minimax.chat", modelList: [] }
+  },
+  {
+    value: "mistralai",
+    label: "mistralai",
+    options: { baseURL: "https://api.mistral.ai", modelList: [] }
+  },
+  {
+    value: "groq",
+    label: "groq",
+    options: { baseURL: "https://api.groq.com/openai", modelList: [] }
+  },
+  {
+    value: "lingyiwanwu",
+    label: "lingyiwanwu",
+    options: { baseURL: "https://api.lingyiwanwu.com", modelList: [] }
+  },
+  {
+    value: "stepfun",
+    label: "stepfun",
+    options: { baseURL: "https://api.stepfun.com", modelList: [] }
+  },
+  {
+    value: "deepseek",
+    label: "deepseek",
+    options: { baseURL: "https://api.deepseek.com", modelList: [] }
+  },
+  {
+    value: "together.ai",
+    label: "together.ai",
+    options: { baseURL: "https://api.together.xyz", modelList: [] }
+  },
+  {
+    value: "volcengine",
+    label: "volcengine",
+    options: {
+      baseURL: "https://ark.cn-beijing.volces.com/api/v3",
+      modelList: []
+    }
+  },
+  {
+    value: "novita",
+    label: "novita",
+    options: { baseURL: "https://api.novita.ai/v3/openai", modelList: [] }
+  },
+  {
+    value: "siliconflow",
+    label: "siliconflow",
+    options: { baseURL: "https://api.siliconflow.cn", modelList: [] }
+  },
+  {
+    value: "tongyi",
+    label: "tongyi",
+    options: {
+      baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1",
+      modelList: []
+    }
+  },
+  {
+    value: "zhipu",
+    label: "zhipu",
+    options: {
+      baseURL: "https://open.bigmodel.cn/api/paas/v4",
+      modelList: []
+    }
+  },
+  {
+    value: "spark",
+    label: "spark",
+    options: {
+      baseURL: "https://spark-api-open.xf-yun.com/v1",
+      modelList: []
+    }
+  },
+  {
+    value: "hunyuan",
+    label: "hunyuan",
+    options: {
+      baseURL: "https://api.hunyuan.cloud.tencent.com/v1",
+      modelList: []
+    }
+  },
+  {
+    value: "gemini",
+    label: "gemini",
+    options: {
+      baseURL: "",
+      modelList: [],
+      description: "非openai兼容,手动适配,如果有问题欢迎报告"
+    }
+  },
+  {
+    value: "claude",
+    label: "claude",
+    options: {
+      baseURL: "",
+      modelList: [],
+      description: "非openai兼容,手动适配,如果有问题欢迎报告"
+    }
+  }
+];
+var vendorOptionsDescribe = `## 通用参数
+- \`extraOptions\`字段用于覆盖默认字段
+\`\`\`json
+{"厂商名(与vendor字段相同)":{ "extraOptions":{"temperature":0.1,"topP":0.8,"maxTokens":8192,"baseURL":"http://127.0.0.1:11434/v1","apiKey":" "} }
+\`\`\`
+`;
+var InputWrapper = metadataPipe(patchWrappers(["tooltip", "form-field"]));
+var ChatItemDefine = v7.pipe(
+  v7.intersect([
+    v7.pipe(
+      v7.object({
+        name: v7.pipe(v7.string(), v7.title("配置名")),
+        vendor: v7.pipe(
+          v7.optional(
+            v7.picklist(VendorList.map((item) => item.value)),
+            "openai"
+          ),
+          v7.description("大语言模型提供的厂商"),
+          v7.title("对话厂商"),
+          v7.metadata({
+            enumOptions: VendorList.map((item) => {
+              return {
+                label: item.label,
+                description: [
+                  item.options.description ? item.options.description : "",
+                  item.options.baseURL ? `链接: ${item.options.baseURL}` : ""
+                ].filter(Boolean).join("\n")
+              };
+            })
+          }),
+          patchInputs({
+            options: VendorList
+          })
+        )
+      }),
+      componentClass("flex *:flex-1 gap-2 items-center")
+    ),
+    v7.pipe(
+      v7.object({
+        baseURL: v7.pipe(
+          v7.optional(v7.string(), "http://127.0.0.1:11434/v1"),
+          v7.title("地址"),
+          v7.description("openai兼容接口"),
+          ...InputWrapper
+        ),
+        model: v7.pipe(
+          v7.optional(v7.string(), `qwen3:8b`),
+          v7.title("模型"),
+          v7.description(
+            "## 模型名\n### ollama模型推荐\n- `qwen3:8b`\n- `qwen3:14b`,`deepseek-r1:7b`,`deepseek-r1:14b`\n### 图片对话模型\n- `minicpm-v:8b`"
+          ),
+          ...InputWrapper
+        )
+      }),
+      componentClass("flex *:flex-1 gap-2 items-center")
+    ),
+    v7.object({
+      apiKey: v7.pipe(
+        v7.optional(v7.string()),
+        v7.description("本地部署默认可以不填")
+      )
+    }),
+    v7.pipe(
+      v7.object({
+        max_tokens: v7.pipe(v7.optional(v7.number(), 8192)),
+        top_p: v7.pipe(
+          v7.optional(v7.number(), 0.8),
+          v7.minValue(0),
+          v7.maxValue(10),
+          v7.description(`核采样（nucleus sampling）是温度采样的另一种替代方法，模型会考虑累积概率质量达到 top_p 的 token。例如，当 top_p 设为 0.1 时，仅考虑累积概率前 10% 的 token。
+
+我们通常建议调整 top_p 或温度参数，但不要同时调整两者。`),
+          ...InputWrapper
+        ),
+        temperature: v7.pipe(
+          v7.optional(v7.pipe(v7.number(), v7.minValue(0), v7.maxValue(2)), 0.1),
+          v7.description(
+            "采样温度应设置在0到2之间。较高的值（如0.8）会使输出更随机，而较低的值（如0.2）则会使输出更集中且确定。我们通常建议仅调整此参数或top_p，而不同时调整两者。"
+          ),
+          ...InputWrapper
+        ),
+        frequency_penalty: v7.pipe(
+          v7.optional(v7.pipe(v7.number(), v7.minValue(-2), v7.maxValue(2))),
+          v7.description(
+            "取值范围为-2.0至2.0。正值会根据当前文本中已有标记的频率对新标记进行惩罚，从而降低模型逐字重复相同内容的概率。"
+          ),
+          ...InputWrapper
+        ),
+        presence_penalty: v7.pipe(
+          v7.optional(v7.pipe(v7.number(), v7.minValue(-2), v7.maxValue(2))),
+          v7.description(
+            "数值介于-2.0至2.0之间。正值会基于新标记是否已在当前文本中出现，对新标记施加惩罚，从而提升模型讨论新话题的可能性。"
+          ),
+          ...InputWrapper
+        ),
+        seed: v7.pipe(
+          v7.optional(v7.pipe(v7.number())),
+          v7.description(
+            "若已指定，系统将尽力确保采样具有确定性，即使用相同种子和参数的重复请求将返回相同结果。确定性无法保证，请通过 system_fingerprint 响应参数监控后端变化。"
+          ),
+          ...InputWrapper
+        ),
+        stop: v7.pipe(
+          v7.optional(v7.pipe(v7.array(v7.pipe(v7.string())), v7.maxLength(4))),
+          v7.description(
+            "最多可指定4个停止序列，API将在生成到该序列时停止，返回的文本中不包含该停止序列。"
+          ),
+          asControl(),
+          setComponent("chip-input-list"),
+          patchInputs({
+            addOnBlur: true
+          }),
+          ...InputWrapper
+        )
+        //   top_logprobs: v.pipe(
+        //     v.optional(v.pipe(v.number(), v.minValue(0), v.maxValue(20))),
+        //     v.description(
+        //       '一个介于0和20之间的整数，用于指定在每个标记位置返回的最可能的标记数量，每个标记均关联对应的对数概率。若使用此参数，则必须将logprobs设置为true。',
+        //     ),
+        //   ),
+        //   verbosity: v.pipe(
+        //     v.optional(v.picklist(['low', 'medium', 'high'])),
+        //     v.description(
+        //       `控制模型回复的详细程度。数值越低，回复越简洁；数值越高，回复越详细。当前支持的取值为低、中和高。`,
+        //     ),
+        //   ),
+        //   reasoning_effort: v.pipe(
+        //     v.optional(v.picklist(['minimal', 'low', 'medium', 'high'])),
+        //     v.description(
+        //       `控制模型回复的详细程度。数值越低，回复越简洁；数值越高，回复越详细。当前支持的取值为低、中和高。`,
+        //     ),
+        //   ),
+      }),
+      componentClass("grid gap-2")
+    )
+  ]),
+  componentClass("grid gap-2"),
+  asVirtualGroup()
+);
+var VendorOptionsDefine = v7.pipe(
+  v7.optional(
+    v7.record(
+      v7.string(),
+      v7.pipe(
+        v7.intersect([
+          v7.object({
+            /** @internal */
+            extraOptions: v7.pipe(
+              v7.optional(omitIntersect(ChatItemDefine, ["name", "vendor"])),
+              v7.description(`附加配置`)
+            )
+          })
+        ]),
+        componentClass("grid gap-2"),
+        asVirtualGroup()
+      )
+    )
+  ),
+  v7.description(vendorOptionsDescribe),
+  setComponent("rest-chip-group"),
+  patchInputs({
+    optionalkeyList: VendorList.map((item) => item.value),
+    placeholder: "请设置额外配置"
+  }),
+  v7.title("厂商额外配置")
+);
+var ChatParamsItemDefine = v7.pipe(
+  v7.intersect([
+    ChatItemDefine,
+    v7.object({ vendorOptions: VendorOptionsDefine })
+  ]),
+  asVirtualGroup(),
+  componentClass("grid gap-2")
+);
+var ChatParamsListDefine = v7.pipe(
+  v7.array(ChatParamsItemDefine),
+  setComponent("label-chip-array"),
+  v7.description("对话模型列表,目前用于切换使用"),
+  patchInputs({
+    displayKey: "name",
+    placeholder: "请添加配置"
+  })
+);
+var InputChatOptionsDefine = omitIntersect(ChatParamsItemDefine, [
+  "name"
+]);
+
+// packages/openai/chat/token.ts
+import { InjectionToken } from "static-injector";
+var OpenAIConfigToken = new InjectionToken(
+  "OpenAIConfig"
+);
+
+// packages/openai/chat/chat.history.service.ts
+import {
+  computed,
+  inject,
+  signal
+} from "static-injector";
+import { omitBy } from "es-toolkit";
+import { bufferWhen, debounceTime, filter, Subject } from "rxjs";
+import { path } from "@cyia/vfs2";
+import * as fs from "fs";
+import { parse as parse4, stringify } from "yaml";
+import dayjs from "dayjs";
+import { isEmptyInput } from "@cyia/util";
+var ChatHistoryService = class {
+  #update$ = signal(0);
+  /** 外部监听更新用 */
+  update$$ = computed(() => this.#update$());
+  #logMap = /* @__PURE__ */ new Map();
+  #config = inject(OpenAIConfigToken);
+  #dir() {
+    return this.#config().history.dir;
+  }
+  #createNewListen(fileName) {
+    const filePath = path.join(this.#dir(), `${fileName}.yml`);
+    const instance = new Subject();
+    instance.pipe(
+      bufferWhen(() => instance.pipe(debounceTime(2e3))),
+      filter((list) => !!list.length)
+    ).subscribe(async (inputList) => {
+      if (!fs.existsSync(this.#dir())) {
+        await fs.promises.mkdir(this.#dir(), { recursive: true });
+      }
+      try {
+        let list = [];
+        if (await fs.existsSync(filePath)) {
+          const content = await fs.promises.readFile(filePath, {
+            encoding: "utf-8"
+          });
+          list = parse4(content);
+        } else {
+          list = [];
+        }
+        list.unshift(...inputList.reverse());
+        await fs.promises.writeFile(filePath, stringify(list));
+        this.#update$.update((a) => a + 1);
+      } catch (error) {
+        this.#config().captureException(error);
+      }
+    });
+    this.#logMap.set(fileName, instance);
+    return instance;
+  }
+  save(messages, options, config) {
+    if (!this.#config().history.enable) {
+      return;
+    }
+    try {
+      const fileName = dayjs().format("YYYY-MM-DD");
+      const message$ = this.#logMap.get(fileName) ?? this.#createNewListen(fileName);
+      const item = {
+        date: dayjs().valueOf(),
+        messages,
+        options: omitBy(options, isEmptyInput),
+        config
+      };
+      message$.next(item);
+    } catch (error) {
+      try {
+        this.#config().captureException(error);
+      } catch (error2) {
+      }
+    }
+  }
+};
+
+// packages/openai/chat/service.ts
+import * as v8 from "valibot";
+var ChatProviderService = class {
+  #config = inject2(OpenAIConfigToken);
+  #chatHistory = inject2(ChatHistoryService);
+  create(input) {
+    let options = v8.parse(InputChatOptionsDefine, input);
+    let instance;
+    const extraOptions = options.vendorOptions?.[options.vendor]?.["extraOptions"];
+    options = {
+      ...extraOptions,
+      ...options,
+      apiKey: options.apiKey?.trim() || extraOptions?.apiKey || " "
+    };
+    if (!options.vendor || options.vendor === "openai") {
+      instance = new OpenAIChat(options);
+    } else if (options.vendor === "gemini") {
+      instance = new GeminiChat(options);
+    } else if (options.vendor === "claude") {
+      instance = new AnthropicChat(options);
+    } else {
+      instance = createCompatibleFactory(options);
+    }
+    instance.init();
+    let openAIOptions = this.#config;
+    const chatHistory = this.#chatHistory;
+    const fn = async function* (...args) {
+      const result = instance.stream(args[0], {
+        ...args[1],
+        tryPull: openAIOptions().tryPull,
+        pullModel: openAIOptions().pullModel
+      });
+      let content = "";
+      let isThink = false;
+      let thinkStart = 0;
+      let thinkEnd;
+      let start = true;
+      let isThinking = false;
+      let contentEnd;
+      let lastEmit;
+      for await (const delta of result) {
+        content += delta;
+        if (start) {
+          start = false;
+          const result2 = ThinkList.find(
+            (item) => delta.startsWith(`<${item}>`)
+          );
+          if (result2) {
+            isThink = true;
+            thinkStart = result2.length + 2;
+            isThinking = true;
+          }
+        } else if (isThink && thinkEnd === void 0) {
+          const result2 = ThinkList.find((item) => delta === `</${item}>`);
+          if (result2) {
+            contentEnd = content.length;
+            thinkEnd = content.length - result2.length - 3;
+            isThinking = false;
+          }
+        }
+        lastEmit = {
+          content: isThink ? (contentEnd ? content.slice(contentEnd) : "").trim() : content,
+          isThinking,
+          delta,
+          thinkContent: isThink ? content.slice(thinkStart, thinkEnd).trim() : void 0
+        };
+        yield lastEmit;
+      }
+      const lastMessage = createAssistantMessage(
+        isThink ? contentEnd ? content.slice(contentEnd) : "" : content
+      );
+      if (lastEmit?.thinkContent) {
+        lastMessage.thinkContent = lastEmit.thinkContent;
+      }
+      chatHistory.save(
+        [...args[0].messages, lastMessage],
+        { ...args[0], messages: void 0 },
+        options
+      );
+    };
+    return {
+      stream: fn,
+      chat: async (...args) => {
+        const result = fn(...args);
+        let obj;
+        for await (const element of result) {
+          obj = element;
+        }
+        return obj;
+      },
+      callTool: (input2, options2) => {
+        return instance.callTool(input2, options2);
+      }
+    };
+  }
+};
+
+// packages/openai/chat/module.ts
+var OPENAI_MODULE = {
+  provider: [ChatProviderService, ChatHistoryService],
+  token: { OpenAIConfigToken }
+};
+export {
+  AssistantChatCompletionContent,
+  AssistantChatMessage,
+  ChatCompletionContentPart,
+  ChatCompletionContentPartImage,
+  ChatCompletionContentPartStr,
+  ChatHistoryService,
+  ChatItemDefine,
+  ChatMessageItemDefine,
+  ChatMessageListDefine,
+  ChatParamsItemDefine,
+  ChatParamsListDefine,
+  ChatProviderService,
+  InputChatOptionsDefine,
+  OPENAI_MODULE,
+  OpenAIConfigToken,
+  SystemChatCompletionContent,
+  SystemChatMessage,
+  UserChatCompletionContent,
+  UserChatMessage,
+  VendorOptionsDefine,
+  createAssistantMessage,
+  createSystemMessage,
+  createUserMessage
+};
+//# sourceMappingURL=index.mjs.map