@reactive-agents/llm-provider 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tyler Buell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,108 @@
+# @reactive-agents/llm-provider
+
+LLM provider adapters for the [Reactive Agents](https://tylerjrbuell.github.io/reactive-agents-ts/) framework.
+
+Provides a unified `LLMService` interface with adapters for Anthropic, OpenAI, Google Gemini, Ollama, and a deterministic test provider.
+
+## Installation
+
+```bash
+bun add @reactive-agents/llm-provider effect
+```
+
+Install the SDK for your chosen provider:
+
+```bash
+bun add @anthropic-ai/sdk          # Anthropic Claude
+bun add openai                     # OpenAI GPT-4o
+bun add @google/genai              # Google Gemini
+```
+
+## Supported Providers
+
+| Provider | Models | Streaming | Embeddings | Structured Output |
+|----------|--------|-----------|------------|------------------|
+| `anthropic` | claude-haiku, claude-sonnet, claude-opus | ✓ | — | ✓ |
+| `openai` | gpt-4o, gpt-4o-mini, o1-* | ✓ | ✓ | ✓ |
+| `gemini` | gemini-2.0-flash, gemini-2.5-pro | ✓ | ✓ | ✓ |
+| `ollama` | any local model | ✓ | ✓ | ✓ |
+| `test` | deterministic mock | ✓ | ✓ | — |
+
+## Usage
+
+### Anthropic
+
+```typescript
+import { createLLMProviderLayer, LLMService } from "@reactive-agents/llm-provider";
+import { Effect } from "effect";
+
+const layer = createLLMProviderLayer("anthropic");
+
+const result = await Effect.runPromise(
+  Effect.gen(function* () {
+    const llm = yield* LLMService;
+    return yield* llm.complete({
+      messages: [{ role: "user", content: "Hello!" }],
+    });
+  }).pipe(Effect.provide(layer)),
+);
+```
+
+### Google Gemini
+
+```typescript
+import { createLLMProviderLayer, LLMService } from "@reactive-agents/llm-provider";
+import { Effect } from "effect";
+
+// Set GOOGLE_API_KEY in your environment
+const layer = createLLMProviderLayer("gemini");
+
+const result = await Effect.runPromise(
+  Effect.gen(function* () {
+    const llm = yield* LLMService;
+    return yield* llm.complete({
+      messages: [{ role: "user", content: "Explain quantum entanglement." }],
+      model: { provider: "gemini", model: "gemini-2.0-flash" },
+    });
+  }).pipe(Effect.provide(layer)),
+);
+```
+
+## Environment Variables
+
+```bash
+ANTHROPIC_API_KEY=sk-ant-...     # Anthropic Claude
+OPENAI_API_KEY=sk-...            # OpenAI GPT-4o
+GOOGLE_API_KEY=...               # Google Gemini
+OLLAMA_ENDPOINT=http://localhost:11434  # Ollama (default)
+```
+
+## Model Presets
+
+Built-in presets with cost estimates:
+
+```typescript
+import { ModelPresets } from "@reactive-agents/llm-provider";
+
+// Available: claude-haiku, claude-sonnet, claude-opus,
+//            gpt-4o-mini, gpt-4o,
+//            gemini-2.0-flash, gemini-2.5-pro
+const preset = ModelPresets["gemini-2.0-flash"];
+// { provider: "gemini", model: "gemini-2.0-flash", costPer1MInput: 0.10, ... }
+```
+
+## Test Provider
+
+For deterministic testing without API calls:
+
+```typescript
+import { TestLLMServiceLayer } from "@reactive-agents/llm-provider";
+
+const layer = TestLLMServiceLayer({
+  "capital of France": "Paris is the capital of France.",
+});
+```
+
+## Documentation
+
+Full documentation at [tylerjrbuell.github.io/reactive-agents-ts](https://tylerjrbuell.github.io/reactive-agents-ts/)

package/dist/index.d.ts

@@ -0,0 +1,542 @@
+import { Schema, Context, Effect, Stream, Layer, Schedule } from 'effect';
+import * as effect_Cause from 'effect/Cause';
+import * as effect_Types from 'effect/Types';
+import * as effect_Duration from 'effect/Duration';
+
+declare const LLMProviderType: Schema.Literal<["anthropic", "openai", "ollama", "gemini", "custom"]>;
+type LLMProvider = Schema.Schema.Type<typeof LLMProviderType>;
+declare const EmbeddingConfigSchema: Schema.Struct<{
+    model: typeof Schema.String;
+    dimensions: typeof Schema.Number;
+    provider: Schema.Literal<["openai", "ollama"]>;
+    batchSize: Schema.optional<typeof Schema.Number>;
+}>;
+type EmbeddingConfig = Schema.Schema.Type<typeof EmbeddingConfigSchema>;
+declare const DefaultEmbeddingConfig: EmbeddingConfig;
+declare const ModelConfigSchema: Schema.Struct<{
+    provider: Schema.Literal<["anthropic", "openai", "ollama", "gemini", "custom"]>;
+    model: typeof Schema.String;
+    maxTokens: Schema.optional<typeof Schema.Number>;
+    temperature: Schema.optional<typeof Schema.Number>;
+    topP: Schema.optional<typeof Schema.Number>;
+    stopSequences: Schema.optional<Schema.Array$<typeof Schema.String>>;
+}>;
+type ModelConfig = Schema.Schema.Type<typeof ModelConfigSchema>;
+declare const ModelPresets: {
+    readonly "claude-haiku": {
+        readonly provider: "anthropic";
+        readonly model: "claude-3-5-haiku-20241022";
+        readonly costPer1MInput: 1;
+        readonly costPer1MOutput: 5;
+        readonly maxContext: 200000;
+        readonly quality: 0.6;
+    };
+    readonly "claude-sonnet": {
+        readonly provider: "anthropic";
+        readonly model: "claude-sonnet-4-20250514";
+        readonly costPer1MInput: 3;
+        readonly costPer1MOutput: 15;
+        readonly maxContext: 200000;
+        readonly quality: 0.85;
+    };
+    readonly "claude-sonnet-4-5": {
+        readonly provider: "anthropic";
+        readonly model: "claude-sonnet-4-5-20250929";
+        readonly costPer1MInput: 3;
+        readonly costPer1MOutput: 15;
+        readonly maxContext: 200000;
+        readonly quality: 0.9;
+    };
+    readonly "claude-opus": {
+        readonly provider: "anthropic";
+        readonly model: "claude-opus-4-20250514";
+        readonly costPer1MInput: 15;
+        readonly costPer1MOutput: 75;
+        readonly maxContext: 1000000;
+        readonly quality: 1;
+    };
+    readonly "gpt-4o-mini": {
+        readonly provider: "openai";
+        readonly model: "gpt-4o-mini";
+        readonly costPer1MInput: 0.15;
+        readonly costPer1MOutput: 0.6;
+        readonly maxContext: 128000;
+        readonly quality: 0.55;
+    };
+    readonly "gpt-4o": {
+        readonly provider: "openai";
+        readonly model: "gpt-4o";
+        readonly costPer1MInput: 2.5;
+        readonly costPer1MOutput: 10;
+        readonly maxContext: 128000;
+        readonly quality: 0.8;
+    };
+    readonly "gemini-2.0-flash": {
+        readonly provider: "gemini";
+        readonly model: "gemini-2.0-flash";
+        readonly costPer1MInput: 0.1;
+        readonly costPer1MOutput: 0.4;
+        readonly maxContext: 1000000;
+        readonly quality: 0.75;
+    };
+    readonly "gemini-2.5-pro": {
+        readonly provider: "gemini";
+        readonly model: "gemini-2.5-pro-preview-03-25";
+        readonly costPer1MInput: 1.25;
+        readonly costPer1MOutput: 10;
+        readonly maxContext: 1000000;
+        readonly quality: 0.95;
+    };
+};
+type ModelPresetName = keyof typeof ModelPresets;
+declare const CacheControlSchema: Schema.Struct<{
+    type: Schema.Literal<["ephemeral"]>;
+}>;
+type CacheControl = Schema.Schema.Type<typeof CacheControlSchema>;
+declare const ImageSourceSchema: Schema.Struct<{
+    type: Schema.Literal<["base64", "url"]>;
+    media_type: Schema.Literal<["image/png", "image/jpeg", "image/gif", "image/webp"]>;
+    data: typeof Schema.String;
+}>;
+type ImageSource = Schema.Schema.Type<typeof ImageSourceSchema>;
+declare const TextContentBlockSchema: Schema.Struct<{
+    type: Schema.Literal<["text"]>;
+    text: typeof Schema.String;
+    cache_control: Schema.optional<Schema.Struct<{
+        type: Schema.Literal<["ephemeral"]>;
+    }>>;
+}>;
+declare const ImageContentBlockSchema: Schema.Struct<{
+    type: Schema.Literal<["image"]>;
+    source: Schema.Struct<{
+        type: Schema.Literal<["base64", "url"]>;
+        media_type: Schema.Literal<["image/png", "image/jpeg", "image/gif", "image/webp"]>;
+        data: typeof Schema.String;
+    }>;
+}>;
+declare const ToolUseContentBlockSchema: Schema.Struct<{
+    type: Schema.Literal<["tool_use"]>;
+    id: typeof Schema.String;
+    name: typeof Schema.String;
+    input: typeof Schema.Unknown;
+}>;
+declare const ToolResultContentBlockSchema: Schema.Struct<{
+    type: Schema.Literal<["tool_result"]>;
+    tool_use_id: typeof Schema.String;
+    content: typeof Schema.String;
+}>;
+type ContentBlock = {
+    readonly type: "text";
+    readonly text: string;
+    readonly cache_control?: CacheControl;
+} | {
+    readonly type: "image";
+    readonly source: ImageSource;
+} | {
+    readonly type: "tool_use";
+    readonly id: string;
+    readonly name: string;
+    readonly input: unknown;
+} | {
+    readonly type: "tool_result";
+    readonly tool_use_id: string;
+    readonly content: string;
+};
+type CacheableContentBlock = {
+    readonly type: "text";
+    readonly text: string;
+    readonly cache_control: CacheControl;
+};
+/**
+ * Helper — wrap text in a cacheable content block.
+ * Non-Anthropic providers silently ignore `cache_control`.
+ */
+declare const makeCacheable: (text: string) => CacheableContentBlock;
+type LLMMessage = {
+    readonly role: "system";
+    readonly content: string;
+} | {
+    readonly role: "user";
+    readonly content: string | readonly ContentBlock[];
+} | {
+    readonly role: "assistant";
+    readonly content: string | readonly ContentBlock[];
+};
+declare const TokenUsageSchema: Schema.Struct<{
+    inputTokens: typeof Schema.Number;
+    outputTokens: typeof Schema.Number;
+    totalTokens: typeof Schema.Number;
+    estimatedCost: typeof Schema.Number;
+}>;
+type TokenUsage = Schema.Schema.Type<typeof TokenUsageSchema>;
+declare const StopReasonSchema: Schema.Literal<["end_turn", "max_tokens", "stop_sequence", "tool_use"]>;
+type StopReason = Schema.Schema.Type<typeof StopReasonSchema>;
+declare const ToolDefinitionSchema: Schema.Struct<{
+    name: typeof Schema.String;
+    description: typeof Schema.String;
+    inputSchema: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+}>;
+type ToolDefinition = Schema.Schema.Type<typeof ToolDefinitionSchema>;
+declare const ToolCallSchema: Schema.Struct<{
+    id: typeof Schema.String;
+    name: typeof Schema.String;
+    input: typeof Schema.Unknown;
+}>;
+type ToolCall = Schema.Schema.Type<typeof ToolCallSchema>;
+type CompletionRequest = {
+    readonly messages: readonly LLMMessage[];
+    readonly model?: ModelConfig;
+    readonly maxTokens?: number;
+    readonly temperature?: number;
+    readonly stopSequences?: readonly string[];
+    readonly tools?: readonly ToolDefinition[];
+    readonly systemPrompt?: string;
+};
+declare const CompletionResponseSchema: Schema.Struct<{
+    content: typeof Schema.String;
+    stopReason: Schema.Literal<["end_turn", "max_tokens", "stop_sequence", "tool_use"]>;
+    usage: Schema.Struct<{
+        inputTokens: typeof Schema.Number;
+        outputTokens: typeof Schema.Number;
+        totalTokens: typeof Schema.Number;
+        estimatedCost: typeof Schema.Number;
+    }>;
+    model: typeof Schema.String;
+    toolCalls: Schema.optional<Schema.Array$<Schema.Struct<{
+        id: typeof Schema.String;
+        name: typeof Schema.String;
+        input: typeof Schema.Unknown;
+    }>>>;
+}>;
+type CompletionResponse = Schema.Schema.Type<typeof CompletionResponseSchema>;
+type StreamEvent = {
+    readonly type: "text_delta";
+    readonly text: string;
+} | {
+    readonly type: "tool_use_start";
+    readonly id: string;
+    readonly name: string;
+} | {
+    readonly type: "tool_use_delta";
+    readonly input: string;
+} | {
+    readonly type: "content_complete";
+    readonly content: string;
+} | {
+    readonly type: "usage";
+    readonly usage: TokenUsage;
+} | {
+    readonly type: "error";
+    readonly error: string;
+};
+type StructuredCompletionRequest<A> = CompletionRequest & {
+    readonly outputSchema: Schema.Schema<A>;
+    readonly retryOnParseFail?: boolean;
+    readonly maxParseRetries?: number;
+};
+type TruncationStrategy = "drop-oldest" | "summarize-middle" | "sliding-window" | "importance-based";
+
+declare const LLMError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "LLMError";
+} & Readonly<A>;
+/**
+ * General LLM error — catch-all for unexpected provider failures.
+ */
+declare class LLMError extends LLMError_base<{
+    readonly message: string;
+    readonly provider: LLMProvider;
+    readonly cause?: unknown;
+}> {
+}
+declare const LLMRateLimitError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "LLMRateLimitError";
+} & Readonly<A>;
+/**
+ * Rate limit exceeded — includes retry-after hint.
+ */
+declare class LLMRateLimitError extends LLMRateLimitError_base<{
+    readonly message: string;
+    readonly provider: LLMProvider;
+    readonly retryAfterMs: number;
+}> {
+}
+declare const LLMTimeoutError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "LLMTimeoutError";
+} & Readonly<A>;
+/**
+ * Request timeout.
+ */
+declare class LLMTimeoutError extends LLMTimeoutError_base<{
+    readonly message: string;
+    readonly provider: LLMProvider;
+    readonly timeoutMs: number;
+}> {
+}
+declare const LLMParseError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "LLMParseError";
+} & Readonly<A>;
+/**
+ * Structured output parse failure.
+ */
+declare class LLMParseError extends LLMParseError_base<{
+    readonly message: string;
+    readonly rawOutput: string;
+    readonly expectedSchema: string;
+}> {
+}
+declare const LLMContextOverflowError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "LLMContextOverflowError";
+} & Readonly<A>;
+/**
+ * Context window overflow — too many tokens for the model.
+ */
+declare class LLMContextOverflowError extends LLMContextOverflowError_base<{
+    readonly message: string;
+    readonly tokenCount: number;
+    readonly maxTokens: number;
+}> {
+}
+/**
+ * Union of all LLM error types.
+ */
+type LLMErrors = LLMError | LLMRateLimitError | LLMTimeoutError | LLMParseError | LLMContextOverflowError;
+
+declare const LLMService_base: Context.TagClass<LLMService, "LLMService", {
+    /**
+     * Complete a prompt (non-streaming).
+     * Returns full response after generation completes.
+     */
+    readonly complete: (request: CompletionRequest) => Effect.Effect<CompletionResponse, LLMErrors>;
+    /**
+     * Stream a completion. Returns an Effect that yields a Stream of events.
+     * Use for real-time UI updates (collaborative mode).
+     */
+    readonly stream: (request: CompletionRequest) => Effect.Effect<Stream.Stream<StreamEvent, LLMErrors>, LLMErrors>;
+    /**
+     * Complete with structured output.
+     * Parses LLM response into a typed object using Effect Schema.
+     * Retries with parse error feedback if parsing fails.
+     */
+    readonly completeStructured: <A>(request: StructuredCompletionRequest<A>) => Effect.Effect<A, LLMErrors>;
+    /**
+     * Generate embeddings for text.
+     *
+     * This is the SOLE embedding source for the entire framework.
+     * Anthropic has no embeddings API — routes to OpenAI or Ollama
+     * per LLMConfig.embeddingConfig.
+     */
+    readonly embed: (texts: readonly string[], model?: string) => Effect.Effect<readonly number[][], LLMErrors>;
+    /**
+     * Count tokens for a set of messages.
+     * Used for context window management.
+     */
+    readonly countTokens: (messages: readonly LLMMessage[]) => Effect.Effect<number, LLMErrors>;
+    /**
+     * Get current model configuration.
+     */
+    readonly getModelConfig: () => Effect.Effect<ModelConfig, never>;
+}>;
+/**
+ * Core LLM service — all LLM interactions go through this.
+ * Layers 3, 4, 5, and 10 depend on this.
+ */
+declare class LLMService extends LLMService_base {
+}
+
+declare const LLMConfig_base: Context.TagClass<LLMConfig, "LLMConfig", {
+    readonly defaultProvider: LLMProvider;
+    readonly defaultModel: string;
+    readonly anthropicApiKey?: string;
+    readonly openaiApiKey?: string;
+    readonly googleApiKey?: string;
+    readonly ollamaEndpoint?: string;
+    /**
+     * Embedding configuration. Anthropic has no embeddings API;
+     * embeddings route to OpenAI (default) or Ollama.
+     * This is the SOLE embedding config for the entire framework.
+     */
+    readonly embeddingConfig: EmbeddingConfig;
+    /**
+     * Enable Anthropic prompt caching.
+     * When true, memory context injections are wrapped in
+     * `cache_control: { type: "ephemeral" }` blocks.
+     */
+    readonly supportsPromptCaching: boolean;
+    readonly maxRetries: number;
+    readonly timeoutMs: number;
+    readonly defaultMaxTokens: number;
+    readonly defaultTemperature: number;
+}>;
+/**
+ * LLM configuration — provided via environment or config file.
+ */
+declare class LLMConfig extends LLMConfig_base {
+}
+/**
+ * Build LLMConfig from environment variables.
+ */
+declare const LLMConfigFromEnv: Layer.Layer<LLMConfig, never, never>;
+
+declare const PromptManager_base: Context.TagClass<PromptManager, "PromptManager", {
+    /**
+     * Build a prompt within token budget.
+     * Automatically truncates conversation history if needed.
+     */
+    readonly buildPrompt: (options: {
+        readonly systemPrompt: string;
+        readonly messages: readonly LLMMessage[];
+        readonly reserveOutputTokens: number;
+        readonly maxContextTokens: number;
+        readonly truncationStrategy: TruncationStrategy;
+    }) => Effect.Effect<readonly LLMMessage[], LLMErrors>;
+    /**
+     * Check if messages fit within context window.
+     */
+    readonly fitsInContext: (messages: readonly LLMMessage[], maxTokens: number) => Effect.Effect<boolean, LLMErrors>;
+}>;
+/**
+ * Manages context window budgets.
+ * Ensures prompts don't exceed model limits.
+ * Implements truncation strategies.
+ */
+declare class PromptManager extends PromptManager_base {
+}
+/**
+ * Live PromptManager that uses heuristic token counting
+ * and applies truncation strategies.
+ */
+declare const PromptManagerLive: Layer.Layer<PromptManager, never, never>;
+
+declare const AnthropicProviderLive: Layer.Layer<LLMService, never, LLMConfig>;
+
+declare const OpenAIProviderLive: Layer.Layer<LLMService, never, LLMConfig>;
+
+declare const LocalProviderLive: Layer.Layer<LLMService, never, LLMConfig>;
+
+declare const GeminiProviderLive: Layer.Layer<LLMService, never, LLMConfig>;
+
+/**
+ * Create a deterministic test LLM service.
+ * Returns responses based on pattern matching against prompt content.
+ *
+ * Usage:
+ * ```ts
+ * const layer = TestLLMServiceLayer({
+ *   "capital of France": "Paris",
+ *   "plan": '{"goal":"test","steps":[]}',
+ * });
+ * ```
+ */
+declare const TestLLMService: (responses: Record<string, string>) => typeof LLMService.Service;
+/**
+ * Create a test Layer for LLMService with optional pattern-matched responses.
+ */
+declare const TestLLMServiceLayer: (responses?: Record<string, string>) => Layer.Layer<LLMService, never, never>;
+
+/**
+ * Estimate token count for messages.
+ * Uses a simple heuristic: ~4 characters per token for English text.
+ * This is used as a fallback when the provider's token counting API is unavailable.
+ */
+declare const estimateTokenCount: (messages: readonly LLMMessage[]) => Effect.Effect<number, never>;
+/**
+ * Calculate cost in USD given token counts and model name.
+ */
+declare const calculateCost: (inputTokens: number, outputTokens: number, model: string) => number;
+
+/**
+ * Retry policy for LLM calls.
+ * Handles rate limits with exponential backoff.
+ * Only retries on rate limit and timeout errors.
+ */
+declare const retryPolicy: Schedule.Schedule<[number, effect_Duration.Duration], LLMErrors, never>;
+
+/**
+ * Schema for ReAct action parsing.
+ */
+declare const ReActActionSchema: Schema.Struct<{
+    thought: typeof Schema.String;
+    action: Schema.optional<Schema.Struct<{
+        tool: typeof Schema.String;
+        input: typeof Schema.Unknown;
+    }>>;
+    finalAnswer: Schema.optional<typeof Schema.String>;
+    isComplete: typeof Schema.Boolean;
+}>;
+type ReActAction = Schema.Schema.Type<typeof ReActActionSchema>;
+/**
+ * Schema for plan generation.
+ */
+declare const PlanSchema: Schema.Struct<{
+    goal: typeof Schema.String;
+    steps: Schema.Array$<Schema.Struct<{
+        id: typeof Schema.Number;
+        description: typeof Schema.String;
+        tool: Schema.optional<typeof Schema.String>;
+        dependsOn: Schema.optional<Schema.Array$<typeof Schema.Number>>;
+        estimatedDuration: Schema.optional<typeof Schema.String>;
+    }>>;
+}>;
+type Plan = Schema.Schema.Type<typeof PlanSchema>;
+/**
+ * Schema for reflection output.
+ */
+declare const ReflectionSchema: Schema.Struct<{
+    taskAccomplished: typeof Schema.Boolean;
+    confidence: typeof Schema.Number;
+    strengths: Schema.Array$<typeof Schema.String>;
+    weaknesses: Schema.Array$<typeof Schema.String>;
+    needsRefinement: typeof Schema.Boolean;
+    refinementSuggestions: Schema.optional<Schema.Array$<typeof Schema.String>>;
+}>;
+type Reflection = Schema.Schema.Type<typeof ReflectionSchema>;
+/**
+ * Schema for strategy selection.
+ */
+declare const StrategySelectionSchema: Schema.Struct<{
+    selectedStrategy: typeof Schema.String;
+    reasoning: typeof Schema.String;
+    confidence: typeof Schema.Number;
+    alternativeStrategies: Schema.Array$<Schema.Struct<{
+        strategy: typeof Schema.String;
+        whyNot: typeof Schema.String;
+    }>>;
+}>;
+type StrategySelection = Schema.Schema.Type<typeof StrategySelectionSchema>;
+/**
+ * Schema for thought evaluation (Tree-of-Thought).
+ */
+declare const ThoughtEvaluationSchema: Schema.Struct<{
+    score: typeof Schema.Number;
+    reasoning: typeof Schema.String;
+    strengths: Schema.Array$<typeof Schema.String>;
+    weaknesses: Schema.Array$<typeof Schema.String>;
+    shouldExpand: typeof Schema.Boolean;
+}>;
+type ThoughtEvaluation = Schema.Schema.Type<typeof ThoughtEvaluationSchema>;
+/**
+ * Schema for task complexity analysis.
+ */
+declare const ComplexityAnalysisSchema: Schema.Struct<{
+    score: typeof Schema.Number;
+    factors: Schema.Array$<Schema.Struct<{
+        factor: typeof Schema.String;
+        weight: typeof Schema.Number;
+        reasoning: typeof Schema.String;
+    }>>;
+    recommendedStrategy: typeof Schema.String;
+    recommendedModel: typeof Schema.String;
+}>;
+type ComplexityAnalysis = Schema.Schema.Type<typeof ComplexityAnalysisSchema>;
+
+/**
+ * Create the LLM provider layer for a specific provider.
+ * Uses env vars for configuration by default.
+ */
+declare const createLLMProviderLayer: (provider?: "anthropic" | "openai" | "ollama" | "gemini" | "test", testResponses?: Record<string, string>) => Layer.Layer<LLMService | PromptManager, never, never>;
+/**
+ * LLM layer with custom config (for programmatic use).
+ */
+declare const createLLMProviderLayerWithConfig: (config: typeof LLMConfig.Service, provider?: "anthropic" | "openai" | "ollama" | "gemini") => Layer.Layer<LLMService | PromptManager, never, never>;
+
+export { AnthropicProviderLive, type CacheControl, CacheControlSchema, type CacheableContentBlock, type CompletionRequest, type CompletionResponse, CompletionResponseSchema, type ComplexityAnalysis, ComplexityAnalysisSchema, type ContentBlock, DefaultEmbeddingConfig, type EmbeddingConfig, EmbeddingConfigSchema, GeminiProviderLive, ImageContentBlockSchema, type ImageSource, ImageSourceSchema, LLMConfig, LLMConfigFromEnv, LLMContextOverflowError, LLMError, type LLMErrors, type LLMMessage, LLMParseError, type LLMProvider, LLMProviderType, LLMRateLimitError, LLMService, LLMTimeoutError, LocalProviderLive, type ModelConfig, ModelConfigSchema, type ModelPresetName, ModelPresets, OpenAIProviderLive, type Plan, PlanSchema, PromptManager, PromptManagerLive, type ReActAction, ReActActionSchema, type Reflection, ReflectionSchema, type StopReason, StopReasonSchema, type StrategySelection, StrategySelectionSchema, type StreamEvent, type StructuredCompletionRequest, TestLLMService, TestLLMServiceLayer, TextContentBlockSchema, type ThoughtEvaluation, ThoughtEvaluationSchema, type TokenUsage, TokenUsageSchema, type ToolCall, ToolCallSchema, type ToolDefinition, ToolDefinitionSchema, ToolResultContentBlockSchema, ToolUseContentBlockSchema, type TruncationStrategy, calculateCost, createLLMProviderLayer, createLLMProviderLayerWithConfig, estimateTokenCount, makeCacheable, retryPolicy };