import { AiPlugin, AiRequestContext, AnthropicProviderSettings, AzureOpenAIProviderSettings, DeepSeekProviderSettings, ExtractProviderOptions, GenerateObjectParams, GenerateTextParams, GoogleGenerativeAIProviderSettings, HookResult, OpenAICompatibleProviderSettings, OpenAIProviderSettings, PluginManager$1 as PluginManager, PluginManagerConfig, ProviderConfig, ProviderError, ProviderId, ProviderOptionsMap, ProviderSettings, ProviderSettingsMap, StreamObjectParams, StreamTextParams, TypedProviderOptions, XaiProviderSettings, createContext$1 as createContext, definePlugin$1 as definePlugin } from "./types-Bj-rFQ8G.mjs";
import * as _ai_sdk_anthropic0 from "@ai-sdk/anthropic";
import * as _ai_sdk_azure0 from "@ai-sdk/azure";
import * as _ai_sdk_google0 from "@ai-sdk/google";
import * as _ai_sdk_openai0 from "@ai-sdk/openai";
import * as _ai_sdk_openai_compatible0 from "@ai-sdk/openai-compatible";
import * as aiSdk from "ai";
import { AssistantModelMessage, Experimental_Agent as Agent, FilePart, FinishReason, GenerateObjectResult, GenerateTextResult, ImagePart, InvalidToolInputError, LanguageModel, LanguageModelUsage, ModelMessage, NoSuchToolError, StreamTextResult, SystemModelMessage, TextPart, TextStreamPart, Tool, ToolCallPart, ToolCallUnion, ToolModelMessage, ToolResultPart, ToolResultUnion, ToolSet, UserModelMessage, defaultSettingsMiddleware, extractReasoningMiddleware, generateObject as generateObject$1, generateText as generateText$1, simulateStreamingMiddleware, smoothStream, stepCountIs, streamObject, streamText as streamText$1 } from "ai";
import { ImageModelV2, LanguageModelV2, LanguageModelV2Middleware, LanguageModelV2Middleware as LanguageModelV2Middleware$1, LanguageModelV2StreamPart } from "@ai-sdk/provider";
import { ReasoningPart, ToolCall } from "@ai-sdk/provider-utils";

//#region src/core/models/types.d.ts
interface ModelConfig<T extends ProviderId = ProviderId> {
  providerId: T;
  modelId: string;
  providerSettings: ProviderSettingsMap[T] & {
    mode?: 'chat' | 'responses';
  };
  middlewares?: LanguageModelV2Middleware$1[];
  extraModelConfig?: Record<string, any>;
}
//#endregion
//#region src/core/runtime/pluginEngine.d.ts
/**
 * 插件增强的 AI 客户端
 * 专注于插件处理，不暴露用户API
 */
declare class PluginEngine<T extends ProviderId = ProviderId> {
  private readonly providerId;
  private pluginManager;
  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[];
  /**
   * 执行带插件的操作（非流式）
   * 提供给AiExecutor使用
   */
  executeWithPlugins<TParams, TResult>(methodName: string, modelId: string, params: TParams, executor: (model: LanguageModel, transformedParams: TParams) => Promise<TResult>, _context?: ReturnType<typeof createContext>): Promise<TResult>;
  /**
   * 执行流式调用的通用逻辑（支持流转换器）
   * 提供给AiExecutor使用
   */
  executeStreamWithPlugins<TParams, TResult>(methodName: string, modelId: string, params: TParams, executor: (model: LanguageModel, transformedParams: TParams, streamTransforms: any[]) => Promise<TResult>, _context?: ReturnType<typeof createContext>): Promise<TResult>;
  /**
   * 创建 OpenAI Compatible 客户端
   */
  static createOpenAICompatible(config: ProviderSettingsMap['openai-compatible'], plugins?: AiPlugin[]): PluginEngine<'openai-compatible'>;
  /**
   * 创建标准提供商客户端
   */
  static create<T extends ProviderId>(providerId: T, plugins?: AiPlugin[]): PluginEngine<T>;
  static create(providerId: string, plugins?: AiPlugin[]): PluginEngine<'openai-compatible'>;
}
//#endregion
//#region src/core/runtime/types.d.ts
/**
 * 运行时执行器配置
 */
interface RuntimeConfig<T extends ProviderId = ProviderId> {
  providerId: T;
  providerSettings: ModelConfig<T>['providerSettings'] & {
    mode?: 'chat' | 'responses';
  };
  plugins?: AiPlugin[];
}
//#endregion
//#region src/core/runtime/executor.d.ts
declare class RuntimeExecutor<T extends ProviderId = ProviderId> {
  pluginEngine: PluginEngine<T>;
  private config;
  constructor(config: RuntimeConfig<T>);
  createResolveModelPlugin(middlewares?: LanguageModelV2Middleware$1[]): AiPlugin;
  createConfigureContextPlugin(): AiPlugin;
  /**
   * 流式文本生成 - 使用已创建的模型（高级用法）
   */
  streamText(model: LanguageModel, params: Omit<Parameters<typeof streamText$1>[0], 'model'>): Promise<ReturnType<typeof streamText$1>>;
  streamText(modelId: string, params: Omit<Parameters<typeof streamText$1>[0], 'model'>, options?: {
    middlewares?: LanguageModelV2Middleware$1[];
  }): Promise<ReturnType<typeof streamText$1>>;
  /**
   * 生成文本 - 使用已创建的模型
   */
  generateText(model: LanguageModel, params: Omit<Parameters<typeof generateText$1>[0], 'model'>): Promise<ReturnType<typeof generateText$1>>;
  generateText(modelId: string, params: Omit<Parameters<typeof generateText$1>[0], 'model'>, options?: {
    middlewares?: LanguageModelV2Middleware$1[];
  }): Promise<ReturnType<typeof generateText$1>>;
  /**
   * 生成结构化对象 - 使用已创建的模型
   */
  generateObject(model: LanguageModel, params: Omit<Parameters<typeof generateObject$1>[0], 'model'>): Promise<ReturnType<typeof generateObject$1>>;
  generateObject(modelOrId: string, params: Omit<Parameters<typeof generateObject$1>[0], 'model'>, options?: {
    middlewares?: LanguageModelV2Middleware$1[];
  }): Promise<ReturnType<typeof generateObject$1>>;
  /**
   * 流式生成结构化对象 - 使用已创建的模型
   */
  streamObject(model: LanguageModel, params: Omit<Parameters<typeof streamObject>[0], 'model'>): Promise<ReturnType<typeof streamObject>>;
  streamObject(modelId: string, params: Omit<Parameters<typeof streamObject>[0], 'model'>, options?: {
    middlewares?: LanguageModelV2Middleware$1[];
  }): Promise<ReturnType<typeof streamObject>>;
  /**
   * 解析模型：如果是字符串则创建模型，如果是模型则直接返回
   */
  private resolveModel;
  /**
   * 获取客户端信息
   */
  getClientInfo(): {
    id: string;
    name: string;
    isSupported: boolean;
    effectiveProvider: string;
  };
  /**
   * 创建执行器 - 支持已知provider的类型安全
   */
  static create<T extends ProviderId>(providerId: T, options: ModelConfig<T>['providerSettings'], plugins?: AiPlugin[]): RuntimeExecutor<T>;
  /**
   * 创建OpenAI Compatible执行器
   */
  static createOpenAICompatible(options: ModelConfig<'openai-compatible'>['providerSettings'], plugins?: AiPlugin[]): RuntimeExecutor<'openai-compatible'>;
}
//#endregion
//#region src/core/runtime/index.d.ts
/**
 * 创建运行时执行器 - 支持类型安全的已知provider
 */
declare function createExecutor<T extends ProviderId>(providerId: T, options: ProviderSettingsMap[T] & {
  mode?: 'chat' | 'responses';
}, plugins?: AiPlugin[]): RuntimeExecutor<T>;
/**
 * 创建OpenAI Compatible执行器
 */
declare function createOpenAICompatibleExecutor(options: ProviderSettingsMap['openai-compatible'] & {
  mode?: 'chat' | 'responses';
}, plugins?: AiPlugin[]): RuntimeExecutor<'openai-compatible'>;
/**
 * 直接流式文本生成 - 支持middlewares
 */
declare function streamText<T extends ProviderId>(providerId: T, options: ProviderSettingsMap[T] & {
  mode?: 'chat' | 'responses';
}, modelId: string, params: Parameters<RuntimeExecutor<T>['streamText']>[1], plugins?: AiPlugin[], middlewares?: LanguageModelV2Middleware$1[]): Promise<ReturnType<RuntimeExecutor<T>['streamText']>>;
/**
 * 直接生成文本 - 支持middlewares
 */
declare function generateText<T extends ProviderId>(providerId: T, options: ProviderSettingsMap[T] & {
  mode?: 'chat' | 'responses';
}, modelId: string, params: Parameters<RuntimeExecutor<T>['generateText']>[1], plugins?: AiPlugin[], middlewares?: LanguageModelV2Middleware$1[]): Promise<ReturnType<RuntimeExecutor<T>['generateText']>>;
/**
 * 直接生成结构化对象 - 支持middlewares
 */
declare function generateObject<T extends ProviderId>(providerId: T, options: ProviderSettingsMap[T] & {
  mode?: 'chat' | 'responses';
}, modelId: string, params: Parameters<RuntimeExecutor<T>['generateObject']>[1], plugins?: AiPlugin[], middlewares?: LanguageModelV2Middleware$1[]): Promise<ReturnType<RuntimeExecutor<T>['generateObject']>>;
/**
 * 直接流式生成结构化对象 - 支持middlewares
 */
//#endregion
//#region src/core/models/ModelCreator.d.ts
declare class ModelCreationError extends Error {
  providerId?: string | undefined;
  cause?: Error | undefined;
  constructor(message: string, providerId?: string | undefined, cause?: Error | undefined);
}
/**
 * 创建基础 AI SDK 模型实例
 * 对于已知的 Provider 使用严格类型检查，未知的 Provider 默认使用 openai-compatible
 */
declare function createBaseModel<T extends ProviderId>({
  providerId,
  modelId,
  providerSettings,
  extraModelConfig
}: {
  providerId: T;
  modelId: string;
  providerSettings: ProviderSettingsMap[T] & {
    mode?: 'chat' | 'responses';
  };
  extraModelConfig?: any;
}): Promise<LanguageModelV2>;
declare function createBaseModel({
  providerId,
  modelId,
  providerSettings,
  extraModelConfig
}: {
  providerId: string;
  modelId: string;
  providerSettings: ProviderSettingsMap['openai-compatible'] & {
    mode?: 'chat' | 'responses';
  };
  extraModelConfig?: any;
}): Promise<LanguageModelV2>;
/**
 * 创建图像生成模型实例
 */
declare function createImageModel<T extends ProviderId>(providerId: T, modelId: string, options: ProviderSettingsMap[T]): Promise<ImageModelV2>;
declare function createImageModel(providerId: string, modelId: string, options: ProviderSettingsMap['openai-compatible']): Promise<ImageModelV2>;
/**
 * 获取支持的 Providers 列表
 */
declare function getSupportedProviders(): Array<{
  id: string;
  name: string;
}>;
/**
 * 获取 Provider 信息
 */
declare function getProviderInfo(providerId: string): {
  id: string;
  name: string;
  isSupported: boolean;
  effectiveProvider: string;
};
//#endregion
//#region src/core/models/factory.d.ts
/**
 * 创建模型 - 核心函数
 */
declare function createModel(config: ModelConfig): Promise<LanguageModelV2>;
/**
 * 批量创建模型
 */
//#endregion
//#region src/core/providers/registry.d.ts
declare class AiProviderRegistry {
  private static instance;
  private registry;
  private constructor();
  static getInstance(): AiProviderRegistry;
  /**
   * 初始化所有支持的 Providers
   * 基于 AI SDK 官方文档: https://ai-sdk.dev/providers/ai-sdk-providers
   */
  private initializeProviders;
  /**
   * 获取所有已注册的 Providers
   */
  getAllProviders(): ProviderConfig[];
  /**
   * 根据 ID 获取 Provider 配置
   */
  getProvider(id: string): ProviderConfig | undefined;
  /**
   * 检查 Provider 是否支持（是否已注册）
   */
  isSupported(id: string): boolean;
  /**
   * 注册新的 Provider（用于扩展）
   */
  registerProvider(config: ProviderConfig): void;
  /**
   * 清理资源
   */
  cleanup(): void;
}
declare const aiProviderRegistry: AiProviderRegistry;
declare const getProvider: (id: string) => ProviderConfig | undefined;
declare const getAllProviders: () => ProviderConfig[];
declare const isProviderSupported: (id: string) => boolean;
declare const registerProvider: (config: ProviderConfig) => void;
//#endregion
//#region src/core/options/factory.d.ts
/**
 * 合并多个供应商的options
 * @param optionsMap 包含多个供应商选项的对象
 * @returns 合并后的TypedProviderOptions
 */
declare function mergeProviderOptions(...optionsMap: Partial<TypedProviderOptions>[]): TypedProviderOptions;
/**
 * 创建OpenAI供应商选项的便捷函数
 */
declare function createOpenAIOptions(options: ExtractProviderOptions<'openai'>): Record<"openai", {
  metadata?: any;
  parallelToolCalls?: boolean | null | undefined;
  previousResponseId?: string | null | undefined;
  store?: boolean | null | undefined;
  user?: string | null | undefined;
  reasoningEffort?: string | null | undefined;
  strictJsonSchema?: boolean | null | undefined;
  instructions?: string | null | undefined;
  reasoningSummary?: string | null | undefined;
  serviceTier?: "auto" | "flex" | null | undefined;
  include?: "reasoning.encrypted_content"[] | null | undefined;
}>;
/**
 * 创建Anthropic供应商选项的便捷函数
 */
declare function createAnthropicOptions(options: ExtractProviderOptions<'anthropic'>): Record<"anthropic", {
  sendReasoning?: boolean | undefined;
  thinking?: {
    type: "enabled" | "disabled";
    budgetTokens?: number | undefined;
  } | undefined;
}>;
/**
 * 创建Google供应商选项的便捷函数
 */
declare function createGoogleOptions(options: ExtractProviderOptions<'google'>): Record<"google", {
  responseModalities?: ("TEXT" | "IMAGE")[] | undefined;
  thinkingConfig?: {
    thinkingBudget?: number | undefined;
    includeThoughts?: boolean | undefined;
  } | undefined;
  cachedContent?: string | undefined;
  structuredOutputs?: boolean | undefined;
  safetySettings?: {
    category: "HARM_CATEGORY_UNSPECIFIED" | "HARM_CATEGORY_HATE_SPEECH" | "HARM_CATEGORY_DANGEROUS_CONTENT" | "HARM_CATEGORY_HARASSMENT" | "HARM_CATEGORY_SEXUALLY_EXPLICIT" | "HARM_CATEGORY_CIVIC_INTEGRITY";
    threshold: "HARM_BLOCK_THRESHOLD_UNSPECIFIED" | "BLOCK_LOW_AND_ABOVE" | "BLOCK_MEDIUM_AND_ABOVE" | "BLOCK_ONLY_HIGH" | "BLOCK_NONE" | "OFF";
  }[] | undefined;
  threshold?: "HARM_BLOCK_THRESHOLD_UNSPECIFIED" | "BLOCK_LOW_AND_ABOVE" | "BLOCK_MEDIUM_AND_ABOVE" | "BLOCK_ONLY_HIGH" | "BLOCK_NONE" | "OFF" | undefined;
  audioTimestamp?: boolean | undefined;
}>;
/**
 * 创建OpenRouter供应商选项的便捷函数
 */
//#endregion
//#region src/core/providers/factory.d.ts
/**
 * 通用配置基础类型，包含所有 Provider 共有的属性
 */
interface BaseProviderConfig {
  apiKey?: string;
  baseURL?: string;
  timeout?: number;
  headers?: Record<string, string>;
  fetch?: typeof globalThis.fetch;
}
/**
 * 完整的配置类型，结合基础配置、AI SDK 配置和特定 Provider 配置
 */
type CompleteProviderConfig<T extends ProviderId> = BaseProviderConfig & Partial<ProviderSettingsMap[T]>;
declare class ProviderConfigBuilder<T extends ProviderId = ProviderId> {
  private providerId;
  private config;
  constructor(providerId: T);
  /**
   * 设置 API Key
   */
  withApiKey(apiKey: string): this;
  withApiKey(apiKey: string, options: T extends 'openai' ? {
    organization?: string;
    project?: string;
  } : never): this;
  /**
   * 设置基础 URL
   */
  withBaseURL(baseURL: string): this;
  /**
   * 设置请求配置
   */
  withRequestConfig(options: {
    headers?: Record<string, string>;
    fetch?: typeof fetch;
  }): this;
  /**
   * Azure OpenAI 特定配置
   */
  withAzureConfig(options: {
    apiVersion?: string;
    resourceName?: string;
  }): T extends 'azure' ? this : never;
  /**
   * Google 特定配置
   */
  withGoogleCredentials(credentials: {
    clientEmail: string;
    privateKey: string;
  }): T extends 'google-vertex' ? this : never;
  /**
   * 设置自定义参数
   */
  withCustomParams(params: Record<string, any>): this;
  /**
   * 构建最终配置
   */
  build(): ProviderSettingsMap[T];
}
/**
 * Provider 配置工厂
 * 提供便捷的配置创建方法
 */
declare class ProviderConfigFactory {
  /**
   * 创建配置构建器
   */
  static builder<T extends ProviderId>(providerId: T): ProviderConfigBuilder<T>;
  /**
   * 从通用Provider对象创建配置 - 使用更优雅的处理器模式
   */
  static fromProvider<T extends ProviderId>(providerId: T, provider: CompleteProviderConfig<T>, options?: {
    headers?: Record<string, string>;
    [key: string]: any;
  }): ProviderSettingsMap[T];
  /**
   * 快速创建 OpenAI 配置
   */
  static createOpenAI(apiKey: string, options?: {
    baseURL?: string;
    organization?: string;
    project?: string;
  }): _ai_sdk_openai0.OpenAIProviderSettings;
  /**
   * 快速创建 Anthropic 配置
   */
  static createAnthropic(apiKey: string, options?: {
    baseURL?: string;
  }): _ai_sdk_anthropic0.AnthropicProviderSettings;
  /**
   * 快速创建 Azure OpenAI 配置
   */
  static createAzureOpenAI(apiKey: string, options: {
    baseURL: string;
    apiVersion?: string;
    resourceName?: string;
  }): _ai_sdk_azure0.AzureOpenAIProviderSettings;
  /**
   * 快速创建 Google 配置
   */
  static createGoogle(apiKey: string, options?: {
    baseURL?: string;
    projectId?: string;
    location?: string;
  }): _ai_sdk_google0.GoogleGenerativeAIProviderSettings;
  /**
   * 快速创建 Vertex AI 配置
   */
  static createVertexAI(): void;
  static createOpenAICompatible(baseURL: string, apiKey: string): _ai_sdk_openai_compatible0.OpenAICompatibleProviderSettings;
}
/**
 * 便捷的配置创建函数
 */
declare const createProviderConfig: typeof ProviderConfigFactory.fromProvider;
declare const providerConfigBuilder: typeof ProviderConfigFactory.builder;
//#endregion
//#region src/index.d.ts
declare const AI_CORE_VERSION = "1.0.0";
declare const AI_CORE_NAME = "@cherrystudio/ai-core";
declare const AiCore: {
  version: string;
  name: string;
  create(providerId: ProviderId, options: ProviderSettingsMap[ProviderId], plugins?: any[]): RuntimeExecutor<ProviderId>;
  getSupportedProviders(): {
    id: string;
    name: string;
  }[];
  isSupported(providerId: string): boolean;
  getClientInfo(providerId: string): {
    id: string;
    name: string;
    isSupported: boolean;
    effectiveProvider: string;
  };
};
declare const createOpenAIExecutor: (options: ProviderSettingsMap["openai"], plugins?: any[]) => RuntimeExecutor<"openai">;
declare const createAnthropicExecutor: (options: ProviderSettingsMap["anthropic"], plugins?: any[]) => RuntimeExecutor<"anthropic">;
declare const createGoogleExecutor: (options: ProviderSettingsMap["google"], plugins?: any[]) => RuntimeExecutor<"google">;
declare const createXAIExecutor: (options: ProviderSettingsMap["xai"], plugins?: any[]) => RuntimeExecutor<"xai">;
declare const DevTools: {
  listProviders(): {
    id: string;
    name: string;
  }[];
  testProvider(providerId: ProviderId, options: ProviderSettingsMap[ProviderId]): Promise<{
    success: boolean;
    providerId: string;
    name: string;
    isSupported: boolean;
    error?: undefined;
  } | {
    success: boolean;
    providerId: ProviderId;
    error: string;
    name?: undefined;
    isSupported?: undefined;
  }>;
  getProviderDetails(): {
    supportedProviders: number;
    registeredProviders: number;
    providers: {
      id: string;
      name: string;
    }[];
  };
};
//#endregion
export { AI_CORE_NAME, AI_CORE_VERSION, Agent, AiCore, type AiPlugin, type AiRequestContext, type AnthropicProviderSettings, type AssistantModelMessage, type AzureOpenAIProviderSettings, type BaseProviderConfig, type DeepSeekProviderSettings, DevTools, type ExtractProviderOptions, type FilePart, type FinishReason, type GenerateObjectParams, type GenerateObjectResult, type GenerateTextParams, type GenerateTextResult, type GoogleGenerativeAIProviderSettings, type HookResult, type ImagePart, type InvalidToolInputError, type LanguageModelUsage, type LanguageModelV2Middleware, type LanguageModelV2StreamPart, ModelCreationError, type ModelMessage, type NoSuchToolError, type OpenAICompatibleProviderSettings, type OpenAIProviderSettings, PluginEngine, PluginManager, type PluginManagerConfig, type ProviderConfig, type ProviderConfigBuilder, ProviderConfigFactory, type ProviderError, type ProviderId, type ProviderOptionsMap, type ProviderSettings, type ProviderSettingsMap, type ReasoningPart, type StreamObjectParams, type StreamTextParams, type StreamTextResult, type SystemModelMessage, type TextPart, type TextStreamPart, type Tool, type ToolCall, type ToolCallPart, type ToolCallUnion, type ToolModelMessage, type ToolResultPart, type ToolResultUnion, type ToolSet, type TypedProviderOptions, type UserModelMessage, type XaiProviderSettings, aiProviderRegistry, aiSdk, createAnthropicExecutor, createAnthropicOptions, createBaseModel as createApiClient, createContext, createExecutor, createGoogleExecutor, createGoogleOptions, createImageModel, createModel, createOpenAICompatibleExecutor, createOpenAIExecutor, createOpenAIOptions, createProviderConfig, createXAIExecutor, defaultSettingsMiddleware, definePlugin, extractReasoningMiddleware, generateObject, generateText, getAllProviders, getProviderInfo as getClientInfo, getProvider, getSupportedProviders, isProviderSupported, mergeProviderOptions, providerConfigBuilder, registerProvider, simulateStreamingMiddleware, smoothStream, stepCountIs, streamText };