@aituber-onair/chat 0.56.0 → 0.57.0

package/dist/umd/aituber-onair-chat.js

@@ -252,6 +252,7 @@ var AITuberOnAirChat = (() => {
     MODEL_ZAI_GLM_5_3_FLASH: () => MODEL_ZAI_GLM_5_3_FLASH,
     MistralChatService: () => MistralChatService,
     MistralChatServiceProvider: () => MistralChatServiceProvider,
+    OPENAI_COMPATIBLE_LOCAL_PRESETS: () => OPENAI_COMPATIBLE_LOCAL_PRESETS,
     OPENROUTER_CREDITS_THRESHOLD: () => OPENROUTER_CREDITS_THRESHOLD,
     OPENROUTER_DEPRECATED_MODELS: () => OPENROUTER_DEPRECATED_MODELS,
     OPENROUTER_FREE_DAILY_LIMIT_HIGH_CREDITS: () => OPENROUTER_FREE_DAILY_LIMIT_HIGH_CREDITS,
@@ -262,6 +263,7 @@ var AITuberOnAirChat = (() => {
     OpenAIChatService: () => OpenAIChatService,
     OpenAIChatServiceProvider: () => OpenAIChatServiceProvider,
     OpenAICompatibleChatServiceProvider: () => OpenAICompatibleChatServiceProvider,
+    OpenAICompatibleEndpointError: () => OpenAICompatibleEndpointError,
     OpenRouterChatService: () => OpenRouterChatService,
     OpenRouterChatServiceProvider: () => OpenRouterChatServiceProvider,
     PLAMO_API_BASE_URL: () => PLAMO_API_BASE_URL,
@@ -333,6 +335,7 @@ var AITuberOnAirChat = (() => {
     isZaiReasoningEffortModel: () => isZaiReasoningEffortModel,
     isZaiToolStreamModel: () => isZaiToolStreamModel,
     isZaiVisionModel: () => isZaiVisionModel,
+    listOpenAICompatibleModels: () => listOpenAICompatibleModels,
     normalizeClaudeReasoningEffort: () => normalizeClaudeReasoningEffort,
     normalizeDeepSeekReasoningEffort: () => normalizeDeepSeekReasoningEffort,
     normalizeGeminiReasoningEffort: () => normalizeGeminiReasoningEffort,
@@ -344,11 +347,13 @@ var AITuberOnAirChat = (() => {
     parseOpenAICompatibleToolStream: () => parseOpenAICompatibleToolStream,
     processChatWithOptionalTools: () => processChatWithOptionalTools,
     refreshOpenRouterFreeModels: () => refreshOpenRouterFreeModels,
+    resolveOpenAICompatibleEndpoint: () => resolveOpenAICompatibleEndpoint,
     resolveVisionModel: () => resolveVisionModel,
     runOnceText: () => runOnceText,
     safeJsonParse: () => safeJsonParse,
     safeParseToolCallInput: () => safeParseToolCallInput,
     screenplayToText: () => screenplayToText,
+    testOpenAICompatibleConnection: () => testOpenAICompatibleConnection,
     textToScreenplay: () => textToScreenplay,
     textsToScreenplay: () => textsToScreenplay
   });
@@ -1826,6 +1831,192 @@ If it's in another language, summarize in that language.
     };
   }
 
+  // src/utils/openaiCompatibleEndpoint.ts
+  var OPENAI_COMPATIBLE_LOCAL_PRESETS = [
+    {
+      id: "ollama",
+      label: "Ollama",
+      baseUrl: "http://localhost:11434/v1",
+      docsUrl: "https://docs.ollama.com/api/openai-compatibility",
+      corsHint: "Set OLLAMA_ORIGINS to allow additional browser origins."
+    },
+    {
+      id: "lmStudio",
+      label: "LM Studio",
+      baseUrl: "http://localhost:1234/v1",
+      docsUrl: "https://lmstudio.ai/docs/developer/openai-compat",
+      corsHint: "Start the server with lms server start --cors for browser access."
+    },
+    {
+      id: "llamaCpp",
+      label: "llama.cpp",
+      baseUrl: "http://127.0.0.1:8080/v1",
+      docsUrl: "https://github.com/ggml-org/llama.cpp/blob/master/tools/server/README.md",
+      corsHint: "All origins are allowed by default; use --cors-origins to restrict them."
+    },
+    {
+      id: "vllm",
+      label: "vLLM",
+      baseUrl: "http://localhost:8000/v1",
+      docsUrl: "https://docs.vllm.ai/en/latest/serving/online_serving/openai_compatible_server/",
+      corsHint: "All origins are allowed by default; use --allowed-origins to restrict them."
+    }
+  ];
+  var OpenAICompatibleEndpointError = class extends Error {
+    constructor(code, message, status) {
+      super(message);
+      this.name = "OpenAICompatibleEndpointError";
+      this.code = code;
+      this.status = status;
+    }
+  };
+  function resolveOpenAICompatibleEndpoint(input) {
+    let url;
+    try {
+      url = new URL(input.trim());
+    } catch {
+      throw new OpenAICompatibleEndpointError(
+        "invalid-url",
+        "Enter a valid HTTP or HTTPS endpoint URL."
+      );
+    }
+    if (url.protocol !== "http:" && url.protocol !== "https:" || url.search || url.hash || url.username || url.password) {
+      throw new OpenAICompatibleEndpointError(
+        "invalid-url",
+        "Use an HTTP or HTTPS endpoint URL without credentials, a query, or a fragment."
+      );
+    }
+    const path = url.pathname.replace(/\/+$/, "");
+    if (path.endsWith("/api/chat") || path.endsWith("/api/generate")) {
+      throw new OpenAICompatibleEndpointError(
+        "invalid-url",
+        "This looks like Ollama's native API URL. Use the OpenAI-compatible base URL instead, e.g. http://localhost:11434/v1."
+      );
+    }
+    const basePath = !path || path === "/" ? "/v1" : path.endsWith("/chat/completions") ? path.slice(0, -"/chat/completions".length) : path;
+    const baseUrl = `${url.origin}${basePath}`;
+    return {
+      baseUrl,
+      chatCompletionsUrl: `${baseUrl}/chat/completions`,
+      modelsUrl: `${baseUrl}/models`
+    };
+  }
+  async function listOpenAICompatibleModels(options) {
+    const { modelsUrl } = resolveOpenAICompatibleEndpoint(options.endpoint);
+    const timeoutMs = options.timeoutMs ?? 8e3;
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+      throw new RangeError("timeoutMs must be a positive finite number.");
+    }
+    if (options.signal?.aborted) {
+      throw new OpenAICompatibleEndpointError(
+        "aborted",
+        "The models request was aborted by the caller."
+      );
+    }
+    const controller = new AbortController();
+    let abortCause;
+    const onAbort = () => {
+      if (!abortCause) abortCause = "caller";
+      controller.abort();
+    };
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+    if (options.signal?.aborted) onAbort();
+    const timeout = setTimeout(() => {
+      if (!abortCause) abortCause = "timeout";
+      controller.abort();
+    }, timeoutMs);
+    try {
+      const headers = {};
+      if (options.apiKey?.trim()) {
+        headers.Authorization = `Bearer ${options.apiKey.trim()}`;
+      }
+      const response = await (options.fetch ?? fetch)(modelsUrl, {
+        method: "GET",
+        headers,
+        signal: controller.signal
+      });
+      if (abortCause) {
+        throw new OpenAICompatibleEndpointError(
+          "aborted",
+          "The models request was aborted by the caller."
+        );
+      }
+      if (!response.ok) {
+        throw new OpenAICompatibleEndpointError(
+          "http",
+          `Model listing failed with HTTP ${response.status}.`,
+          response.status
+        );
+      }
+      let body;
+      try {
+        body = await response.json();
+      } catch {
+        throw new OpenAICompatibleEndpointError(
+          "invalid-response",
+          "The models endpoint did not return valid JSON."
+        );
+      }
+      if (!body || typeof body !== "object" || !("data" in body) || !Array.isArray(body.data) || !body.data.every(
+        (model) => model && typeof model === "object" && "id" in model && typeof model.id === "string"
+      )) {
+        throw new OpenAICompatibleEndpointError(
+          "invalid-response",
+          "The models response must contain data with model IDs."
+        );
+      }
+      if (abortCause) {
+        throw new OpenAICompatibleEndpointError(
+          "aborted",
+          "The models request was aborted by the caller."
+        );
+      }
+      return [...new Set(body.data.map((model) => model.id))];
+    } catch (error) {
+      if (abortCause === "caller") {
+        throw new OpenAICompatibleEndpointError(
+          "aborted",
+          "The models request was aborted by the caller."
+        );
+      }
+      if (abortCause === "timeout") {
+        throw new OpenAICompatibleEndpointError(
+          "timeout",
+          `The models request timed out after ${timeoutMs} ms.`
+        );
+      }
+      if (error instanceof OpenAICompatibleEndpointError) throw error;
+      throw new OpenAICompatibleEndpointError(
+        "network",
+        "Could not reach the models endpoint. In a browser, this is usually a CORS restriction or the server is not running."
+      );
+    } finally {
+      clearTimeout(timeout);
+      options.signal?.removeEventListener("abort", onAbort);
+    }
+  }
+  async function testOpenAICompatibleConnection(options) {
+    const startedAt = Date.now();
+    try {
+      const models = await listOpenAICompatibleModels(options);
+      return {
+        ok: true,
+        latencyMs: Date.now() - startedAt,
+        models,
+        ...options.model !== void 0 ? { modelFound: models.includes(options.model) } : {}
+      };
+    } catch (error) {
+      if (error instanceof RangeError) throw error;
+      return {
+        ok: false,
+        error: error instanceof OpenAICompatibleEndpointError ? error : new OpenAICompatibleEndpointError(
+          "network",
+          "Could not reach the models endpoint. In a browser, this is usually a CORS restriction or the server is not running."
+        )
+      };
+    }
+  }
+
   // src/utils/openaiCompatibleTools.ts
   var buildOpenAICompatibleTools = (tools, format = "chat-completions") => {
     if (tools.length === 0) return [];