@cherrystudio/ai-core/dist/index.d.mts

Cherry Studio AI Core - Unified AI Provider Interface Based on Vercel AI SDK

import { _ as ToolFactoryMap, d as RegisteredProviderId, f as StringKeys, g as ToolFactory, h as ToolCapability, l as ProviderId, m as WebSearchToolConfigMap, n as CoreProviderSettingsMap, o as ExtractToolConfig, s as ExtractToolConfigMap, t as AiSdkModel, v as ToolFactoryPatch } from "./index-CCQe5Cuy.mjs";
import "./provider/index.mjs";
import { a as GenerateTextResult, i as GenerateTextParams, n as AiPlugin, o as StreamTextParams, r as AiRequestContext, s as StreamTextResult, t as definePlugin } from "./index-C18YloeF.mjs";
import { LanguageModel, embedMany as embedMany$1, generateImage as generateImage$1, generateText as generateText$1, streamText as streamText$1 } from "ai";
import { EmbeddingModelV3, ImageModelV3, JSONObject, LanguageModelV2, LanguageModelV3, ProviderV3 } from "@ai-sdk/provider";

//#region src/core/runtime/pluginEngine.d.ts
/**
 * 插件增强的 AI 客户端
 * 专注于插件处理，不暴露用户API
 */
declare class PluginEngine<T extends string = RegisteredProviderId> {
  private readonly providerId;
  /**
   * Plugin storage with explicit any/any generics
   *
   * SAFETY: Plugins are contravariant in TParams and covariant in TResult.
   * The cast to AiPlugin<TParams, TResult>[] in PluginManager is safe due to variance rules:
   * - A plugin accepting any params (TParams = any) can handle specific params
   * - A plugin returning any result (TResult = any) can be used as any specific result type
   *
   * Using AiPlugin<any, any> instead of AiPlugin preserves generic type information
   * and makes the variance relationship explicit for type checking.
   */
  private basePlugins;
  constructor(providerId: T, plugins?: AiPlugin[]);
  /**
   * 添加插件
   */
  use(plugin: AiPlugin): this;
  /**
   * 批量添加插件
   */
  usePlugins(plugins: AiPlugin[]): this;
  /**
   * 移除插件
   */
  removePlugin(pluginName: string): this;
  /**
   * 获取插件统计
   */
  getPluginStats(): {
    total: number;
    pre: number;
    normal: number;
    post: number;
    hooks: {
      resolveModel: number;
      loadTemplate: number;
      transformParams: number;
      transformResult: number;
      onRequestStart: number;
      onRequestEnd: number;
      onError: number;
      transformStream: number;
    };
  };
  /**
   * 获取所有插件
   */
  getPlugins(): AiPlugin<any, any>[];
  /**
   * 执行带插件的操作（非流式）
   * 提供给AiExecutor使用
   */
  executeWithPlugins<TParams extends GenerateTextParams, TResult extends GenerateTextResult>(methodName: string, params: TParams, executor: (model: LanguageModel, transformedParams: TParams) => TResult, _context?: AiRequestContext<TParams, TResult>): Promise<TResult>;
  /**
   * 执行带插件的图像生成操作
   * 提供给AiExecutor使用
   */
  executeImageWithPlugins<TParams extends Omit<Parameters<typeof generateImage$1>[0], 'model'> & {
    model: string | ImageModelV3;
  }, TResult extends ReturnType<typeof generateImage$1>>(methodName: string, params: TParams, executor: (model: ImageModelV3, transformedParams: TParams) => TResult, _context?: AiRequestContext<TParams, TResult>): Promise<TResult>;
  /**
   * 执行流式调用的通用逻辑（支持流转换器）
   * 提供给AiExecutor使用
   */
  executeStreamWithPlugins<TParams extends StreamTextParams, TResult extends StreamTextResult>(methodName: string, params: TParams, executor: (model: LanguageModel, transformedParams: TParams, streamTransforms: any[]) => TResult, _context?: AiRequestContext<TParams, TResult>): Promise<TResult>;
}
//#endregion
//#region src/core/runtime/types.d.ts
/**
 * 运行时执行器配置
 *
 * @typeParam TSettingsMap - Provider Settings Map（默认 CoreProviderSettingsMap）
 * @typeParam T - Provider ID 类型（从 TSettingsMap 的键推断）
 */
interface RuntimeConfig<TSettingsMap extends Record<string, any> = CoreProviderSettingsMap, T extends StringKeys<TSettingsMap> = StringKeys<TSettingsMap>> {
  providerId: T;
  provider: ProviderV3;
  providerSettings: TSettingsMap[T];
  plugins?: AiPlugin[];
  /**
   * 模型解析函数
   * 从 variant 的 resolveModel 声明中提取（类型安全在 extension 声明处保证）。
   * 不提供时使用 AI SDK 默认的 provider.languageModel()。
   */
  modelResolver?: (modelId: string) => any;
}
type generateImageParams = Omit<Parameters<typeof generateImage$1>[0], 'model'> & {
  model: string | ImageModelV3;
};
type generateImageResult = Awaited<ReturnType<typeof generateImage$1>>;
type generateTextParams = Parameters<typeof generateText$1>[0];
type streamTextParams = Parameters<typeof streamText$1>[0];
type EmbedManyParams = Omit<Parameters<typeof embedMany$1>[0], 'model'> & {
  model: string | EmbeddingModelV3;
};
type EmbedManyResult = Awaited<ReturnType<typeof embedMany$1>>;
//#endregion
//#region src/core/runtime/executor.d.ts
declare class RuntimeExecutor<TSettingsMap extends Record<string, any> = CoreProviderSettingsMap, T extends StringKeys<TSettingsMap> = StringKeys<TSettingsMap>> {
  pluginEngine: PluginEngine<T>;
  private config;
  private registry;
  constructor(config: RuntimeConfig<TSettingsMap, T>);
  private createResolveModelPlugin;
  private createResolveImageModelPlugin;
  private createConfigureContextPlugin;
  /**
   * 流式文本生成
   */
  streamText(params: streamTextParams): Promise<ReturnType<typeof streamText$1>>;
  /**
   * 生成文本
   */
  generateText(params: generateTextParams): Promise<ReturnType<typeof generateText$1>>;
  /**
   * 生成图像
   */
  generateImage(params: generateImageParams): Promise<generateImageResult>;
  /**
   * 批量嵌入文本
   */
  embedMany(params: EmbedManyParams): Promise<EmbedManyResult>;
  /**
   * 解析模型：将字符串 modelId 解析为 model 对象
   *
   * 对于有 modelResolver 的配置（如 xAI responses, OpenAI chat），
   * 使用 resolver 函数解析模型，而不是通过 registry.languageModel()。
   * resolver 在 extension 声明处类型安全地捕获了具体 provider 方法。
   */
  private resolveModel;
  /**
   * 解析图像模型：如果是字符串则创建图像模型，如果是模型则直接返回
   */
  private resolveImageModel;
  /**
   * 创建执行器 - 支持已知provider的类型安全
   */
  static create<TSettingsMap extends Record<string, any> = CoreProviderSettingsMap, T extends StringKeys<TSettingsMap> = StringKeys<TSettingsMap>>(providerId: T, provider: ProviderV3, options: TSettingsMap[T], plugins?: AiPlugin[], modelResolver?: (modelId: string) => any): RuntimeExecutor<TSettingsMap, T>;
  /**
   * 创建OpenAI Compatible执行器
   * ✅ Now accepts provider instance directly
   */
  static createOpenAICompatible(provider: ProviderV3, // ✅ Accept provider instance
  options: CoreProviderSettingsMap['openai-compatible'], plugins?: AiPlugin[]): RuntimeExecutor<CoreProviderSettingsMap, 'openai-compatible'>;
}
//#endregion
//#region src/core/runtime/index.d.ts
/**
 * 创建运行时执行器 - 支持类型安全的已知provider
 * 自动确保 provider 已初始化
 */
declare function createExecutor<TSettingsMap extends Record<string, any> = CoreProviderSettingsMap, T extends StringKeys<TSettingsMap> = StringKeys<TSettingsMap>>(providerId: T, options: TSettingsMap[T], plugins?: AiPlugin[]): Promise<RuntimeExecutor<TSettingsMap, T>>;
/**
 * 直接流式文本生成
 */
declare function streamText<TSettingsMap extends Record<string, any> = CoreProviderSettingsMap, T extends StringKeys<TSettingsMap> = StringKeys<TSettingsMap>>(providerId: T, options: TSettingsMap[T], params: Parameters<RuntimeExecutor<TSettingsMap, T>['streamText']>[0], plugins?: AiPlugin[]): Promise<ReturnType<RuntimeExecutor<TSettingsMap, T>['streamText']>>;
/**
 * 直接生成文本
 */
declare function generateText<TSettingsMap extends Record<string, any> = CoreProviderSettingsMap, T extends StringKeys<TSettingsMap> = StringKeys<TSettingsMap>>(providerId: T, options: TSettingsMap[T], params: Parameters<RuntimeExecutor<TSettingsMap, T>['generateText']>[0], plugins?: AiPlugin[]): Promise<ReturnType<RuntimeExecutor<TSettingsMap, T>['generateText']>>;
/**
 * 直接生成图像 - 支持middlewares
 */
declare function generateImage<TSettingsMap extends Record<string, any> = CoreProviderSettingsMap, T extends StringKeys<TSettingsMap> = StringKeys<TSettingsMap>>(providerId: T, options: TSettingsMap[T], params: Parameters<RuntimeExecutor<TSettingsMap, T>['generateImage']>[0], plugins?: AiPlugin[]): Promise<ReturnType<RuntimeExecutor<TSettingsMap, T>['generateImage']>>;
/**
 * 直接批量嵌入文本
 * AI SDK v6 只有 embedMany，没有 embed
 */
declare function embedMany<TSettingsMap extends Record<string, any> = CoreProviderSettingsMap, T extends StringKeys<TSettingsMap> = StringKeys<TSettingsMap>>(providerId: T, options: TSettingsMap[T], params: Parameters<RuntimeExecutor<TSettingsMap, T>['embedMany']>[0], plugins?: AiPlugin[]): Promise<ReturnType<RuntimeExecutor<TSettingsMap, T>['embedMany']>>;
//#endregion
//#region src/core/models/utils.d.ts
declare const isV2Model: (model: AiSdkModel) => model is LanguageModelV2;
declare const isV3Model: (model: AiSdkModel) => model is LanguageModelV3;
//#endregion
//#region src/core/errors/index.d.ts
/**
 * AI Core Error System
 * Unified error handling for the AI Core package
 */
/**
 * Base error class for all AI Core errors
 * Provides structured error information with error codes, context, and cause tracking
 */
declare class AiCoreError extends Error {
  readonly code: string;
  readonly context?: Record<string, unknown> | undefined;
  readonly cause?: Error | undefined;
  constructor(code: string, message: string, context?: Record<string, unknown> | undefined, cause?: Error | undefined);
  toJSON(): {
    name: string;
    code: string;
    message: string;
    context: Record<string, unknown> | undefined;
    cause: {
      name: string;
      message: string;
    } | undefined;
  };
}
/**
 * Recursive depth limit exceeded error
 * Thrown when recursive calls exceed the maximum allowed depth
 */
declare class RecursiveDepthError extends AiCoreError {
  constructor(requestId: string, currentDepth: number, maxDepth: number);
}
/**
 * Model resolution failure error
 * Thrown when a model ID cannot be resolved to a model instance
 */
declare class ModelResolutionError extends AiCoreError {
  constructor(modelId: string, providerId: string, cause?: Error);
}
/**
 * Parameter validation error
 * Thrown when request parameters fail validation
 */
declare class ParameterValidationError extends AiCoreError {
  constructor(paramName: string, reason: string, value?: unknown);
}
/**
 * Plugin execution error
 * Thrown when a plugin fails during execution
 */
declare class PluginExecutionError extends AiCoreError {
  constructor(pluginName: string, hookName: string, cause: Error);
}
/**
 * Template loading error
 * Thrown when a template cannot be loaded
 */
declare class TemplateLoadError extends AiCoreError {
  constructor(templateName: string, cause?: Error);
}
//#endregion
export { AiCoreError, type AiPlugin, type AiRequestContext, type AiSdkModel, type EmbedManyParams, type EmbedManyResult, type ExtractToolConfig, type ExtractToolConfigMap, type GenerateTextParams, type GenerateTextResult, ModelResolutionError, ParameterValidationError, PluginEngine, PluginExecutionError, type ProviderId, RecursiveDepthError, type StreamTextParams, type StreamTextResult, TemplateLoadError, type ToolCapability, type ToolFactory, type ToolFactoryMap, type ToolFactoryPatch, type WebSearchToolConfigMap, createExecutor, definePlugin, embedMany, generateImage, generateText, isV2Model, isV3Model, streamText };