@dexto/core 1.1.4 → 1.1.6

package/dist/llm/tokenizer/default.js

@@ -0,0 +1,17 @@
+class DefaultTokenizer {
+  /**
+   * Assumes roughly 4 characters per token.
+   * @param text Text content to count tokens for
+   * @returns Approximate number of tokens
+   */
+  countTokens(text) {
+    if (!text) return 0;
+    return Math.ceil(text.length / 4);
+  }
+  getProviderName() {
+    return "default";
+  }
+}
+export {
+  DefaultTokenizer
+};

package/dist/llm/tokenizer/factory.cjs

@@ -0,0 +1,44 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var factory_exports = {};
+__export(factory_exports, {
+  createTokenizer: () => createTokenizer
+});
+module.exports = __toCommonJS(factory_exports);
+var import_openai = require("./openai.js");
+var import_anthropic = require("./anthropic.js");
+var import_google = require("./google.js");
+var import_default = require("./default.js");
+function createTokenizer(provider, model) {
+  switch (provider) {
+    case "openai":
+      return new import_openai.OpenAITokenizer(model);
+    case "anthropic":
+      return new import_anthropic.AnthropicTokenizer();
+    case "google":
+      return new import_google.GoogleTokenizer(model);
+    // Add cases for other providers here
+    default:
+      return new import_default.DefaultTokenizer();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createTokenizer
+});

package/dist/llm/tokenizer/factory.d.cts

@@ -0,0 +1,12 @@
+import { ITokenizer } from './types.cjs';
+import { LLMProvider } from '../types.cjs';
+
+/**
+ * Creates the appropriate tokenizer for the specified provider and model
+ * @param provider The LLM provider name (case-insensitive)
+ * @param model The specific model name (used by some tokenizers)
+ * @returns An appropriate tokenizer implementation, or DefaultTokenizer if no specific implementation exists
+ */
+declare function createTokenizer(provider: LLMProvider, model: string): ITokenizer;
+
+export { createTokenizer };

package/dist/llm/tokenizer/factory.d.ts

@@ -0,0 +1,12 @@
+import { ITokenizer } from './types.js';
+import { LLMProvider } from '../types.js';
+
+/**
+ * Creates the appropriate tokenizer for the specified provider and model
+ * @param provider The LLM provider name (case-insensitive)
+ * @param model The specific model name (used by some tokenizers)
+ * @returns An appropriate tokenizer implementation, or DefaultTokenizer if no specific implementation exists
+ */
+declare function createTokenizer(provider: LLMProvider, model: string): ITokenizer;
+
+export { createTokenizer };

package/dist/llm/tokenizer/factory.js

@@ -0,0 +1,20 @@
+import { OpenAITokenizer } from "./openai.js";
+import { AnthropicTokenizer } from "./anthropic.js";
+import { GoogleTokenizer } from "./google.js";
+import { DefaultTokenizer } from "./default.js";
+function createTokenizer(provider, model) {
+  switch (provider) {
+    case "openai":
+      return new OpenAITokenizer(model);
+    case "anthropic":
+      return new AnthropicTokenizer();
+    case "google":
+      return new GoogleTokenizer(model);
+    // Add cases for other providers here
+    default:
+      return new DefaultTokenizer();
+  }
+}
+export {
+  createTokenizer
+};

package/dist/llm/tokenizer/google.cjs

@@ -0,0 +1,52 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var google_exports = {};
+__export(google_exports, {
+  GoogleTokenizer: () => GoogleTokenizer
+});
+module.exports = __toCommonJS(google_exports);
+class GoogleTokenizer {
+  modelName;
+  /**
+   * Initializes the tokenizer for a specific Google Gemini model.
+   * Currently, the model name is not used due to the approximation.
+   * @param model The Google model name (e.g., 'gemini-pro')
+   */
+  constructor(model) {
+    this.modelName = model;
+  }
+  /**
+   * Approximates the token count for Google Gemini models.
+   * Uses a rough guess based on character count (similar to Anthropic's approximation).
+   * IMPORTANT: This is NOT accurate for Gemini models.
+   * @param text Text content to count tokens for
+   * @returns Approximate number of tokens
+   */
+  countTokens(text) {
+    if (!text) return 0;
+    return Math.ceil(text.length / 4);
+  }
+  getProviderName() {
+    return "google";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GoogleTokenizer
+});

package/dist/llm/tokenizer/google.d.cts

@@ -0,0 +1,31 @@
+import { ITokenizer } from './types.cjs';
+
+/**
+ * Tokenizer for Google Gemini models - CURRENTLY USING APPROXIMATION.
+ *
+ * TODO: Replace this with a proper token counting implementation.
+ * The official `@google/generative-ai` library's `countTokens` function
+ * is asynchronous, which complicates synchronous use cases.
+ * Consider using a WASM-based tokenizer or re-evaluating the need
+ * for synchronous counting if a more accurate method is required.
+ */
+declare class GoogleTokenizer implements ITokenizer {
+    private modelName;
+    /**
+     * Initializes the tokenizer for a specific Google Gemini model.
+     * Currently, the model name is not used due to the approximation.
+     * @param model The Google model name (e.g., 'gemini-pro')
+     */
+    constructor(model: string);
+    /**
+     * Approximates the token count for Google Gemini models.
+     * Uses a rough guess based on character count (similar to Anthropic's approximation).
+     * IMPORTANT: This is NOT accurate for Gemini models.
+     * @param text Text content to count tokens for
+     * @returns Approximate number of tokens
+     */
+    countTokens(text: string): number;
+    getProviderName(): string;
+}
+
+export { GoogleTokenizer };

package/dist/llm/tokenizer/google.d.ts

@@ -0,0 +1,31 @@
+import { ITokenizer } from './types.js';
+
+/**
+ * Tokenizer for Google Gemini models - CURRENTLY USING APPROXIMATION.
+ *
+ * TODO: Replace this with a proper token counting implementation.
+ * The official `@google/generative-ai` library's `countTokens` function
+ * is asynchronous, which complicates synchronous use cases.
+ * Consider using a WASM-based tokenizer or re-evaluating the need
+ * for synchronous counting if a more accurate method is required.
+ */
+declare class GoogleTokenizer implements ITokenizer {
+    private modelName;
+    /**
+     * Initializes the tokenizer for a specific Google Gemini model.
+     * Currently, the model name is not used due to the approximation.
+     * @param model The Google model name (e.g., 'gemini-pro')
+     */
+    constructor(model: string);
+    /**
+     * Approximates the token count for Google Gemini models.
+     * Uses a rough guess based on character count (similar to Anthropic's approximation).
+     * IMPORTANT: This is NOT accurate for Gemini models.
+     * @param text Text content to count tokens for
+     * @returns Approximate number of tokens
+     */
+    countTokens(text: string): number;
+    getProviderName(): string;
+}
+
+export { GoogleTokenizer };

package/dist/llm/tokenizer/google.js

@@ -0,0 +1,28 @@
+class GoogleTokenizer {
+  modelName;
+  /**
+   * Initializes the tokenizer for a specific Google Gemini model.
+   * Currently, the model name is not used due to the approximation.
+   * @param model The Google model name (e.g., 'gemini-pro')
+   */
+  constructor(model) {
+    this.modelName = model;
+  }
+  /**
+   * Approximates the token count for Google Gemini models.
+   * Uses a rough guess based on character count (similar to Anthropic's approximation).
+   * IMPORTANT: This is NOT accurate for Gemini models.
+   * @param text Text content to count tokens for
+   * @returns Approximate number of tokens
+   */
+  countTokens(text) {
+    if (!text) return 0;
+    return Math.ceil(text.length / 4);
+  }
+  getProviderName() {
+    return "google";
+  }
+}
+export {
+  GoogleTokenizer
+};

package/dist/llm/tokenizer/openai.cjs

@@ -0,0 +1,108 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var openai_exports = {};
+__export(openai_exports, {
+  OpenAITokenizer: () => OpenAITokenizer
+});
+module.exports = __toCommonJS(openai_exports);
+var import_types = require("./types.js");
+var import_module = require("module");
+var import_logger = require("../../logger/index.js");
+const import_meta = {};
+const FALLBACK_ENCODING = "cl100k_base";
+class OpenAITokenizer {
+  modelName;
+  // Store original model name for context/logging
+  encoding;
+  // Tiktoken encoding instance
+  /**
+   * Initializes the tokenizer for a specific OpenAI model or compatible model.
+   * @param model The OpenAI model name (e.g., 'gpt-4o') or a custom model name.
+   * @throws TokenizationError if tiktoken initialization fails for both specific model and fallback.
+   */
+  constructor(model) {
+    this.modelName = model;
+    try {
+      const { encoding_for_model } = loadTiktoken();
+      this.encoding = encoding_for_model(model);
+      import_logger.logger.debug(`Initialized tiktoken with specific encoding for model: ${model}`);
+    } catch (error) {
+      import_logger.logger.warn(
+        `Could not get specific encoding for model '${this.modelName}'. Falling back to '${FALLBACK_ENCODING}'. Error: ${error instanceof Error ? error.message : String(error)}`
+      );
+      try {
+        const { get_encoding } = loadTiktoken();
+        this.encoding = get_encoding(FALLBACK_ENCODING);
+        import_logger.logger.debug(`Initialized tiktoken with fallback encoding: ${FALLBACK_ENCODING}`);
+      } catch (fallbackError) {
+        import_logger.logger.error(
+          `Failed to initialize tiktoken with specific model '${this.modelName}' or fallback '${FALLBACK_ENCODING}'.`,
+          fallbackError
+        );
+        throw new import_types.TokenizationError(
+          `Failed to initialize tiktoken for model '${this.modelName}' using specific or fallback encoding ('${FALLBACK_ENCODING}'): ${fallbackError instanceof Error ? fallbackError.message : String(fallbackError)}`
+        );
+      }
+    }
+  }
+  /**
+   * Counts the tokens in the text using the determined encoding.
+   * @param text Text content to count tokens for
+   * @returns Number of tokens
+   * @throws TokenizationError if encoding fails during counting.
+   */
+  countTokens(text) {
+    if (!text) return 0;
+    try {
+      const tokens = this.encoding.encode(text);
+      return tokens.length;
+    } catch (error) {
+      import_logger.logger.error(
+        `Tiktoken encoding failed for model ${this.modelName} (using encoding: ${this.encoding.name}):`,
+        error
+      );
+      throw new import_types.TokenizationError(
+        `Encoding failed for text snippet using model ${this.modelName}.`
+      );
+    }
+  }
+  /**
+   * Cleans up the tiktoken encoding instance when done.
+   * Recommended by tiktoken library.
+   */
+  free() {
+    if (this.encoding) {
+      this.encoding.free();
+    }
+  }
+  getProviderName() {
+    return "openai";
+  }
+}
+let _tiktoken = null;
+function loadTiktoken() {
+  if (_tiktoken) return _tiktoken;
+  const req = (0, import_module.createRequire)(import_meta.url);
+  _tiktoken = req("tiktoken");
+  return _tiktoken;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OpenAITokenizer
+});

package/dist/llm/tokenizer/openai.d.cts

@@ -0,0 +1,32 @@
+import { ITokenizer } from './types.cjs';
+
+/**
+ * Tokenizer for OpenAI models using the tiktoken library.
+ * Attempts to use the specific model's encoding, falls back to a common base encoding ('cl100k_base')
+ * for unknown or custom model names (often used with custom baseURLs).
+ */
+declare class OpenAITokenizer implements ITokenizer {
+    private modelName;
+    private encoding;
+    /**
+     * Initializes the tokenizer for a specific OpenAI model or compatible model.
+     * @param model The OpenAI model name (e.g., 'gpt-4o') or a custom model name.
+     * @throws TokenizationError if tiktoken initialization fails for both specific model and fallback.
+     */
+    constructor(model: string);
+    /**
+     * Counts the tokens in the text using the determined encoding.
+     * @param text Text content to count tokens for
+     * @returns Number of tokens
+     * @throws TokenizationError if encoding fails during counting.
+     */
+    countTokens(text: string): number;
+    /**
+     * Cleans up the tiktoken encoding instance when done.
+     * Recommended by tiktoken library.
+     */
+    free(): void;
+    getProviderName(): string;
+}
+
+export { OpenAITokenizer };

package/dist/llm/tokenizer/openai.d.ts

@@ -0,0 +1,32 @@
+import { ITokenizer } from './types.js';
+
+/**
+ * Tokenizer for OpenAI models using the tiktoken library.
+ * Attempts to use the specific model's encoding, falls back to a common base encoding ('cl100k_base')
+ * for unknown or custom model names (often used with custom baseURLs).
+ */
+declare class OpenAITokenizer implements ITokenizer {
+    private modelName;
+    private encoding;
+    /**
+     * Initializes the tokenizer for a specific OpenAI model or compatible model.
+     * @param model The OpenAI model name (e.g., 'gpt-4o') or a custom model name.
+     * @throws TokenizationError if tiktoken initialization fails for both specific model and fallback.
+     */
+    constructor(model: string);
+    /**
+     * Counts the tokens in the text using the determined encoding.
+     * @param text Text content to count tokens for
+     * @returns Number of tokens
+     * @throws TokenizationError if encoding fails during counting.
+     */
+    countTokens(text: string): number;
+    /**
+     * Cleans up the tiktoken encoding instance when done.
+     * Recommended by tiktoken library.
+     */
+    free(): void;
+    getProviderName(): string;
+}
+
+export { OpenAITokenizer };

package/dist/llm/tokenizer/openai.js

@@ -0,0 +1,83 @@
+import { TokenizationError } from "./types.js";
+import { createRequire } from "module";
+import { logger } from "../../logger/index.js";
+const FALLBACK_ENCODING = "cl100k_base";
+class OpenAITokenizer {
+  modelName;
+  // Store original model name for context/logging
+  encoding;
+  // Tiktoken encoding instance
+  /**
+   * Initializes the tokenizer for a specific OpenAI model or compatible model.
+   * @param model The OpenAI model name (e.g., 'gpt-4o') or a custom model name.
+   * @throws TokenizationError if tiktoken initialization fails for both specific model and fallback.
+   */
+  constructor(model) {
+    this.modelName = model;
+    try {
+      const { encoding_for_model } = loadTiktoken();
+      this.encoding = encoding_for_model(model);
+      logger.debug(`Initialized tiktoken with specific encoding for model: ${model}`);
+    } catch (error) {
+      logger.warn(
+        `Could not get specific encoding for model '${this.modelName}'. Falling back to '${FALLBACK_ENCODING}'. Error: ${error instanceof Error ? error.message : String(error)}`
+      );
+      try {
+        const { get_encoding } = loadTiktoken();
+        this.encoding = get_encoding(FALLBACK_ENCODING);
+        logger.debug(`Initialized tiktoken with fallback encoding: ${FALLBACK_ENCODING}`);
+      } catch (fallbackError) {
+        logger.error(
+          `Failed to initialize tiktoken with specific model '${this.modelName}' or fallback '${FALLBACK_ENCODING}'.`,
+          fallbackError
+        );
+        throw new TokenizationError(
+          `Failed to initialize tiktoken for model '${this.modelName}' using specific or fallback encoding ('${FALLBACK_ENCODING}'): ${fallbackError instanceof Error ? fallbackError.message : String(fallbackError)}`
+        );
+      }
+    }
+  }
+  /**
+   * Counts the tokens in the text using the determined encoding.
+   * @param text Text content to count tokens for
+   * @returns Number of tokens
+   * @throws TokenizationError if encoding fails during counting.
+   */
+  countTokens(text) {
+    if (!text) return 0;
+    try {
+      const tokens = this.encoding.encode(text);
+      return tokens.length;
+    } catch (error) {
+      logger.error(
+        `Tiktoken encoding failed for model ${this.modelName} (using encoding: ${this.encoding.name}):`,
+        error
+      );
+      throw new TokenizationError(
+        `Encoding failed for text snippet using model ${this.modelName}.`
+      );
+    }
+  }
+  /**
+   * Cleans up the tiktoken encoding instance when done.
+   * Recommended by tiktoken library.
+   */
+  free() {
+    if (this.encoding) {
+      this.encoding.free();
+    }
+  }
+  getProviderName() {
+    return "openai";
+  }
+}
+let _tiktoken = null;
+function loadTiktoken() {
+  if (_tiktoken) return _tiktoken;
+  const req = createRequire(import.meta.url);
+  _tiktoken = req("tiktoken");
+  return _tiktoken;
+}
+export {
+  OpenAITokenizer
+};

package/dist/llm/tokenizer/types.cjs

@@ -0,0 +1,33 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+__export(types_exports, {
+  TokenizationError: () => TokenizationError
+});
+module.exports = __toCommonJS(types_exports);
+class TokenizationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TokenizationError";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TokenizationError
+});

package/dist/llm/tokenizer/types.d.cts

@@ -0,0 +1,19 @@
+interface ITokenizer {
+    /**
+     * Counts the number of tokens in the provided text according
+     * to the specific LLM provider's tokenization rules
+     * @param text Text content to count tokens for
+     * @returns Number of tokens in the text
+     */
+    countTokens(text: string): number;
+    /**
+     * Gets the name of the LLM provider this tokenizer is for
+     * @returns Provider name (e.g., "openai", "anthropic")
+     */
+    getProviderName(): string;
+}
+declare class TokenizationError extends Error {
+    constructor(message: string);
+}
+
+export { type ITokenizer, TokenizationError };

package/dist/llm/tokenizer/types.d.ts

@@ -0,0 +1,19 @@
+interface ITokenizer {
+    /**
+     * Counts the number of tokens in the provided text according
+     * to the specific LLM provider's tokenization rules
+     * @param text Text content to count tokens for
+     * @returns Number of tokens in the text
+     */
+    countTokens(text: string): number;
+    /**
+     * Gets the name of the LLM provider this tokenizer is for
+     * @returns Provider name (e.g., "openai", "anthropic")
+     */
+    getProviderName(): string;
+}
+declare class TokenizationError extends Error {
+    constructor(message: string);
+}
+
+export { type ITokenizer, TokenizationError };

package/dist/llm/tokenizer/types.js

@@ -0,0 +1,9 @@
+class TokenizationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TokenizationError";
+  }
+}
+export {
+  TokenizationError
+};

package/dist/llm/types.cjs

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+__export(types_exports, {
+  LLM_PROVIDERS: () => LLM_PROVIDERS,
+  LLM_ROUTERS: () => LLM_ROUTERS,
+  SUPPORTED_FILE_TYPES: () => SUPPORTED_FILE_TYPES
+});
+module.exports = __toCommonJS(types_exports);
+const LLM_PROVIDERS = [
+  "openai",
+  "openai-compatible",
+  "anthropic",
+  "google",
+  "groq",
+  "xai",
+  "cohere"
+];
+const LLM_ROUTERS = ["vercel", "in-built"];
+const SUPPORTED_FILE_TYPES = ["pdf", "image", "audio"];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LLM_PROVIDERS,
+  LLM_ROUTERS,
+  SUPPORTED_FILE_TYPES
+});

package/dist/llm/types.d.cts

@@ -0,0 +1,29 @@
+declare const LLM_PROVIDERS: readonly ["openai", "openai-compatible", "anthropic", "google", "groq", "xai", "cohere"];
+type LLMProvider = (typeof LLM_PROVIDERS)[number];
+declare const LLM_ROUTERS: readonly ["vercel", "in-built"];
+type LLMRouter = (typeof LLM_ROUTERS)[number];
+declare const SUPPORTED_FILE_TYPES: readonly ["pdf", "image", "audio"];
+type SupportedFileType = (typeof SUPPORTED_FILE_TYPES)[number];
+/**
+ * LLMRouter defines the routing backend for LLM service instantiation.
+ * 'vercel' = use Vercel LLM service, 'in-built' = use in-built LLM service
+ * This type is now defined in the registry as the source of truth.
+ */
+/**
+ * Context interface for message formatters.
+ * Provides runtime information for model-aware processing.
+ */
+interface LLMContext {
+    /** LLM provider name (e.g., 'google.generative-ai', 'openai') */
+    provider: LLMProvider;
+    /** Specific LLM model name (e.g., 'gemini-2.5-flash', 'gpt-4') */
+    model: string;
+}
+interface LLMUpdateContext {
+    provider?: LLMProvider;
+    model?: string;
+    router?: LLMRouter;
+    suggestedAction?: string;
+}
+
+export { type LLMContext, type LLMProvider, type LLMRouter, type LLMUpdateContext, LLM_PROVIDERS, LLM_ROUTERS, SUPPORTED_FILE_TYPES, type SupportedFileType };