mcard-js 2.1.49 → 2.1.51

package/dist/chunk-KMC566CN.js

@@ -0,0 +1,591 @@
+import {
+  BaseLLMProvider,
+  DEFAULT_PROVIDER,
+  LLMConfig,
+  LLM_PROVIDERS,
+  OllamaProvider
+} from "./chunk-Y4BT6LHA.js";
+import {
+  IO
+} from "./chunk-MPMRBT5R.js";
+import {
+  Either
+} from "./chunk-2KADE3SE.js";
+import {
+  DEFAULT_FALLBACK_MODEL,
+  DEFAULT_OLLAMA_BASE_URL,
+  LLM_DEFAULT_TIMEOUT_SECS
+} from "./chunk-PKLONZCF.js";
+
+// src/ptr/llm/providers/WebLLMProvider.ts
+function asOptionalNumber(value) {
+  return typeof value === "number" ? value : void 0;
+}
+var WebLLMProvider = class extends BaseLLMProvider {
+  provider_name = "webllm";
+  config;
+  engine = null;
+  current_model = null;
+  initialization_promise = null;
+  constructor() {
+    super();
+    this.config = LLM_PROVIDERS["webllm"];
+  }
+  async _get_engine(model_id) {
+    if (this.engine && this.current_model === model_id) {
+      return Either.right(this.engine);
+    }
+    if (this.initialization_promise) {
+      await this.initialization_promise;
+      if (this.engine && this.current_model === model_id) {
+        return Either.right(this.engine);
+      }
+    }
+    this.initialization_promise = (async () => {
+      try {
+        if (typeof window === "undefined") {
+          throw new Error("WebLLM only supports browser environments.");
+        }
+        const windowWithWebLLM = window;
+        let webllm = windowWithWebLLM.webllm;
+        if (!webllm) {
+          try {
+            webllm = await import("@mlc-ai/web-llm");
+          } catch (e) {
+            void e;
+          }
+        }
+        if (!webllm) {
+          throw new Error("WebLLM library not found. Please include @mlc-ai/web-llm or add script tag.");
+        }
+        if (!this.engine) {
+          this.engine = await webllm.CreateMLCEngine(model_id, {
+            initProgressCallback: (report) => {
+              console.debug(`[WebLLM] ${report.text}`);
+            }
+          });
+        } else {
+          await this.engine.reload(model_id);
+        }
+        this.current_model = model_id;
+      } catch (e) {
+        this.engine = null;
+        this.current_model = null;
+        throw e;
+      }
+    })();
+    try {
+      await this.initialization_promise;
+      return Either.right(this.engine);
+    } catch (e) {
+      this.initialization_promise = null;
+      const error = e;
+      return Either.left(`WebLLM init failed: ${error.message || String(e)}`);
+    }
+  }
+  async complete(prompt, params, images) {
+    const model = typeof params.model === "string" ? params.model : this.config.default_model;
+    const engineResult = await this._get_engine(model);
+    if (engineResult.isLeft) return Either.left(engineResult.left);
+    const engine = engineResult.right;
+    try {
+      const completion = await engine.chat.completions.create({
+        messages: [{ role: "user", content: prompt }],
+        temperature: asOptionalNumber(params.temperature),
+        max_tokens: asOptionalNumber(params.max_tokens),
+        top_p: asOptionalNumber(params.top_p),
+        stream: false
+      });
+      const content = completion.choices?.[0]?.message?.content || "";
+      return Either.right(content);
+    } catch (e) {
+      const error = e;
+      return Either.left(`WebLLM completion error: ${error.message || String(e)}`);
+    }
+  }
+  async chat(messages, params) {
+    const model = typeof params.model === "string" ? params.model : this.config.default_model;
+    const engineResult = await this._get_engine(model);
+    if (engineResult.isLeft) return Either.left(engineResult.left);
+    const engine = engineResult.right;
+    try {
+      const completion = await engine.chat.completions.create({
+        messages,
+        temperature: asOptionalNumber(params.temperature),
+        max_tokens: asOptionalNumber(params.max_tokens),
+        top_p: asOptionalNumber(params.top_p),
+        stream: false
+      });
+      const choice = completion.choices?.[0];
+      return Either.right({
+        content: choice?.message?.content || "",
+        role: choice?.message?.role || "assistant",
+        model,
+        usage: completion.usage
+      });
+    } catch (e) {
+      const error = e;
+      return Either.left(`WebLLM chat error: ${error.message || String(e)}`);
+    }
+  }
+  async validate_connection() {
+    if (typeof window === "undefined") return false;
+    if (window.webllm) return true;
+    try {
+      await import("@mlc-ai/web-llm");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async list_models() {
+    return Either.right(this.config.available_models);
+  }
+};
+
+// src/ptr/llm/providers/MLCLLMProvider.ts
+import * as http from "http";
+import * as https from "https";
+var MLCLLMProvider = class extends BaseLLMProvider {
+  provider_name = "mlc-llm";
+  base_url;
+  timeout;
+  config;
+  constructor(base_url = null, timeout = LLM_DEFAULT_TIMEOUT_SECS) {
+    super();
+    this.config = LLM_PROVIDERS["mlc-llm"];
+    this.base_url = (base_url || this.config.base_url).replace(/\/$/, "");
+    this.timeout = timeout * 1e3;
+  }
+  async _fetch_json(endpoint, options) {
+    if (typeof globalThis.fetch === "function") {
+      try {
+        const controller = new AbortController();
+        const id = setTimeout(() => controller.abort(), this.timeout);
+        const response = await fetch(`${this.base_url}${endpoint}`, {
+          ...options,
+          signal: controller.signal
+        });
+        clearTimeout(id);
+        if (!response.ok) {
+          return Either.left(`HTTP error ${response.status}: ${await response.text()}`);
+        }
+        const data = await response.json();
+        return Either.right(data);
+      } catch (e) {
+        const error = e;
+        return Either.left(`Connection error: ${error.message || String(e)}`);
+      }
+    }
+    return this._node_request(endpoint, options);
+  }
+  _node_request(endpoint, options) {
+    const urlStr = `${this.base_url}${endpoint}`;
+    const url = new URL(urlStr);
+    const isHttps = url.protocol === "https:";
+    const client = isHttps ? https : http;
+    const reqOptions = {
+      method: options.method || "GET",
+      headers: options.headers || {},
+      timeout: this.timeout
+    };
+    return new Promise((resolve) => {
+      const req = client.request(url, reqOptions, (res) => {
+        let body = "";
+        res.on("data", (chunk) => body += chunk);
+        res.on("end", () => {
+          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+            try {
+              resolve(Either.right(JSON.parse(body)));
+            } catch (e) {
+              resolve(Either.left(`Parse error: ${e}`));
+            }
+          } else {
+            resolve(Either.left(`HTTP Error ${res.statusCode}: ${body}`));
+          }
+        });
+      });
+      req.on("error", (e) => resolve(Either.left(e.message)));
+      req.on("timeout", () => {
+        req.destroy();
+        resolve(Either.left("Request timed out"));
+      });
+      if (options.body) {
+        req.write(options.body);
+      }
+      req.end();
+    });
+  }
+  async complete(prompt, params, images) {
+    const data = {
+      model: typeof params.model === "string" ? params.model : this.config.default_model,
+      messages: [{ role: "user", content: prompt }],
+      max_tokens: params.max_tokens,
+      temperature: params.temperature,
+      top_p: params.top_p,
+      stream: false
+    };
+    const result = await this._fetch_json(this.config.api_path, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(data)
+    });
+    if (result.isLeft) return Either.left(result.left);
+    const response = result.right;
+    if (response.choices && response.choices.length > 0) {
+      return Either.right(response.choices[0].text || "");
+    }
+    return Either.left(`Unexpected response format: ${JSON.stringify(response)}`);
+  }
+  async chat(messages, params) {
+    const data = {
+      model: params.model || this.config.default_model,
+      messages,
+      max_tokens: params.max_tokens,
+      temperature: params.temperature,
+      top_p: params.top_p,
+      stream: false
+    };
+    const result = await this._fetch_json(this.config.chat_path, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(data)
+    });
+    if (result.isLeft) return Either.left(result.left);
+    const response = result.right;
+    if (response.choices && response.choices.length > 0) {
+      const message = response.choices[0].message;
+      return Either.right({
+        content: message?.content || "",
+        role: message?.role || "assistant",
+        model: response.model,
+        usage: response.usage
+      });
+    }
+    return Either.left(`Unexpected response format: ${JSON.stringify(response)}`);
+  }
+  async validate_connection() {
+    const result = await this._fetch_json(this.config.models_path, { method: "GET" });
+    return result.isRight;
+  }
+  async list_models() {
+    const result = await this._fetch_json(this.config.models_path, { method: "GET" });
+    if (result.isLeft) return Either.left(result.left);
+    const response = result.right;
+    if (response.data && Array.isArray(response.data)) {
+      return Either.right(response.data.map((m) => m.id).filter((id) => typeof id === "string"));
+    }
+    return Either.left("Invalid models response");
+  }
+};
+
+// src/ptr/llm/IntelligenceRouter.ts
+import * as http2 from "http";
+import * as https2 from "https";
+var IntelligenceRouter = class {
+  localUrl;
+  localModel;
+  constructor(localUrl, localModel) {
+    this.localUrl = localUrl ?? DEFAULT_OLLAMA_BASE_URL;
+    this.localModel = localModel ?? DEFAULT_FALLBACK_MODEL;
+  }
+  /**
+   * Probe a remote provider URL with a lightweight HTTP request.
+   * Returns true if reachable within the timeout.
+   */
+  async probeConnection(providerUrl, timeoutMs = 2e3) {
+    return new Promise((resolve) => {
+      try {
+        const url = new URL(providerUrl);
+        const client = url.protocol === "https:" ? https2 : http2;
+        const req = client.get(url, { timeout: timeoutMs }, (res) => {
+          res.resume();
+          resolve(true);
+        });
+        req.on("error", () => {
+          resolve(false);
+        });
+        req.on("timeout", () => {
+          req.destroy();
+          resolve(false);
+        });
+      } catch {
+        resolve(false);
+      }
+    });
+  }
+  /**
+   * Returns the (provider, model, baseUrl) tuple that is optimal.
+   * Currently favors the requested configuration unless a failure explicitly overrides it.
+   */
+  getOptimalProvider(requestedProvider, requestedModel, requestedUrl = null) {
+    return { provider: requestedProvider, model: requestedModel, url: requestedUrl };
+  }
+  /**
+   * Handle a provider failure and return fallback configuration + warning message.
+   */
+  handleFailure(failedProvider, error) {
+    const errorName = error instanceof Error ? error.constructor.name : "Error";
+    const warning = `Adaptive Fallback Triggered: Provider '${failedProvider}' failed with ${errorName}. Defaulting to Edge Fallback [${this.localModel}] via Ollama.`;
+    console.warn(`[IntelligenceRouter] ${warning}`);
+    return {
+      provider: "ollama",
+      model: this.localModel,
+      url: this.localUrl,
+      warning
+    };
+  }
+};
+
+// src/ptr/llm/LLMRuntime.ts
+function get_provider(provider_name = DEFAULT_PROVIDER, base_url = null, timeout = LLM_DEFAULT_TIMEOUT_SECS) {
+  if (provider_name === "ollama") {
+    return new OllamaProvider(base_url, timeout);
+  }
+  if (provider_name === "webllm") {
+    return new WebLLMProvider();
+  }
+  if (provider_name === "mlc-llm") {
+    return new MLCLLMProvider(base_url, timeout);
+  }
+  throw new Error(`Unknown provider: ${provider_name}`);
+}
+var LLMRuntime = class {
+  provider_name;
+  _provider = null;
+  constructor(provider_name = DEFAULT_PROVIDER) {
+    this.provider_name = provider_name;
+  }
+  get provider() {
+    if (!this._provider) {
+      this._provider = get_provider(this.provider_name);
+    }
+    return this._provider;
+  }
+  async execute(codeOrPath, context, config, chapterDir) {
+    let configCtx = {};
+    if (typeof context === "object" && context !== null) {
+      configCtx = context;
+    }
+    const concrete = config;
+    const llmConfig = LLMConfig.from_concrete(concrete, configCtx);
+    if (llmConfig.provider !== this.provider_name || llmConfig.endpoint_url) {
+      this.provider_name = llmConfig.provider;
+      this._provider = get_provider(llmConfig.provider, llmConfig.endpoint_url, llmConfig.timeout);
+    }
+    let prompt = "";
+    let images;
+    if (typeof context === "string") {
+      prompt = context;
+    } else if (context && typeof context === "object") {
+      const ctx = context;
+      if (typeof ctx.prompt === "string") {
+        prompt = ctx.prompt;
+        if (Array.isArray(ctx.images)) {
+          images = ctx.images;
+        }
+      } else {
+        prompt = JSON.stringify(context);
+      }
+    }
+    const router = new IntelligenceRouter();
+    const attemptExecution = async (cfg) => {
+      if (cfg.provider !== this.provider_name || cfg.endpoint_url) {
+        this.provider_name = cfg.provider;
+        this._provider = get_provider(cfg.provider, cfg.endpoint_url, cfg.timeout);
+      }
+      if (cfg.system_prompt) {
+        return this._execute_chat(prompt, cfg, images);
+      } else {
+        return this._execute_completion(prompt, cfg, images);
+      }
+    };
+    let result = await attemptExecution(llmConfig);
+    if (result.isLeft) {
+      const errMsg = String(result.left).toLowerCase();
+      if (errMsg.includes("timeout") || errMsg.includes("connection") || errMsg.includes("failed")) {
+        const fallback = router.handleFailure(llmConfig.provider, new Error(String(result.left)));
+        if (configCtx) {
+          if (!Array.isArray(configCtx.execution_warnings)) {
+            configCtx.execution_warnings = [];
+          }
+          configCtx.execution_warnings.push(fallback.warning);
+        }
+        llmConfig.provider = fallback.provider;
+        llmConfig.model = fallback.model;
+        llmConfig.endpoint_url = fallback.url;
+        this.provider_name = fallback.provider;
+        this._provider = null;
+        result = await attemptExecution(llmConfig);
+      }
+    }
+    if (result.isLeft) {
+      return `Error: ${result.left}`;
+    }
+    return this._format_response(result.right, llmConfig, configCtx);
+  }
+  async _execute_completion(prompt, config, images) {
+    const params = config.to_provider_params();
+    return this.provider.complete(prompt, params, images);
+  }
+  async _execute_chat(prompt, config, images) {
+    const messages = [];
+    if (config.system_prompt) {
+      messages.push({ role: "system", content: config.system_prompt });
+    }
+    const userMsg = { role: "user", content: prompt };
+    if (images && images.length > 0) {
+      userMsg.images = images;
+    }
+    messages.push(userMsg);
+    if (config.assistant_instruction) {
+      messages.push({ role: "assistant", content: config.assistant_instruction });
+    }
+    const params = config.to_provider_params();
+    return this.provider.chat(messages, params);
+  }
+  _format_response(response, config, context) {
+    let content = response;
+    if (response && typeof response === "object" && "content" in response) {
+      content = response.content;
+    }
+    if (typeof content === "string" && content.includes("<think>")) {
+      const regex = /<think>([\s\S]*?)<\/think>/g;
+      let match;
+      let thinkingBlocks = [];
+      while ((match = regex.exec(content)) !== null) {
+        if (match[1]) {
+          thinkingBlocks.push(match[1].trim());
+        }
+      }
+      if (thinkingBlocks.length > 0 && context) {
+        context.thinking_process = thinkingBlocks.join("\n\n");
+      }
+      content = content.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
+    }
+    if (config.response_format === "json") {
+      try {
+        if (typeof content === "string") {
+          const start = content.indexOf("{");
+          const end = content.lastIndexOf("}") + 1;
+          if (start >= 0 && end > start) {
+            return JSON.parse(content.substring(start, end));
+          }
+        }
+        return content;
+      } catch (e) {
+        return content;
+      }
+    }
+    return content;
+  }
+};
+function promptMonad(prompt, config = {}) {
+  return IO.of(async () => {
+    try {
+      const llmConfig = new LLMConfig(config);
+      const router = new IntelligenceRouter();
+      const runtime = new LLMRuntime(llmConfig.provider);
+      const params = llmConfig.to_provider_params();
+      let result = await runtime.provider.complete(prompt, params);
+      if (result.isLeft) {
+        const errMsg = String(result.left).toLowerCase();
+        if (errMsg.includes("timeout") || errMsg.includes("connection") || errMsg.includes("failed")) {
+          const fallback = router.handleFailure(llmConfig.provider, new Error(String(result.left)));
+          llmConfig.provider = fallback.provider;
+          llmConfig.model = fallback.model;
+          llmConfig.endpoint_url = fallback.url;
+          const fallbackRuntime = new LLMRuntime(fallback.provider);
+          result = await fallbackRuntime.provider.complete(prompt, llmConfig.to_provider_params());
+        }
+      }
+      if (result.isRight) {
+        let response = result.right;
+        let content = typeof response === "string" ? response : response.content || "";
+        if (typeof content === "string" && content.includes("<think>")) {
+          const regex = /<think>([\s\S]*?)<\/think>/g;
+          let match;
+          let thinkingBlocks = [];
+          while ((match = regex.exec(content)) !== null) {
+            if (match[1]) thinkingBlocks.push(match[1].trim());
+          }
+          content = content.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
+          if (typeof response === "string") {
+            response = { content, thinking_process: thinkingBlocks.join("\n\n") };
+          } else {
+            response.content = content;
+            response.thinking_process = thinkingBlocks.join("\n\n");
+          }
+          result = Either.right(response);
+        }
+      }
+      return result;
+    } catch (e) {
+      return Either.left(`LLM execution failed: ${e}`);
+    }
+  });
+}
+function chatMonad(messages = null, prompt = null, system_prompt = "", config = {}) {
+  return IO.of(async () => {
+    try {
+      const router = new IntelligenceRouter();
+      const configData = { ...config };
+      if (system_prompt) configData.system_prompt = system_prompt;
+      const llmConfig = new LLMConfig(configData);
+      const msgs = messages ? [...messages] : [];
+      if (msgs.length === 0) {
+        if (llmConfig.system_prompt) {
+          msgs.push({ role: "system", content: llmConfig.system_prompt });
+        }
+        if (prompt) {
+          msgs.push({ role: "user", content: prompt });
+        }
+        if (llmConfig.assistant_instruction) {
+          msgs.push({ role: "assistant", content: llmConfig.assistant_instruction });
+        }
+      }
+      const attemptChat = async (cfg) => {
+        const rt = new LLMRuntime(cfg.provider);
+        const params = cfg.to_provider_params();
+        return rt.provider.chat(msgs, params);
+      };
+      let result = await attemptChat(llmConfig);
+      if (result.isLeft) {
+        const errMsg = String(result.left).toLowerCase();
+        if (errMsg.includes("timeout") || errMsg.includes("connection") || errMsg.includes("failed")) {
+          const fallback = router.handleFailure(llmConfig.provider, new Error(String(result.left)));
+          llmConfig.provider = fallback.provider;
+          llmConfig.model = fallback.model;
+          llmConfig.endpoint_url = fallback.url;
+          result = await attemptChat(llmConfig);
+        }
+      }
+      if (result.isRight) {
+        let response = result.right;
+        let content = response.content || "";
+        if (typeof content === "string" && content.includes("<think>")) {
+          const regex = /<think>([\s\S]*?)<\/think>/g;
+          let match;
+          let thinkingBlocks = [];
+          while ((match = regex.exec(content)) !== null) {
+            if (match[1]) thinkingBlocks.push(match[1].trim());
+          }
+          content = content.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
+          response.content = content;
+          response.thinking_process = thinkingBlocks.join("\n\n");
+          result = Either.right(response);
+        }
+      }
+      return result;
+    } catch (e) {
+      return Either.left(`LLM chat failed: ${e}`);
+    }
+  });
+}
+
+export {
+  get_provider,
+  LLMRuntime,
+  promptMonad,
+  chatMonad
+};