/**
 * @holoscript/llm-provider
 *
 * Unified LLM provider SDK for HoloScript.
 * Supports OpenAI, Anthropic (Claude), Google Gemini, and Mock adapters
 * with a consistent interface for scene generation and AI integration.
 *
 * @example
 * ```typescript
 * import { AnthropicAdapter, LLMProviderManager } from '@holoscript/llm-provider';
 *
 * const claude = new AnthropicAdapter({ apiKey: process.env.ANTHROPIC_API_KEY! });
 * const scene = await claude.generateHoloScript({
 *   prompt: "a floating island with glowing crystals and a waterfall",
 * });
 * console.log(scene.code);
 * ```
 *
 * @module @holoscript/llm-provider
 * @version 1.0.0
 */
export type { ILLMProvider, LLMMessage, LLMSystemMessage, LLMUserMessage, LLMAssistantMessage, MessageRole, LLMCompletionRequest, LLMCompletionResponse, LLMFileMetadata, LLMFileUploadRequest, TokenUsage, HoloScriptGenerationRequest, HoloScriptGenerationResponse, LLMProviderName, LLMProviderConfig, OpenAIApiSurface, OpenAIReasoningEffort, OpenAIProviderConfig, AnthropicProviderConfig, GeminiProviderConfig, BitNetProviderConfig, LocalLLMProviderConfig, OpenRouterProviderConfig, XAIProviderConfig, LLMProviderRegistry, ProviderSelectionStrategy, ToolSpec, ToolSpecUnion, AnthropicAdvisorToolSpec, CacheControlEphemeral, AnthropicFileSource, AnthropicDocumentFileBlock, AnthropicImageFileBlock, AnthropicContainerUploadBlock, AnthropicFileContentBlock, AnthropicFileContentBlockType, AnthropicFileContentBlockOptions, LLMContentBlock, AnthropicEffortLevel, AnthropicThinkingParam, ToolUseBlock, ToolResultBlock, TextBlock, AssistantContentBlock, LLMStreamChunk, Capabilities, InlineModerationRequest, InlineModerationResult, ProviderExtensions, OpenAIProviderExtensions, AnthropicProviderExtensions, GrokProviderExtensions, GeminiProviderExtensions, OllamaProviderExtensions, } from './types';
export { LLMProviderError, LLMRateLimitError, LLMAuthenticationError, LLMContextLengthError, LLMCreditExhaustedError, anthropicFileContentBlock, filterGenericTools, isAnthropicAdvisorTool, isToolSpec, messageContentAsString, } from './types';
export { BaseLLMAdapter } from './base-adapter';
export { OpenAIAdapter, OPENAI_MODELS, OPENAI_CAPABILITIES, messagesToOpenAIResponsesInput, parseOpenAIResponsesResult, parseOpenAIModerationResult, resolveOpenAIToolControls, toolSpecsToOpenAIResponseTools, } from './adapters/openai';
export type { OpenAIModel } from './adapters/openai';
export { supportsRealtime } from './realtime';
export type { RealtimeTransport, RealtimeSessionConfig, RealtimeSession, RealtimeServerEvent, EphemeralSecret, AudioUsage, } from './realtime';
export { OpenAIRealtimeAdapter, OPENAI_REALTIME_MODELS, DEFAULT_OPENAI_REALTIME_MODEL, DEFAULT_OPENAI_REALTIME_MINI_MODEL, openOpenAIRealtimeSession, mintOpenAIEphemeralSecret, } from './adapters/openai-realtime';
export type { OpenAIRealtimeModel, OpenAIRealtimeDeps, RealtimeWebSocketLike, RealtimeWebSocketFactory, RealtimeFetchLike, } from './adapters/openai-realtime';
export { AnthropicAdapter, ANTHROPIC_MODELS, ANTHROPIC_MODEL_METADATA, ANTHROPIC_CAPABILITIES, ANTHROPIC_ADVISOR_BETA, ANTHROPIC_FILES_BETA, buildThinkingAndOutputForAnthropic, collectAnthropicBetaHeaders, getAnthropicModelMetadata, hasAnthropicFileContent, isAnthropicDefaultRoutingEligible, } from './adapters/anthropic';
export type { AnthropicModel, AnthropicModelMetadata } from './adapters/anthropic';
export { GeminiAdapter, GEMINI_MODELS, GEMINI_MODEL_METADATA, GEMINI_CAPABILITIES, getGeminiModelMetadata, isGeminiDefaultRoutingEligible, } from './adapters/gemini';
export type { GeminiModel, GeminiModelMetadata } from './adapters/gemini';
export { MockAdapter, MOCK_CAPABILITIES } from './adapters/mock';
export { BitNetAdapter, BITNET_MODELS, BITNET_MODEL_ALIASES, BITNET_CAPABILITIES, } from './adapters/bitnet';
export type { BitNetModel } from './adapters/bitnet';
export { LocalLLMAdapter, LOCAL_LLM_MODELS, LOCAL_LLM_CAPABILITIES } from './adapters/local-llm';
export type { LocalLLMModel } from './adapters/local-llm';
export { OpenRouterAdapter, OPENROUTER_MODELS, OPENROUTER_CAPABILITIES, } from './adapters/openrouter';
export type { OpenRouterModel } from './adapters/openrouter';
export { OpenAICompatibleAdapter, OPENAI_COMPATIBLE_CAPABILITIES, } from './adapters/openai-compatible';
export type { OpenAICompatibleAdapterConfig } from './adapters/openai-compatible';
export { VastServerlessAdapter, VAST_SERVERLESS_CAPABILITIES } from './adapters/vast-serverless';
export type { VastServerlessAdapterConfig } from './adapters/vast-serverless';
export { XAIAdapter, XAI_MODELS, XAI_MODEL_CAPABILITIES, XAI_CAPABILITIES } from './adapters/xai';
export type { XAIModel, XAIModelCapability } from './adapters/xai';
export { BrittneyCloudAdapter, BRITTNEY_CLOUD_MODELS, BRITTNEY_CLOUD_CAPABILITIES, } from './adapters/brittney-cloud';
export type { BrittneyCloudModel, BrittneyCloudProviderConfig, BrittneyCloudLane, } from './adapters/brittney-cloud';
export { LLMProviderManager } from './provider-manager';
export type { ProviderManagerConfig } from './provider-manager';
export { resolveSovereignProvider, resolveSovereignProviderAsync } from './sovereign-resolver';
export type { ResolvedSovereignProvider, SovereignProviderName, SovereignResolveOptions, } from './sovereign-resolver';
export { LOCAL_DEFAULT_MODEL, FLEET_DEFAULT_MODEL, CLOUD_DEFAULT_MODEL, SAFE_LOCAL_FALLBACK, LANE_DEFAULTS, laneDefault, MODEL_LIBRARY, modelsForLane, modelLibraryEntry, MODEL_BLACKLIST, isBlacklistedModel, resolveAllowedModel, } from './model-policy';
export type { ModelLane, ModelTier, ModelLibraryEntry } from './model-policy';
export { planWeightDeltaGraph } from './weight-delta-graph';
export type { ContentDigest, WeightArtifactFormat, WeightArtifactRef, WeightCompatibility, WeightDeltaRole, WeightActivationMode, WeightRoleContract, WeightDelta, EvaluationRule, EvaluatorPolicy, EvaluationRequirement, EvaluationReceiptRef, WeightCompositionMethod, WeightComposition, WeightDeltaGraph, WeightGraphReadiness, WeightPlanIssueCode, WeightPlanIssue, AdmissionRequirementStatus, AdmissionRequirementPlan, WeightExecutionStep, WeightExecutionPlan, } from './weight-delta-graph';
export { pickLocalModel, __clearLocalModelPickerCache, OLLAMA_DEFAULT_BASE_URL, } from './local-model-picker';
export type { LocalModelChoice } from './local-model-picker';
export { parseFleetSpec, loadFleetSpec, resolveNodeEndpoint, discoverNode, discoverLlamaCppNode, discoverPytorchHoloNode, pickFleetModel, resolveLocalFleet, embedAcrossFleet, cosineSimilarity, } from './fleet-router';
export type { FleetNode, FleetBackend, FleetSpec, NodeDiscovery, FleetCandidate, FleetRoute, FleetRouteOptions, FetchLike, } from './fleet-router';
export { QuestGenerator } from './QuestGenerator';
export type { QuestNarrativeRequest, QuestNarrativeResponse } from './QuestGenerator';
export { InMemoryAgentStepGraph, KVFlowCacheManager, scopeFromBrainCaching, scopeToCacheUsage, estimateKVBytes, entryFromStep, } from './kvflow';
export type { StepNodeId, KVFlowScope, KVResidency, AgentStep, KVCacheEntry, KVFlowConfig, EvictionResult, PrefetchResult, KVFlowTelemetry, } from './kvflow';
export { getNarrativeQuestService, NarrativeQuestService, type QuestParams, } from './services/NarrativeQuestService';
import { OpenAIAdapter } from './adapters/openai';
import { AnthropicAdapter } from './adapters/anthropic';
import { GeminiAdapter } from './adapters/gemini';
import { MockAdapter } from './adapters/mock';
import { BitNetAdapter } from './adapters/bitnet';
import { LocalLLMAdapter } from './adapters/local-llm';
import { OpenRouterAdapter } from './adapters/openrouter';
import { OpenAICompatibleAdapter } from './adapters/openai-compatible';
import { XAIAdapter } from './adapters/xai';
import { BrittneyCloudAdapter } from './adapters/brittney-cloud';
import { LLMProviderManager } from './provider-manager';
import type { OpenAIProviderConfig, AnthropicProviderConfig, GeminiProviderConfig, BitNetProviderConfig, LocalLLMProviderConfig, OpenRouterProviderConfig, XAIProviderConfig, BrittneyCloudProviderConfig } from './types';
import type { OpenAICompatibleAdapterConfig } from './adapters/openai-compatible';
import type { FleetBackend } from './fleet-router';
/**
 * Create an OpenAI adapter from environment variables.
 * Uses OPENAI_API_KEY environment variable.
 */
export declare function createOpenAIProvider(config?: Partial<OpenAIProviderConfig>): OpenAIAdapter;
/**
 * Create an Anthropic adapter from environment variables.
 * Uses ANTHROPIC_API_KEY environment variable.
 */
export declare function createAnthropicProvider(config?: Partial<AnthropicProviderConfig>): AnthropicAdapter;
/**
 * Create a Gemini adapter from environment variables.
 * Uses GEMINI_API_KEY or GOOGLE_AI_API_KEY environment variable.
 */
export declare function createGeminiProvider(config?: Partial<GeminiProviderConfig>): GeminiAdapter;
/**
 * Create a mock provider for testing (no API key required).
 */
export declare function createMockProvider(): MockAdapter;
/**
 * Create a BitNet adapter targeting a local bitnet.cpp server.
 * Requires bitnet.cpp running at http://localhost:8080 (or custom baseURL).
 * No API key required — the server runs locally.
 *
 * Setup: https://github.com/microsoft/BitNet
 *   python setup_env.py -md microsoft/bitnet-b1.58-2B-4T -q i2_s
 *   python run_inference.py --serve --port 8080 --host 0.0.0.0
 *
 * @example
 * ```typescript
 * const bitnet = createBitNetProvider();
 * const health = await bitnet.healthCheck();
 * if (health.ok) {
 *   const scene = await bitnet.generateHoloScript({ prompt: 'a glowing sphere' });
 * }
 * ```
 */
export declare function createBitNetProvider(config?: Partial<BitNetProviderConfig>): BitNetAdapter;
/**
 * Create a LocalLLM adapter for any OpenAI-compatible local inference server.
 * Works with llama.cpp, Ollama, LM Studio, or similar.
 * No API key required — the server runs locally.
 *
 * @example
 * ```typescript
 * // llama.cpp: llama-server -m mistral-7b-instruct.gguf --port 8080
 * const localLlm = createLocalLLMProvider({ baseURL: 'http://localhost:8080' });
 * const scene = await localLlm.generateHoloScript({ prompt: 'a glowing sphere' });
 *
 * // Ollama: ollama serve
 * const ollama = createLocalLLMProvider({ baseURL: 'http://localhost:11434', model: 'mistral' });
 * ```
 */
export declare function createLocalLLMProvider(config?: Partial<LocalLLMProviderConfig>): LocalLLMAdapter;
/**
 * Create a LocalLLMAdapter from a fleet route, using the route's `backend`
 * (carried since the pytorch-holo fleet parity work) to select the wire
 * protocol IN-BAND: `ollama` → native /api/chat NDJSON, anything else
 * (llama.cpp llama-server, pytorch-holo HoloServe) → OpenAI-compat /v1/*.
 * Replaces the `:11434`-port-heuristic guess for routed consumers.
 *
 * @example
 * ```typescript
 * const picked = await resolveLocalFleet({ brainPath: process.env.HOLO_LLM_FLEET_BRAIN });
 * if (picked) {
 *   const adapter = createLocalLLMProviderForRoute(picked);
 *   const res = await adapter.complete({ messages }, picked.model);
 * }
 * ```
 */
export declare function createLocalLLMProviderForRoute(route: {
    baseURL: string;
    model: string;
    backend: FleetBackend;
}, config?: Partial<LocalLLMProviderConfig>): LocalLLMAdapter;
/**
 * Create an OpenRouter adapter from environment variables.
 * Uses OPENROUTER_API_KEY environment variable.
 * OpenRouter provides an OpenAI-compatible API that routes to 200+ models.
 *
 * @example
 * ```typescript
 * const openrouter = createOpenRouterProvider();
 * const scene = await openrouter.generateHoloScript({
 *   prompt: "a floating island with glowing crystals",
 * });
 * ```
 */
export declare function createOpenRouterProvider(config?: Partial<OpenRouterProviderConfig>): OpenRouterAdapter;
/**
 * Create an OpenAI-compatible Bearer adapter for any hosted endpoint that
 * speaks `${baseURL}/chat/completions` with an optional `Authorization: Bearer`
 * header (Fireworks, Together, Kimi-via-Fireworks, self-hosted vLLM/TGI/SGLang).
 *
 * Unlike the other factories this does NOT read an env var by default — the
 * endpoint baseURL is the discriminator, so the caller passes `{ baseURL,
 * apiKey?, model }` explicitly.
 *
 * @example
 * ```typescript
 * const fireworks = createOpenAICompatibleProvider({
 *   baseURL: 'https://api.fireworks.ai/inference/v1',
 *   apiKey: process.env.FIREWORKS_API_KEY,
 *   model: 'accounts/fireworks/models/llama-v3p1-8b-instruct',
 * });
 * ```
 */
export declare function createOpenAICompatibleProvider(config?: Partial<OpenAICompatibleAdapterConfig>): OpenAICompatibleAdapter;
/**
 * Create an xAI (Grok) adapter from environment variables.
 * Uses XAI_API_KEY environment variable.
 * xAI provides an OpenAI-compatible API at https://api.x.ai/v1.
 *
 * @example
 * ```typescript
 * const xai = createXAIProvider();
 * const scene = await xai.generateHoloScript({
 *   prompt: "a floating island with glowing crystals",
 * });
 * ```
 */
export declare function createXAIProvider(config?: Partial<XAIProviderConfig>): XAIAdapter;
/**
 * Create a Brittney Cloud adapter from environment variables.
 * Uses BRITTNEY_SERVICE_URL and optional BRITTNEY_API_KEY.
 *
 * Brittney Cloud is HoloScript's first-party inference gateway.
 * It routes to Fireworks, Together, Kimi, or Ollama backends.
 *
 * @example
 * ```typescript
 * const brittney = createBrittneyCloudProvider();
 * const scene = await brittney.generateHoloScript({
 *   prompt: "a floating island with glowing crystals",
 * });
 * ```
 */
export declare function createBrittneyCloudProvider(config?: Partial<BrittneyCloudProviderConfig>): BrittneyCloudAdapter;
/**
 * Create a provider manager with automatic provider detection.
 * Reads API keys from environment variables.
 */
export declare function createProviderManager(): LLMProviderManager;