@shenghuabi/openai 1.1.47 → 1.2.2

package/index.mjs

@@ -1,8 +1,8 @@
-// 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/token.ts
+import { InjectionToken } from "static-injector";
+var OpenAIConfigToken = new InjectionToken(
+  "OpenAIConfig"
+);
 
 // packages/openai/chat/message.define.ts
 import * as v from "valibot";
@@ -12,8 +12,7 @@ var ChatCompletionContentPartStr = v.object({
 });
 var ChatCompletionContentPartImage = v.object({
   image_url: v.object({
-    url: v.string(),
-    detail: v.optional(v.picklist(["auto", "low", "high"]))
+    url: v.string()
   }),
   type: v.optional(v.literal("image_url"), "image_url")
 });
@@ -45,390 +44,11 @@ var ChatMessageItemDefine = v.union([
   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: 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) => ({
-    role: "system",
-    parts: messageContentTransform(item.content)
-  }))
-);
-var GenminiChatMessageListDefine = v3.pipe(
-  v3.array(
-    v3.union([
-      v3.pipe(
-        UserChatMessage,
-        v3.transform((item) => ({
-          role: "user",
-          parts: messageContentTransform(item.content)
-        }))
-      ),
-      v3.pipe(
-        AssistantChatMessage,
-        v3.transform((item) => ({
-          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) => 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(
+var ChatMessageCommonItemDefine = v.union([
   UserChatMessage,
-  v5.transform((item) => ({
-    ...item,
-    content: item.content.map(contentConvert)
-  }))
-);
-var AssistantMessageDefine = v5.pipe(
-  AssistantChatMessage,
-  v5.transform((item) => ({
-    ...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) => ({
-          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
-    };
-  }
-};
+  AssistantChatMessage
+]);
+var ChatMessageListDefine = v.array(ChatMessageItemDefine);
 
 // packages/openai/chat/util/create.ts
 function createSystemMessage() {
@@ -447,560 +67,671 @@ function createAssistantMessage(text = "") {
   };
 }
 
-// packages/openai/chat/const.ts
-var ThinkList = [
-  "think",
-  "thinking",
-  "reason",
-  "reasoning",
-  "thought",
-  "Thought"
-];
+// packages/openai/chat/module.ts
+var OPENAI_MODULE = {
+  provider: [],
+  token: { OpenAIConfigToken }
+};
 
-// packages/openai/chat/options.define.ts
-import { asControl, actions, setComponent } from "@piying/view-angular-core";
-import * as v7 from "valibot";
+// packages/openai/chat/chat.ts
 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兼容,手动适配,如果有问题欢迎报告"
-    }
+  stream
+} from "@earendil-works/pi-ai";
+
+// packages/openai/chat/util/get-custom-provider.ts
+import * as v3 from "valibot";
+import { getModel } from "@earendil-works/pi-ai";
+
+// packages/openai/chat/provider.define.ts
+import * as v2 from "valibot";
+var KnownProviderDefine = v2.pipe(
+  v2.picklist([
+    "amazon-bedrock",
+    "anthropic",
+    "google",
+    "google-vertex",
+    "openai",
+    "azure-openai-responses",
+    "openai-codex",
+    "deepseek",
+    "github-copilot",
+    "xai",
+    "groq",
+    "cerebras",
+    "openrouter",
+    "vercel-ai-gateway",
+    "zai",
+    "mistral",
+    "minimax",
+    "minimax-cn",
+    "moonshotai",
+    "moonshotai-cn",
+    "huggingface",
+    "fireworks",
+    "together",
+    "opencode",
+    "opencode-go",
+    "kimi-coding",
+    "cloudflare-workers-ai",
+    "cloudflare-ai-gateway",
+    "xiaomi",
+    "xiaomi-token-plan-cn",
+    "xiaomi-token-plan-ams",
+    "xiaomi-token-plan-sgp",
+    "ant-ling",
+    "nvidia",
+    "zai-coding-cn",
+    /** 自定义 */
+    "openai-completions",
+    "openai-responses",
+    "anthropic-messages"
+  ]),
+  v2.title("提供商"),
+  v2.description(`'openai-completions','openai-responses','anthropic-messages',为自定义提供商`)
+);
+
+// packages/openai/chat/util/get-custom-provider.ts
+import { hideWhen } from "@piying/view-angular-core";
+import { map } from "rxjs";
+function getCustomProvider(compat, model, name, input) {
+  return { ...input, id: model, api: compat, name };
+}
+function getModelConfig(input) {
+  if (input.provider === "faux") {
+    return {
+      model: input.config,
+      config: input
+    };
   }
-];
-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(actions.wrappers.set(["tooltip", "label"]));
-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) => ({
-              label: item.label,
-              description: [
-                item.options.description ? item.options.description : "",
-                item.options.baseURL ? `链接: ${item.options.baseURL}` : ""
-              ].filter(Boolean).join("\n")
-            }))
-          }),
-          actions.inputs.patch({
-            options: VendorList
-          })
+  const config = v3.parse(ModelConfigDefine, input);
+  if (config.provider === "openai-completions" || config.provider === "openai-responses" || config.provider === "anthropic-messages") {
+    return {
+      model: getCustomProvider(
+        config.provider,
+        config.model,
+        config.name,
+        config.config
+      ),
+      config
+    };
+  }
+  return {
+    model: getModel(config.provider, config.model),
+    config
+  };
+}
+var ThinkingLevelSchema = v3.pipe(
+  v3.picklist(["minimal", "low", "medium", "high", "xhigh"]),
+  v3.title("思考等级"),
+  v3.description("模型思考的详细程度，从最小到最大")
+);
+var ModelThinkingLevelSchema = v3.pipe(
+  v3.picklist(["off", "minimal", "low", "medium", "high", "xhigh"]),
+  v3.title("模型思考等级"),
+  v3.description("关闭或设置模型思考的详细程度")
+);
+var OpenAICompletionsCompatSchema = v3.pipe(
+  v3.optional(
+    v3.object({
+      supportsStore: v3.optional(
+        v3.pipe(
+          v3.boolean(),
+          v3.title("支持存储"),
+          v3.description("是否支持服务端会话存储")
         )
-      }),
-      actions.wrappers.patch(["div"]),
-      actions.class.top("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
+      ),
+      supportsDeveloperRole: v3.optional(
+        v3.pipe(
+          v3.boolean(),
+          v3.title("支持开发者角色"),
+          v3.description("是否支持 developer 系统消息角色")
+        )
+      ),
+      supportsReasoningEffort: v3.optional(
+        v3.pipe(
+          v3.boolean(),
+          v3.title("支持推理努力"),
+          v3.description("是否支持 reasoning_effort 参数")
+        )
+      ),
+      supportsUsageInStreaming: v3.optional(
+        v3.pipe(
+          v3.boolean(),
+          v3.title("流式用量"),
+          v3.description("流式输出中是否返回 usage 信息")
+        )
+      ),
+      maxTokensField: v3.optional(
+        v3.pipe(
+          v3.picklist(["max_completion_tokens", "max_tokens"]),
+          v3.title("最大 token 字段名"),
+          v3.description("指定最大 token 参数使用的是哪个字段名")
+        )
+      ),
+      requiresToolResultName: v3.optional(
+        v3.pipe(
+          v3.boolean(),
+          v3.title("需要工具结果名称"),
+          v3.description("是否要求工具结果消息包含 name 字段")
+        )
+      ),
+      requiresAssistantAfterToolResult: v3.optional(
+        v3.pipe(
+          v3.boolean(),
+          v3.title("需要助手回复"),
+          v3.description("工具结果后是否需要助手消息跟进")
+        )
+      ),
+      requiresThinkingAsText: v3.optional(
+        v3.pipe(
+          v3.boolean(),
+          v3.title("思考转文本"),
+          v3.description("是否将思考过程作为普通文本发送")
+        )
+      ),
+      requiresReasoningContentOnAssistantMessages: v3.optional(
+        v3.pipe(
+          v3.boolean(),
+          v3.title("推理内容在助手消息中"),
+          v3.description("是否在助手消息中包含推理内容")
+        )
+      ),
+      thinkingFormat: v3.optional(
+        v3.pipe(
+          v3.picklist([
+            "openai",
+            "openrouter",
+            "deepseek",
+            "together",
+            "zai",
+            "qwen",
+            "qwen-chat-template",
+            "string-thinking",
+            "ant-ling"
+          ]),
+          v3.title("思考格式"),
+          v3.description("指定 thinking 标签的序列化格式")
+        )
+      ),
+      openRouterRouting: v3.optional(
+        v3.pipe(
+          v3.unknown(),
+          v3.title("OpenRouter 路由"),
+          v3.description("自定义 OpenRouter 的路由配置")
+        )
+      ),
+      vercelGatewayRouting: v3.optional(
+        v3.pipe(
+          v3.unknown(),
+          v3.title("Vercel Gateway 路由"),
+          v3.description("自定义 Vercel AI Gateway 的路由配置")
+        )
+      ),
+      zaiToolStream: v3.optional(
+        v3.pipe(
+          v3.boolean(),
+          v3.title("ZAI 工具流式"),
+          v3.description("是否启用 ZAI 平台工具调用的流式输出")
+        )
+      ),
+      supportsStrictMode: v3.optional(
+        v3.pipe(
+          v3.boolean(),
+          v3.title("严格模式"),
+          v3.description("是否支持工具的 JSON Schema 严格校验")
+        )
+      ),
+      cacheControlFormat: v3.optional(
+        v3.pipe(
+          v3.literal("anthropic"),
+          v3.title("缓存控制格式"),
+          v3.description("指定缓存控制的语法格式")
+        )
+      ),
+      sendSessionAffinityHeaders: v3.optional(
+        v3.pipe(
+          v3.boolean(),
+          v3.title("发送会话亲和标头"),
+          v3.description("是否在请求中携带会话亲和性标头")
+        )
+      ),
+      supportsLongCacheRetention: v3.optional(
+        v3.pipe(
+          v3.boolean(),
+          v3.title("长期缓存保留"),
+          v3.description("是否支持长期缓存保留策略")
         )
-      }),
-      actions.wrappers.patch([
-        {
-          type: "div",
-          attributes: { class: "flex *:flex-1 gap-2 items-center" }
-        }
-      ])
-    ),
-    v7.object({
-      apiKey: v7.pipe(
-        v7.optional(v7.string()),
-        v7.description("本地部署默认可以不填"),
-        v7.title("apiKey")
       )
-    }),
-    v7.pipe(
-      v7.object({
-        max_tokens: v7.pipe(v7.optional(v7.number(), 8192), v7.title("max_tokens")),
-        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,
-          v7.title("top_p")
-        ),
-        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,
-          v7.title("temperature")
-        ),
-        frequency_penalty: v7.pipe(
-          v7.optional(v7.pipe(v7.number(), v7.minValue(-2), v7.maxValue(2))),
-          v7.description(
-            "取值范围为-2.0至2.0。正值会根据当前文本中已有标记的频率对新标记进行惩罚，从而降低模型逐字重复相同内容的概率。"
-          ),
-          ...InputWrapper,
-          v7.title("frequency_penalty")
-        ),
-        presence_penalty: v7.pipe(
-          v7.optional(v7.pipe(v7.number(), v7.minValue(-2), v7.maxValue(2))),
-          v7.description(
-            "数值介于-2.0至2.0之间。正值会基于新标记是否已在当前文本中出现，对新标记施加惩罚，从而提升模型讨论新话题的可能性。"
-          ),
-          ...InputWrapper,
-          v7.title("presence_penalty")
-        ),
-        seed: v7.pipe(
-          v7.optional(v7.pipe(v7.number())),
-          v7.description(
-            "若已指定，系统将尽力确保采样具有确定性，即使用相同种子和参数的重复请求将返回相同结果。确定性无法保证，请通过 system_fingerprint 响应参数监控后端变化。"
-          ),
-          ...InputWrapper,
-          v7.title("seed")
-        ),
-        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"),
-          actions.inputs.patch({
-            addOnBlur: true
-          }),
-          ...InputWrapper,
-          v7.title("stop")
+    })
+  ),
+  v3.title("OpenAI Completions 兼容配置"),
+  v3.description("针对 OpenAI Completions API 的兼容性覆写选项")
+);
+var OpenAIResponsesCompatSchema = v3.pipe(
+  v3.optional(
+    v3.object({
+      supportsDeveloperRole: v3.optional(
+        v3.pipe(
+          v3.boolean(),
+          v3.title("支持开发者角色"),
+          v3.description("是否支持 developer 系统消息角色")
         )
-        //   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(
-        //       `控制模型回复的详细程度。数值越低，回复越简洁；数值越高，回复越详细。当前支持的取值为低、中和高。`,
-        //     ),
-        //   ),
-      }),
-      actions.wrappers.patch(["div"]),
-      actions.class.top("grid gap-2")
-    )
-  ]),
-  actions.wrappers.patch(["div"]),
-  actions.class.top("grid gap-2"),
-  asVirtualGroup()
+      ),
+      sendSessionIdHeader: v3.optional(
+        v3.pipe(
+          v3.boolean(),
+          v3.title("发送会话 ID 标头"),
+          v3.description("是否在请求中携带 X-Session-ID 标头")
+        )
+      ),
+      supportsLongCacheRetention: v3.optional(
+        v3.pipe(
+          v3.boolean(),
+          v3.title("长期缓存保留"),
+          v3.description("是否支持长期缓存保留策略")
+        )
+      )
+    })
+  ),
+  v3.title("OpenAI Responses 兼容配置"),
+  v3.description("针对 OpenAI Responses API 的兼容性覆写选项")
 );
-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(`附加配置`)
-            )
-          })
-        ]),
-        actions.wrappers.patch(["div"]),
-        actions.class.top("grid gap-2"),
-        asVirtualGroup()
+var AnthropicMessagesCompatSchema = v3.pipe(
+  v3.optional(
+    v3.object({
+      supportsEagerToolInputStreaming: v3.optional(
+        v3.pipe(
+          v3.boolean(),
+          v3.title(" eagerly 工具流式"),
+          v3.description("是否支持工具调用的 eager 模式流式输出")
+        )
+      ),
+      supportsLongCacheRetention: v3.optional(
+        v3.pipe(
+          v3.boolean(),
+          v3.title("长期缓存保留"),
+          v3.description("是否支持长期缓存保留策略")
+        )
+      ),
+      sendSessionAffinityHeaders: v3.optional(
+        v3.pipe(
+          v3.boolean(),
+          v3.title("发送会话亲和标头"),
+          v3.description("是否在请求中携带会话亲和性标头")
+        )
+      ),
+      supportsCacheControlOnTools: v3.optional(
+        v3.pipe(
+          v3.boolean(),
+          v3.title("工具缓存控制"),
+          v3.description("是否支持在 tool_use 消息中使用 cache_control")
+        )
+      ),
+      supportsTemperature: v3.optional(
+        v3.pipe(
+          v3.boolean(),
+          v3.title("支持温度参数"),
+          v3.description("模型/接口是否支持 temperature 参数")
+        )
+      ),
+      forceAdaptiveThinking: v3.optional(
+        v3.pipe(
+          v3.boolean(),
+          v3.title("强制自适应思考"),
+          v3.description("是否强制启用 adaptive thinking 模式")
+        )
+      ),
+      allowEmptySignature: v3.optional(
+        v3.pipe(
+          v3.boolean(),
+          v3.title("允许空签名"),
+          v3.description("是否允许工具调用不指定签名(sha256)")
+        )
       )
-    )
+    })
   ),
-  v7.description(vendorOptionsDescribe),
-  setComponent("rest-chip-group"),
-  actions.inputs.patch({
-    optionalkeyList: VendorList.map((item) => item.value),
-    placeholder: "请设置额外配置"
-  }),
-  v7.title("厂商额外配置")
+  v3.title("Anthropic Messages 兼容配置"),
+  v3.description("针对 Anthropic Messages API 的兼容性覆写选项")
 );
-var ChatParamsItemDefine = v7.pipe(
-  v7.intersect([
-    ChatItemDefine,
-    v7.object({ vendorOptions: VendorOptionsDefine })
+var CompatSchema = v3.pipe(
+  v3.union([
+    OpenAICompletionsCompatSchema,
+    OpenAIResponsesCompatSchema,
+    AnthropicMessagesCompatSchema
   ]),
-  asVirtualGroup(),
-  actions.wrappers.patch(["div"]),
-  actions.class.top("grid gap-2")
+  v3.title("兼容配置"),
+  v3.description(
+    "模型 API 兼容性覆写选项，支持 OpenAI Completions、OpenAI Responses、Anthropic Messages 三种格式"
+  )
 );
-var ChatParamsListDefine = v7.pipe(
-  v7.array(ChatParamsItemDefine),
-  setComponent("label-chip-array"),
-  v7.description("对话模型列表,目前用于切换使用"),
-  actions.inputs.patch({
-    displayKey: "name",
-    placeholder: "请添加配置"
-  })
+var InputChoiceSchema = v3.pipe(
+  v3.picklist(["text", "image"]),
+  v3.title("输入类型"),
+  v3.description("支持的输入模态类型")
 );
-var InputChatOptionsDefine = omitIntersect(ChatParamsItemDefine, [
-  "name"
-]);
-
-// packages/openai/chat/token.ts
-import { InjectionToken } from "static-injector";
-var OpenAIConfigToken = new InjectionToken(
-  "OpenAIConfig"
+var InputSchema = v3.pipe(
+  v3.array(InputChoiceSchema),
+  v3.title("输入类型列表"),
+  v3.description("该模型支持的用户输入类型，如 text 文本或 image 图片")
 );
-
-// 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 = [];
+var HeadersSchema = v3.pipe(
+  v3.record(v3.string(), v3.string()),
+  v3.title("自定义请求头"),
+  v3.description("额外的 HTTP 请求头键值对配置")
+);
+var CostSchema = v3.pipe(
+  v3.optional(
+    v3.object({
+      input: v3.pipe(
+        v3.number(),
+        v3.title("输入单价"),
+        v3.description("每 token 输入费用")
+      ),
+      output: v3.pipe(
+        v3.number(),
+        v3.title("输出单价"),
+        v3.description("每 token 输出费用")
+      ),
+      cacheRead: v3.pipe(
+        v3.number(),
+        v3.title("缓存读取单价"),
+        v3.description("从缓存读取每 token 的费用")
+      ),
+      cacheWrite: v3.pipe(
+        v3.number(),
+        v3.title("缓存写入单价"),
+        v3.description("写入缓存每 token 的费用")
+      )
+    }),
+    { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }
+  ),
+  v3.title("费用配置"),
+  v3.description("模型各操作类型的 token 计价标准")
+);
+var ThinkingLevelMapSchema = v3.pipe(
+  v3.record(
+    ModelThinkingLevelSchema,
+    v3.pipe(
+      v3.nullish(v3.string()),
+      v3.title("配置值"),
+      v3.description("对应思考等级的具体配置字符串，null 表示未设置")
+    )
+  ),
+  v3.title("思考等级配置映射"),
+  v3.description("各思考等级对应的具体配置参数映射")
+);
+var ModelSchema = v3.pipe(
+  v3.object({
+    provider: v3.pipe(
+      v3.optional(v3.string(), "default"),
+      v3.title("厂商"),
+      v3.description("模型提供商，如 openai / anthropic / llama")
+    ),
+    baseUrl: v3.pipe(
+      v3.string(),
+      v3.title("基础 URL"),
+      v3.description("API 请求的基础地址")
+    ),
+    reasoning: v3.pipe(
+      v3.optional(v3.boolean(), false),
+      v3.title("支持推理"),
+      v3.description("该模型是否支持思考/推理模式")
+    ),
+    // thinkingLevelMap: v.optional(
+    //   v.pipe(
+    //     v.optional(ThinkingLevelMapSchema),
+    //     v.title('思考等级配置'),
+    //     v.description('各思考等级的具体参数配置映射'),
+    //   ),
+    // ),
+    input: v3.pipe(
+      v3.optional(InputSchema, ["text", "image"]),
+      v3.title("输入类型"),
+      v3.description("支持的输入模态类型")
+    ),
+    cost: v3.pipe(
+      CostSchema,
+      v3.title("费用配置"),
+      v3.description("模型 token 计价标准")
+    ),
+    contextWindow: v3.pipe(
+      v3.pipe(v3.optional(v3.number(), 99999999)),
+      v3.title("上下文窗口"),
+      v3.description("模型支持的上下文最大 token 数")
+    ),
+    maxTokens: v3.pipe(
+      v3.pipe(v3.optional(v3.number(), 99999999)),
+      v3.title("最大输出 tokens"),
+      v3.description("单次请求允许的最大输出 token 数")
+    ),
+    headers: v3.optional(
+      v3.pipe(
+        v3.optional(HeadersSchema),
+        v3.title("自定义请求头"),
+        v3.description("额外的 HTTP 请求头配置")
+      )
+    ),
+    compat: v3.pipe(
+      v3.optional(CompatSchema, { supportsDeveloperRole: false }),
+      v3.title("兼容配置"),
+      v3.description("API 兼容性覆写选项")
+    )
+  }),
+  v3.title("模型定义"),
+  v3.description(
+    "pi-ai 模型的核心配置结构，包含模型标识、API 参数、费用及兼容性设置"
+  )
+);
+var OutputSchema = InputSchema;
+var ModelConfigDefine = v3.pipe(
+  v3.object({
+    provider: KnownProviderDefine,
+    model: v3.pipe(v3.string(), v3.title("模型名")),
+    name: v3.pipe(
+      v3.optional(v3.string()),
+      v3.title("配置名"),
+      v3.description("模型的配置名称(默认为模型名)")
+    ),
+    /** provider是自定义时使用 */
+    apiKey: v3.pipe(v3.optional(v3.string()), v3.title("apiKey")),
+    config: v3.pipe(
+      v3.optional(ModelSchema),
+      hideWhen({
+        disabled: true,
+        listen(fn, field) {
+          return fn({ list: [["..", "provider"]] }).pipe(
+            map(
+              ({ list: [value] }) => !(value === "openai-completions" || value === "openai-responses" || value === "anthropic-messages")
+            )
+          );
         }
-        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) {
-      }
-    }
-  }
-};
+      })
+    )
+  }),
+  v3.transform((item) => ({ ...item, name: item.name ?? item.model }))
+);
 
-// 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);
+// packages/openai/chat/chat.ts
+import { deepClone } from "@cyia/util";
+import * as v4 from "valibot";
+function createChatStream(input) {
+  const result = getModelConfig(input);
+  return (context, options, extra) => {
+    context.messages = deepClone(context.messages);
+    const PiPUserConvertDefine = v4.pipe(
+      UserChatMessage,
+      v4.transform(
+        (item) => ({
+          role: "user",
+          timestamp: Date.now(),
+          content: item.content.map((item2) => {
+            if (item2.type === "text") {
+              return item2;
+            } else {
+              const match = item2.image_url.url.match(
+                /^data:([^;]+);base64,(.+)$/
+              );
+              return {
+                type: "image",
+                mimeType: match[1],
+                data: match[2]
+              };
+            }
+          })
+        })
+      )
+    );
+    const PiPAssConvertDefine = v4.pipe(
+      AssistantChatMessage,
+      v4.transform(
+        (item) => ({
+          role: "assistant",
+          timestamp: Date.now(),
+          content: item.content.map((item2) => item2),
+          api: result.model.api,
+          provider: result.model.provider,
+          usage: {
+            cacheRead: 0,
+            cacheWrite: 0,
+            cost: {
+              input: 0,
+              output: 0,
+              cacheRead: 0,
+              cacheWrite: 0,
+              total: 0
+            },
+            input: 0,
+            output: 0,
+            totalTokens: 0
+          },
+          stopReason: "stop",
+          model: result.model.api
+        })
+      )
+    );
+    const sysIndex = context.messages.findIndex(
+      (item) => item.role === "system"
+    );
+    if (sysIndex !== -1) {
+      const item = context.messages[sysIndex];
+      context.messages.splice(sysIndex, 1);
+      context.systemPrompt = item.content[0].text;
     }
-    instance.init();
-    const 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;
+    const createStream = () => stream(
+      result.model,
+      {
+        ...context,
+        messages: v4.parse(
+          v4.array(v4.union([PiPUserConvertDefine, PiPAssConvertDefine])),
+          context.messages
+        )
+      },
+      {
+        ...options,
+        apiKey: options?.apiKey ?? result.config.apiKey,
+        onPayload(payload, model) {
+          payload = options?.onPayload?.(payload, model) ?? payload;
+          if (model.api === "openai-completions") {
+            return {
+              ...payload,
+              response_format: extra?.response_format
+            };
           }
+          return payload;
         }
-        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;
+    );
+    let currentStream = createStream();
+    const config = extra?.injector?.get(OpenAIConfigToken);
+    return (async function* () {
+      let hasRetry = false;
+      while (true) {
+        let retry = false;
+        for await (const item of currentStream) {
+          if (item.type === "error") {
+            if (item.error.errorMessage?.includes("404") && item.error.errorMessage?.includes(
+              "no router for requested model"
+            ) && !hasRetry) {
+              if (config?.().tryPull?.()) {
+                await config().pullModel?.(input.model);
+                retry = true;
+                break;
+              }
+            }
+          }
+          yield item;
         }
-        return obj;
-      },
-      callTool: (input2, options2) => instance.callTool(input2, options2)
-    };
-  }
-};
+        if (!retry || hasRetry) {
+          break;
+        }
+        hasRetry = true;
+        currentStream = createStream();
+      }
+    })();
+  };
+}
 
-// packages/openai/chat/module.ts
-var OPENAI_MODULE = {
-  provider: [ChatProviderService, ChatHistoryService],
-  token: { OpenAIConfigToken }
-};
+// packages/openai/index.ts
+import { complete, stream as stream2, fauxAssistantMessage as fauxAssistantMessage2, fauxText as fauxText2, fauxThinking } from "@earendil-works/pi-ai";
+
+// packages/openai/chat/util/faux-provider.ts
+import {
+  registerFauxProvider,
+  fauxAssistantMessage,
+  fauxText
+} from "@earendil-works/pi-ai";
+function createDynamicResponse(responseFactory) {
+  return async (context, _options, state) => {
+    const responses = responseFactory(context, state.callCount);
+    const content = Array.isArray(responses) ? responses.map((r) => fauxText(r)) : fauxText(responses);
+    return fauxAssistantMessage(content);
+  };
+}
+function registerMockProvider(options) {
+  const registration = registerFauxProvider(options);
+  return {
+    model: registration.getModel(),
+    setResponses: (responses) => registration.setResponses(responses),
+    unregister: () => registration.unregister()
+  };
+}
 export {
+  AnthropicMessagesCompatSchema,
   AssistantChatCompletionContent,
   AssistantChatMessage,
   ChatCompletionContentPart,
   ChatCompletionContentPartImage,
   ChatCompletionContentPartStr,
-  ChatHistoryService,
-  ChatItemDefine,
+  ChatMessageCommonItemDefine,
   ChatMessageItemDefine,
   ChatMessageListDefine,
-  ChatParamsItemDefine,
-  ChatParamsListDefine,
-  ChatProviderService,
-  InputChatOptionsDefine,
+  CompatSchema,
+  InputChoiceSchema,
+  InputSchema,
+  ModelConfigDefine,
+  ModelSchema,
+  ModelThinkingLevelSchema,
   OPENAI_MODULE,
+  OpenAICompletionsCompatSchema,
   OpenAIConfigToken,
+  OpenAIResponsesCompatSchema,
+  OutputSchema,
   SystemChatCompletionContent,
   SystemChatMessage,
+  ThinkingLevelSchema,
   UserChatCompletionContent,
   UserChatMessage,
-  VendorOptionsDefine,
+  complete,
   createAssistantMessage,
+  createChatStream,
+  createDynamicResponse,
   createSystemMessage,
-  createUserMessage
+  createUserMessage,
+  fauxAssistantMessage2 as fauxAssistantMessage,
+  fauxText2 as fauxText,
+  fauxThinking,
+  getModelConfig,
+  registerMockProvider,
+  stream2 as stream
 };
 //# sourceMappingURL=index.mjs.map