mcard-js 2.1.41 → 2.1.43

package/dist/chunk-23GCCCXB.js

@@ -1,402 +0,0 @@
-import {
-  IO
-} from "./chunk-MPMRBT5R.js";
-import {
-  BaseLLMProvider,
-  DEFAULT_PROVIDER,
-  LLMConfig,
-  LLM_PROVIDERS,
-  OllamaProvider
-} from "./chunk-QXPHMSPA.js";
-import {
-  Either
-} from "./chunk-2KADE3SE.js";
-
-// src/ptr/llm/providers/WebLLMProvider.ts
-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.");
-        }
-        let webllm = window.webllm;
-        if (!webllm) {
-          try {
-            webllm = await import("@mlc-ai/web-llm");
-          } catch (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;
-      return Either.left(`WebLLM init failed: ${e.message || e}`);
-    }
-  }
-  async complete(prompt, params) {
-    const model = 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: params.temperature,
-        max_tokens: params.max_tokens,
-        top_p: params.top_p,
-        stream: false
-      });
-      const content = completion.choices[0]?.message?.content || "";
-      return Either.right(content);
-    } catch (e) {
-      return Either.left(`WebLLM completion error: ${e.message || e}`);
-    }
-  }
-  async chat(messages, params) {
-    const model = 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: params.temperature,
-        max_tokens: params.max_tokens,
-        top_p: 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) {
-      return Either.left(`WebLLM chat error: ${e.message || 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 = 120) {
-    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) {
-        return Either.left(`Connection error: ${e.message}`);
-      }
-    }
-    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) {
-    const data = {
-      model: params.model || this.config.default_model,
-      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,
-        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));
-    }
-    return Either.left("Invalid models response");
-  }
-};
-
-// src/ptr/llm/LLMRuntime.ts
-function get_provider(provider_name = DEFAULT_PROVIDER, base_url = null, timeout = 120) {
-  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) {
-      this._provider = get_provider(llmConfig.provider, llmConfig.endpoint_url, llmConfig.timeout);
-    }
-    let prompt = "";
-    if (typeof context === "string") {
-      prompt = context;
-    } else {
-      prompt = JSON.stringify(context);
-    }
-    let result;
-    if (llmConfig.system_prompt) {
-      result = await this._execute_chat(prompt, llmConfig);
-    } else {
-      result = await this._execute_completion(prompt, llmConfig);
-    }
-    if (result.isLeft) {
-      return `Error: ${result.left}`;
-    }
-    return this._format_response(result.right, llmConfig);
-  }
-  async _execute_completion(prompt, config) {
-    const params = config.to_provider_params();
-    return this.provider.complete(prompt, params);
-  }
-  async _execute_chat(prompt, config) {
-    const messages = [];
-    if (config.system_prompt) {
-      messages.push({ role: "system", content: config.system_prompt });
-    }
-    messages.push({ role: "user", content: prompt });
-    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) {
-    let content = response;
-    if (response && typeof response === "object" && "content" in response) {
-      content = response.content;
-    }
-    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 runtime = new LLMRuntime(llmConfig.provider);
-      const params = llmConfig.to_provider_params();
-      return runtime.provider.complete(prompt, params);
-    } catch (e) {
-      return Either.left(`LLM execution failed: ${e}`);
-    }
-  });
-}
-function chatMonad(messages = null, prompt = null, system_prompt = "", config = {}) {
-  return IO.of(async () => {
-    try {
-      const configData = { ...config };
-      if (system_prompt) configData.system_prompt = system_prompt;
-      const llmConfig = new LLMConfig(configData);
-      const runtime = new LLMRuntime(llmConfig.provider);
-      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 params = llmConfig.to_provider_params();
-      return runtime.provider.chat(msgs, params);
-    } catch (e) {
-      return Either.left(`LLM chat failed: ${e}`);
-    }
-  });
-}
-
-export {
-  get_provider,
-  LLMRuntime,
-  promptMonad,
-  chatMonad
-};