@anvaka/vue-llm 0.1.0

package/README.md

@@ -0,0 +1,166 @@
+# @anvaka/vue-llm (WIP)
+
+Browser-only LLM client + Vue 3 plugin, provider adapters, and lightweight components.
+
+## Features
+- Provider factory with 8 built-in providers (OpenAI, Anthropic, Grok, Gemini, Ollama, Llama Server, OpenRouter, Custom) – extend with `registerProvider()`
+- LocalStorage-based config store (custom storage adapter supported)
+- Streaming + promise requests via `llmClient.stream()`
+- Vue plugin for dependency injection
+- `useLLM()` composable with reactive streaming state
+- Ready-to-use components: `ProviderSelector`, `LLMConfigModal`, `StoredKeysManager`
+- CSS variable theming (`--llm-*` tokens)
+
+## Quick Start
+```js
+import { createApp } from 'vue'
+import App from './App.vue'
+import { LLMPlugin } from '@anvaka/vue-llm'
+import '@anvaka/vue-llm/styles/variables.css'
+
+createApp(App)
+  .use(LLMPlugin, { autoInit: false, namespace: 'myllm' })
+  .mount('#app')
+```
+
+## Components
+
+### ProviderSelector
+Dropdown to switch between configured providers.
+```vue
+<script setup>
+import { ProviderSelector } from '@anvaka/vue-llm'
+</script>
+<template>
+  <ProviderSelector @changed="onProviderChanged" @open-config="showModal = true" />
+</template>
+```
+
+### LLMConfigModal
+Full configuration modal for managing providers (add, edit, test, delete).
+```vue
+<script setup>
+import { ref } from 'vue'
+import { LLMConfigModal } from '@anvaka/vue-llm'
+const showConfig = ref(false)
+</script>
+<template>
+  <LLMConfigModal 
+    :is-visible="showConfig" 
+    @close="showConfig = false"
+    @config-changed="onConfigChanged" 
+  />
+</template>
+```
+
+Props:
+- `isVisible` (Boolean) – controls modal visibility
+- `editTarget` (Object) – optional config to edit directly
+- `showJudge` (Boolean) – enable judge mode UI
+- `showAllMode` (Boolean) – show all providers including disabled
+
+Events:
+- `close` – emitted when modal closes
+- `configChanged` – emitted when a provider config is saved/deleted
+
+### StoredKeysManager
+Manage stored API keys separately from provider configs.
+```vue
+<script setup>
+import { StoredKeysManager } from '@anvaka/vue-llm'
+</script>
+<template>
+  <StoredKeysManager @close="closeManager" @keysUpdated="refreshUI" />
+</template>
+```
+
+## useLLM Composable
+Access the LLM client, config store, and key store with reactive helpers.
+```js
+import { useLLM } from '@anvaka/vue-llm'
+
+const {
+  // Core objects
+  client,              // LLMClient instance
+  configStore,         // ConfigStore instance
+  keyStore,            // KeyStore instance
+
+  // Streaming with reactive state
+  stream,              // (messages, options) => Promise - stream with reactive updates
+  isStreaming,         // ref<boolean>
+  streamContent,       // ref<string> - accumulated response
+  streamThinking,      // ref<string> - accumulated thinking content
+
+  // Config management
+  getEnabledConfigs,   // () => config[] - enabled providers only
+  getAllConfigs,       // () => config[] - all providers including disabled
+  getActiveConfig,     // () => config | null
+  getActiveProviderId, // () => string | null
+  setActiveProviderId, // (id) => boolean
+  saveConfig,          // (id, config) => boolean
+  deleteConfig,        // (id) => boolean
+  enableProvider,      // (id) => boolean
+  disableProvider,     // (id) => boolean
+  getAvailableModels,  // (providerType, config) => Promise<string[]>
+  testConnection,      // (config) => Promise<string>
+  refresh,             // () => Promise<void>
+
+  // Key management
+  getStoredKey,        // (id) => string | null
+  storeKey,            // (id, apiKey, options) => boolean
+  deleteStoredKey,     // (id) => boolean
+  hasStoredKey,        // (providerType) => boolean
+  getAllStoredKeys,    // () => Record<string, KeyData>
+  getStoredKeyMeta     // (id) => KeyMeta | null
+} = useLLM()
+```
+
+## Non-Vue Usage
+For scripts outside Vue components, use the singleton exports:
+```js
+import { llmClient, configStore, keyStore } from '@anvaka/vue-llm'
+
+// Stream directly
+await llmClient.stream({ messages: [...] }, chunk => console.log(chunk.fullContent))
+
+// Manage configs
+configStore.saveConfig('my-provider', { ... })
+configStore.setActiveProviderId('my-provider')
+```
+
+## Theming
+Override any `--llm-*` CSS variable globally or per container.
+```css
+:root { --llm-accent: #ff7e41; }
+html[data-theme='light'] { --llm-bg: #fff; }
+```
+
+## Extending Providers
+```js
+import { BaseProvider, registerProvider } from '@anvaka/vue-llm/providers'
+
+class MyProvider extends BaseProvider { 
+  /* implement abstract methods */ 
+}
+registerProvider('my-provider', MyProvider)
+```
+
+### Available Exports
+```js
+// From '@anvaka/vue-llm/providers'
+import { 
+  BaseProvider,
+  PROVIDERS,           // { OPENAI, ANTHROPIC, GROK, GEMINI, OLLAMA, LLAMA_SERVER, OPENROUTER, CUSTOM }
+  DEFAULT_CONFIGS,     // Default configs for each provider type
+  createProvider,      // (type, config) => Provider
+  registerProvider,    // (type, ProviderClass) => void
+  createProviderFlexible // (type, config) => Provider (includes custom-registered)
+} from '@anvaka/vue-llm/providers'
+
+// Helper for creating config objects
+import { createDefaultConfig } from '@anvaka/vue-llm'
+const config = createDefaultConfig('openai') // Returns template config object
+```
+
+## License
+MIT

package/dist/_virtual/_plugin-vue_export-helper.js

@@ -0,0 +1,9 @@
+const s = (t, e) => {
+  const o = t.__vccOpts || t;
+  for (const [r, c] of e)
+    o[r] = c;
+  return o;
+};
+export {
+  s as default
+};

package/dist/core/LLMClient.js

@@ -0,0 +1,248 @@
+import { createProviderFlexible as I } from "../providers/factory.js";
+class A {
+  constructor({ configStore: t, logger: s } = {}) {
+    this.configStore = t, this.logger = s || console, this.config = null, this.provider = null, this.usageTracker = null;
+  }
+  async initialize(t = null) {
+    if (this.config = t || this.configStore.getActiveConfig(), !this.config)
+      throw new Error("LLM not configured");
+    this.provider = I(this.config.provider, this.config), await this.provider.initialize(), this.usageTracker = this._createUsageTracker();
+  }
+  async ensureInitialized() {
+    this.provider || await this.initialize();
+  }
+  async refresh() {
+    this.config = null, this.provider = null, await this.initialize();
+  }
+  async testConnection(t) {
+    var r;
+    const s = this.config, i = this.provider;
+    try {
+      await this.initialize(t);
+      const e = [
+        { role: "system", content: 'Respond with exactly "pong"' },
+        { role: "user", content: "ping" }
+      ], n = this.validateCapabilities({
+        model: this.config.model,
+        enableThinking: !1,
+        temperature: 0.1,
+        maxTokens: 10,
+        stream: !1
+      }), o = this.provider.prepareRequest(e, n), a = await this.provider.makeRequest(o);
+      return (r = this.provider.processResponse(a).content) == null ? void 0 : r.trim();
+    } finally {
+      this.config = s, this.provider = i;
+    }
+  }
+  _createUsageTracker() {
+    return {
+      totalTokens: 0,
+      totalCost: 0,
+      recordUsage: (t, s) => {
+        var i;
+        (i = s.usage) != null && i.tokens && (this.totalTokens += s.usage.tokens);
+      },
+      recordPartialUsage: (t) => {
+        t != null && t.tokens && (this.totalTokens += t.tokens);
+      }
+    };
+  }
+  validateCapabilities(t) {
+    var i;
+    if (!this.provider) return t;
+    const s = t.enableThinking !== void 0 ? t.enableThinking : ((i = this.config) == null ? void 0 : i.enableThinking) || !1;
+    return {
+      ...t,
+      enableThinking: s && this.provider.hasCapability("thinking"),
+      images: t.images && this.provider.hasCapability("vision") ? t.images : null,
+      tools: t.tools && this.provider.hasCapability("tools") ? t.tools : null
+    };
+  }
+  async ping() {
+    var n;
+    await this.ensureInitialized();
+    const t = [
+      { role: "system", content: 'Respond with exactly "pong"' },
+      { role: "user", content: "ping" }
+    ], s = this.validateCapabilities({
+      model: this.config.model,
+      temperature: 0.1,
+      maxTokens: 10,
+      stream: !1
+    }), i = this.provider.prepareRequest(t, s), r = await this.provider.makeRequest(i);
+    return (n = this.provider.processResponse(r).content) == null ? void 0 : n.trim();
+  }
+  async stream(t, s) {
+    await this.ensureInitialized();
+    const i = this.validateCapabilities({ ...t, stream: !0, model: t.model || this.config.model, requestId: this.generateRequestId() }), r = t.messages;
+    let e = "";
+    return await this.provider.streamRequest(r, i, (n) => {
+      e = n.fullContent, s && s(n);
+    }), e;
+  }
+  generateRequestId() {
+    return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+  getCapabilities() {
+    return this.provider ? Array.from(this.provider.capabilities) : [];
+  }
+  getUsageStats() {
+    var t, s;
+    return {
+      totalTokens: ((t = this.usageTracker) == null ? void 0 : t.totalTokens) || 0,
+      totalCost: ((s = this.usageTracker) == null ? void 0 : s.totalCost) || 0
+    };
+  }
+  async discoverModels() {
+    return await this.ensureInitialized(), this.provider.discoverModels();
+  }
+  getConfigByName(t) {
+    var r;
+    if (!t || !((r = this.configStore) != null && r.getEnabledConfigs)) return null;
+    const s = t.trim(), i = this.configStore.getEnabledConfigs().filter((e) => this._matchesDisplayName(e, s));
+    if (i.length === 0) return null;
+    if (i.length > 1) {
+      const e = i.map((n) => n.id).join(", ");
+      throw new Error(`Multiple provider presets share the name '${t}'. Conflicting ids: ${e}`);
+    }
+    return i[0];
+  }
+  _matchesDisplayName(t, s) {
+    return !t || !s ? !1 : t.name === s || this._formatDisplayName(t) === s;
+  }
+  _formatDisplayName(t) {
+    const s = (t == null ? void 0 : t.provider) || "provider", i = (t == null ? void 0 : t.baseUrl) || "n/a";
+    return (t == null ? void 0 : t.name) || `${s} (${i})`;
+  }
+  // Compatibility wrapper replicating old createLLMWrapper() dual streaming/promise API.
+  // Provides llm(prompt, opts).into(target, attrs?) and .withOperation(name) chain.
+  createLLMWrapper(t, s = null, i = null) {
+    const r = this;
+    function e(n, o = {}) {
+      return new S(r, t, n, o, s, i);
+    }
+    return e;
+  }
+}
+class S {
+  constructor(t, s, i, r, e, n) {
+    this.client = t, this.contextNode = s, this.prompt = i, this.options = r || {}, this.originatingCode = e, this.defaultPresetName = n, this.targetNode = null, this.targetAttributes = {}, this.operationName = null, this._executed = !1, this._promise = null;
+  }
+  withOperation(t) {
+    return this.operationName = t, this;
+  }
+  into(t, s = {}) {
+    return this.targetNode = t, this.targetAttributes = s, this._ensureExecution(), this;
+  }
+  then(t, s) {
+    return this._ensureExecution(), this._promise.then(t, s);
+  }
+  catch(t) {
+    return this._ensureExecution(), this._promise.catch(t);
+  }
+  finally(t) {
+    return this._ensureExecution(), this._promise.finally(t);
+  }
+  _ensureExecution() {
+    this._executed || (this._executed = !0, this._promise = this._run());
+  }
+  async _run() {
+    var o;
+    const t = await this._createExecutionContext(), { provider: s, config: i } = t;
+    if (!s || !i) throw new Error("LLM not configured");
+    const r = this.client.validateCapabilities.bind({ provider: s, config: i }), e = [];
+    this.options.system && e.push({ role: "system", content: this.options.system }), e.push({ role: "user", content: this.prompt });
+    const n = {
+      model: this.options.model || i.model,
+      temperature: this.options.temperature ?? i.temperature,
+      maxTokens: this.options.maxTokens ?? i.maxTokens,
+      enableThinking: this.options.enableThinking,
+      requestId: this.client.generateRequestId(),
+      ...this.options.images ? { images: this.options.images } : {},
+      ...this.options.tools ? { tools: this.options.tools } : {}
+    };
+    try {
+      if (this.targetNode) {
+        const h = r({ ...n, stream: !0 });
+        return await this._streamIntoTarget(e, h, s, i);
+      }
+      const a = r({ ...n, stream: !1 });
+      return await this._promiseResponse(e, a, s, i);
+    } finally {
+      (o = t.cleanup) == null || o.call(t);
+    }
+  }
+  async _createExecutionContext() {
+    var r, e, n, o;
+    const t = this._resolvePresetName();
+    if (!t)
+      return await this.client.ensureInitialized(), { provider: this.client.provider, config: this.client.config, cleanup: () => {
+      } };
+    if (!this.client.configStore)
+      throw new Error("Provider presets require a configured ConfigStore instance");
+    const s = (e = (r = this.client).getConfigByName) == null ? void 0 : e.call(r, t);
+    if (!s) {
+      const a = (((o = (n = this.client.configStore).getEnabledConfigs) == null ? void 0 : o.call(n)) || []).map((u) => u.name || `${u.provider} (${u.baseUrl})`).filter(Boolean), h = a.length ? ` Available presets: ${a.join(", ")}` : " No configured providers found.";
+      throw new Error(`Provider preset '${t}' not found.${h}`);
+    }
+    const i = I(s.provider, s);
+    return await i.initialize(), { provider: i, config: s, cleanup: () => {
+      var a;
+      return (a = i.cancelAllRequests) == null ? void 0 : a.call(i);
+    } };
+  }
+  _resolvePresetName() {
+    const t = typeof this.options.preset == "string" ? this.options.preset : null, s = typeof this.defaultPresetName == "string" ? this.defaultPresetName : null, i = t || s;
+    return i ? i.trim() : null;
+  }
+  _applyAttributes(t) {
+    var s, i;
+    for (const [r, e] of Object.entries(this.targetAttributes || {}))
+      try {
+        t.setAttribute(r, e);
+      } catch (n) {
+        (i = (s = this.client.logger) == null ? void 0 : s.warn) == null || i.call(s, "Failed to set attribute on target node", { key: r, value: e, error: n });
+      }
+  }
+  async _streamIntoTarget(t, s, i, r) {
+    var c, m, p, f, g, d, v, b, _, w, y, k, T, q;
+    let e, n;
+    typeof this.targetNode == "string" ? (n = this.targetNode, e = this.contextNode.createChild(n), (c = e.setSelected) == null || c.call(e)) : (e = this.targetNode, n = ((m = e.getText) == null ? void 0 : m.call(e)) || ""), this._applyAttributes(e);
+    const o = r == null ? void 0 : r.name;
+    o && e.addTag && e.addTag("provider", o), (p = e.addLLMLog) == null || p.call(e, this.operationName || "streaming-request", {
+      provider: r == null ? void 0 : r.provider,
+      model: r == null ? void 0 : r.model,
+      messages: t,
+      options: s
+    }), (f = e.setStreamingState) == null || f.call(e, !0), e._activeRequestId = s.requestId;
+    let a = "", h = null, u = 0;
+    try {
+      return await i.streamRequest(t, s, (l) => {
+        var C, x, R;
+        l.content && (a = l.fullContent, (C = e.setText) == null || C.call(e, a)), (x = l.usage) != null && x.tokens && (u += l.usage.tokens), l.finishReason && (h = l.finishReason), l.done && ((R = e.setStreamingState) == null || R.call(e, !1), e._activeRequestId = null);
+      }), (g = e.addLLMLog) == null || g.call(e, (this.operationName || "streaming-request") + "-response", { requestId: s.requestId }, { content: a, usage: { tokens: u } }), h === "length" ? ((d = e.setAttribute) == null || d.call(e, "_truncated", !0), (v = e.addLog) == null || v.call(e, "Response truncated. Increase Max Tokens.", "warn", { finish_reason: "length" })) : (b = e.setAttribute) == null || b.call(e, "_truncated", !1), await ((_ = e.persistNow) == null ? void 0 : _.call(e)), e;
+    } catch (l) {
+      throw (w = e.addLLMLog) == null || w.call(e, (this.operationName || "streaming-request") + "-error", { requestId: s.requestId }, null, l), (y = e.setStreamingState) == null || y.call(e, !1), e._activeRequestId = null, (k = e.setText) == null || k.call(e, `Error: ${l.message}`), (T = e.setAttribute) == null || T.call(e, "_truncated", !1), await ((q = e.persistNow) == null ? void 0 : q.call(e)), l;
+    }
+  }
+  async _promiseResponse(t, s, i, r) {
+    var h, u, c, m, p, f, g;
+    const e = i.prepareRequest(t, s), n = await i.makeRequest(e), o = i.processResponse(n);
+    if ((o.finishReason || ((u = (h = n == null ? void 0 : n.choices) == null ? void 0 : h[0]) == null ? void 0 : u.finish_reason) || null) === "length")
+      try {
+        this.contextNode.setAttribute("_truncated", !0);
+      } catch (d) {
+        (m = (c = this.client.logger) == null ? void 0 : c.warn) == null || m.call(c, "Unable to mark node as truncated", { error: d });
+      }
+    else
+      try {
+        this.contextNode.setAttribute("_truncated", !1);
+      } catch (d) {
+        (f = (p = this.client.logger) == null ? void 0 : p.warn) == null || f.call(p, "Unable to clear truncated marker on node", { error: d });
+      }
+    return ((g = o.content) == null ? void 0 : g.trim()) || "";
+  }
+}
+export {
+  A as LLMClient
+};

package/dist/core/configStore.js

@@ -0,0 +1,52 @@
+import { LocalStorageAdapter as r } from "./storageAdapter.js";
+class n {
+  constructor({ storageAdapter: t = null } = {}) {
+    this.storage = t || new r("llm"), this.CONFIGS_KEY = "configs", this.ACTIVE_KEY = "active-provider";
+  }
+  _readConfigs() {
+    const t = this.storage.get(this.CONFIGS_KEY);
+    if (!t) return {};
+    try {
+      return JSON.parse(t);
+    } catch {
+      return {};
+    }
+  }
+  _writeConfigs(t) {
+    try {
+      this.storage.set(this.CONFIGS_KEY, JSON.stringify(t));
+    } catch {
+    }
+  }
+  listConfigs() {
+    return this._readConfigs();
+  }
+  getConfig(t) {
+    return this._readConfigs()[t] || null;
+  }
+  saveConfig(t, i) {
+    const e = this._readConfigs();
+    return e[t] = { ...i, configuredAt: (/* @__PURE__ */ new Date()).toISOString() }, this._writeConfigs(e), !0;
+  }
+  deleteConfig(t) {
+    const i = this._readConfigs();
+    return delete i[t], this._writeConfigs(i), this.getActiveProviderId() === t && this.setActiveProviderId(null), !0;
+  }
+  getActiveProviderId() {
+    return this.storage.get(this.ACTIVE_KEY);
+  }
+  setActiveProviderId(t) {
+    t ? this.storage.set(this.ACTIVE_KEY, t) : this.storage.remove(this.ACTIVE_KEY);
+  }
+  getActiveConfig() {
+    const t = this.getActiveProviderId();
+    return t ? this.getConfig(t) : null;
+  }
+  getEnabledConfigs() {
+    const t = this._readConfigs();
+    return Object.entries(t).filter(([i, e]) => e && e.enabled !== !1 && e.provider && e.baseUrl).map(([i, e]) => ({ id: i, ...e }));
+  }
+}
+export {
+  n as ConfigStore
+};

package/dist/core/keyStore.js

@@ -0,0 +1,58 @@
+const d = "stored-keys";
+class u {
+  constructor(e, t = d) {
+    this.storage = e, this.key = t;
+  }
+  _read() {
+    const e = this.storage.get(this.key);
+    if (!e) return {};
+    try {
+      return JSON.parse(e);
+    } catch {
+      return {};
+    }
+  }
+  _write(e) {
+    try {
+      this.storage.set(this.key, JSON.stringify(e));
+    } catch {
+    }
+  }
+  getAll() {
+    return this._read();
+  }
+  get(e) {
+    var r;
+    return ((r = this._read()[e]) == null ? void 0 : r.apiKey) || null;
+  }
+  set(e, t, r = {}) {
+    const s = this._read(), { providerType: n, serviceEndpoint: o, providerName: a } = r;
+    return s[e] = { apiKey: t, storedAt: (/* @__PURE__ */ new Date()).toISOString(), ...n && { providerType: n }, ...o && { serviceEndpoint: o }, ...a && { providerName: a } }, this._write(s), !0;
+  }
+  delete(e) {
+    const t = this._read();
+    return delete t[e], this._write(t), !0;
+  }
+  has(e) {
+    var r;
+    const t = this._read();
+    return e === "custom" ? Object.values(t).some((s) => s.providerType === "custom") : !!((r = t[e]) != null && r.apiKey);
+  }
+  getForType(e) {
+    const t = this._read(), r = {};
+    for (const [s, n] of Object.entries(t))
+      (n.providerType === e || s === e) && (r[s] = n);
+    return r;
+  }
+  meta(e) {
+    const t = this._read()[e];
+    return t ? { hasKey: !!t.apiKey, storedAt: t.storedAt, maskedKey: t.apiKey ? l(t.apiKey) : null, providerType: t.providerType, serviceEndpoint: t.serviceEndpoint, providerName: t.providerName } : null;
+  }
+}
+function l(i) {
+  return !i || i.length < 12 ? "••••••••" : `${i.substring(0, 8)}••••${i.substring(i.length - 4)}`;
+}
+export {
+  u as KeyStore,
+  l as maskApiKey
+};

package/dist/core/storageAdapter.js

@@ -0,0 +1,67 @@
+class i {
+  constructor(t = "llm") {
+    this.ns = t;
+  }
+  _k(t) {
+    return `${this.ns}:${t}`;
+  }
+  get(t) {
+    try {
+      return localStorage.getItem(this._k(t));
+    } catch {
+      return null;
+    }
+  }
+  set(t, s) {
+    try {
+      localStorage.setItem(this._k(t), s);
+    } catch {
+    }
+  }
+  remove(t) {
+    try {
+      localStorage.removeItem(this._k(t));
+    } catch {
+    }
+  }
+  // List all keys for this namespace (returns object of raw string values)
+  list(t = "") {
+    const s = {};
+    try {
+      const l = this._k(t);
+      for (let r = 0; r < localStorage.length; r++) {
+        const e = localStorage.key(r);
+        e && e.startsWith(this.ns + ":") && e.startsWith(l) && (s[e.slice(this.ns.length + 1)] = localStorage.getItem(e));
+      }
+    } catch {
+    }
+    return s;
+  }
+}
+class h {
+  constructor(t = "llm") {
+    this.ns = t, this.store = /* @__PURE__ */ new Map();
+  }
+  _k(t) {
+    return `${this.ns}:${t}`;
+  }
+  get(t) {
+    return this.store.get(this._k(t)) || null;
+  }
+  set(t, s) {
+    this.store.set(this._k(t), s);
+  }
+  remove(t) {
+    this.store.delete(this._k(t));
+  }
+  list(t = "") {
+    const s = {}, l = this._k(t);
+    for (const [r, e] of this.store.entries())
+      r.startsWith(l) && (s[r.slice(this.ns.length + 1)] = e);
+    return s;
+  }
+}
+export {
+  i as LocalStorageAdapter,
+  h as MemoryStorageAdapter
+};

package/dist/index.js

@@ -0,0 +1,38 @@
+import { LLMClient as l } from "./core/LLMClient.js";
+import { ConfigStore as S } from "./core/configStore.js";
+import { KeyStore as p, maskApiKey as M } from "./core/keyStore.js";
+import { LocalStorageAdapter as s, MemoryStorageAdapter as x } from "./core/storageAdapter.js";
+import { DEFAULT_CONFIGS as g, PROVIDERS as _, createProvider as C, createProviderFlexible as O, registerProvider as u } from "./providers/factory.js";
+import { createLLM as r } from "./vue/plugin.js";
+import { LLMPlugin as P, LLM_CLIENT_SYMBOL as E, LLM_CONFIG_SYMBOL as v, LLM_KEYSTORE_SYMBOL as A } from "./vue/plugin.js";
+import { createDefaultConfig as I, useLLM as K } from "./vue/useLLM.js";
+import { default as k } from "./vue/components/ProviderSelector.vue.js";
+import { default as D } from "./vue/components/LLMConfigModal.vue.js";
+import { default as R } from "./vue/components/StoredKeysManager.vue.js";
+const e = r({}), t = e.client, L = e.configStore, a = e.keyStore;
+export {
+  S as ConfigStore,
+  g as DEFAULT_CONFIGS,
+  p as KeyStore,
+  l as LLMClient,
+  D as LLMConfigModal,
+  P as LLMPlugin,
+  E as LLM_CLIENT_SYMBOL,
+  v as LLM_CONFIG_SYMBOL,
+  A as LLM_KEYSTORE_SYMBOL,
+  s as LocalStorageAdapter,
+  x as MemoryStorageAdapter,
+  _ as PROVIDERS,
+  k as ProviderSelector,
+  R as StoredKeysManager,
+  L as configStore,
+  I as createDefaultConfig,
+  r as createLLM,
+  C as createProvider,
+  O as createProviderFlexible,
+  a as keyStore,
+  t as llmClient,
+  M as maskApiKey,
+  u as registerProvider,
+  K as useLLM
+};