@reactive-agents/llm-provider 0.5.0 → 0.5.5

package/dist/index.js

@@ -1123,16 +1123,27 @@ var init_dist = __esm({
 // src/types.ts
 import { Schema } from "effect";
 var LLMProviderType = Schema.Literal(
+  /** Claude models via Anthropic API. Requires ANTHROPIC_API_KEY. */
   "anthropic",
+  /** GPT models via OpenAI API. Requires OPENAI_API_KEY. */
   "openai",
+  /** Local models via Ollama. Requires a running Ollama server. */
   "ollama",
+  /** Google Gemini models. Requires GOOGLE_API_KEY. */
   "gemini",
+  /** LiteLLM proxy — unified gateway to 40+ model providers. */
+  "litellm",
+  /** User-defined provider adapter — implement the LLMService interface. */
   "custom"
 );
 var EmbeddingConfigSchema = Schema.Struct({
+  /** Embedding model name (e.g., "text-embedding-3-small") */
   model: Schema.String,
+  /** Output embedding vector dimensionality */
   dimensions: Schema.Number,
+  /** Provider hosting the embedding model */
   provider: Schema.Literal("openai", "ollama"),
+  /** Maximum vectors to embed in a single API call (default: 100) */
   batchSize: Schema.optional(Schema.Number)
 });
 var DefaultEmbeddingConfig = {
@@ -1142,110 +1153,176 @@ var DefaultEmbeddingConfig = {
   batchSize: 100
 };
 var ModelConfigSchema = Schema.Struct({
+  /** LLM provider identifier */
   provider: LLMProviderType,
+  /** Model name/identifier for the provider */
   model: Schema.String,
+  /** Maximum tokens in response (optional) */
   maxTokens: Schema.optional(Schema.Number),
+  /** Sampling temperature 0.0-1.0 (optional) */
   temperature: Schema.optional(Schema.Number),
+  /** Top-p (nucleus) sampling probability (optional) */
   topP: Schema.optional(Schema.Number),
+  /** Stop sequences to halt generation (optional) */
   stopSequences: Schema.optional(Schema.Array(Schema.String))
 });
 var ModelPresets = {
+  /**
+   * Claude 3.5 Haiku — fast, cost-effective Anthropic model.
+   * Best for low-latency, simple reasoning tasks; not recommended for complex analysis.
+   */
   "claude-haiku": {
     provider: "anthropic",
     model: "claude-3-5-haiku-20241022",
+    /** Cost per 1 million input tokens in USD */
     costPer1MInput: 1,
+    /** Cost per 1 million output tokens in USD */
     costPer1MOutput: 5,
+    /** Maximum context window in tokens */
     maxContext: 2e5,
+    /** Quality tier (0.6 = reliable for simple tasks) */
     quality: 0.6
   },
+  /**
+   * Claude Sonnet 4 — balanced Anthropic model.
+   * Recommended for general-purpose reasoning, tool use, and production agents.
+   */
   "claude-sonnet": {
     provider: "anthropic",
     model: "claude-sonnet-4-20250514",
     costPer1MInput: 3,
     costPer1MOutput: 15,
     maxContext: 2e5,
+    /** Quality tier (0.85 = excellent reasoning) */
     quality: 0.85
   },
+  /**
+   * Claude Sonnet 4.5 — latest Anthropic model.
+   * Superior reasoning over Sonnet 4; recommended for complex multi-step reasoning.
+   */
   "claude-sonnet-4-5": {
     provider: "anthropic",
     model: "claude-sonnet-4-5-20250929",
     costPer1MInput: 3,
     costPer1MOutput: 15,
     maxContext: 2e5,
+    /** Quality tier (0.9 = very strong reasoning) */
     quality: 0.9
   },
+  /**
+   * Claude Opus 4 — most capable Anthropic model.
+   * Best for complex analysis, research, and high-accuracy multi-hop reasoning.
+   * Largest context window (1M tokens); highest cost.
+   */
   "claude-opus": {
     provider: "anthropic",
     model: "claude-opus-4-20250514",
     costPer1MInput: 15,
     costPer1MOutput: 75,
     maxContext: 1e6,
+    /** Quality tier (1.0 = frontier-class reasoning) */
     quality: 1
   },
+  /**
+   * GPT-4o Mini — fast, low-cost OpenAI model.
+   * Good for simple tasks and high-throughput scenarios.
+   */
   "gpt-4o-mini": {
     provider: "openai",
     model: "gpt-4o-mini",
     costPer1MInput: 0.15,
     costPer1MOutput: 0.6,
     maxContext: 128e3,
+    /** Quality tier (0.55 = capable but less reliable for complex reasoning) */
     quality: 0.55
   },
+  /**
+   * GPT-4o — latest OpenAI flagship model.
+   * Strong reasoning, multimodal support; recommended for tool use and complex analysis.
+   */
   "gpt-4o": {
     provider: "openai",
     model: "gpt-4o",
     costPer1MInput: 2.5,
     costPer1MOutput: 10,
     maxContext: 128e3,
+    /** Quality tier (0.8 = very good reasoning) */
     quality: 0.8
   },
+  /**
+   * Gemini 2.0 Flash — fast Google model.
+   * Excellent speed and cost efficiency; large 1M context window.
+   */
   "gemini-2.0-flash": {
     provider: "gemini",
     model: "gemini-2.0-flash",
     costPer1MInput: 0.1,
     costPer1MOutput: 0.4,
     maxContext: 1e6,
+    /** Quality tier (0.75 = good reasoning) */
     quality: 0.75
   },
+  /**
+   * Gemini 2.5 Pro Preview — advanced Google model.
+   * Superior reasoning to Flash; large context window and competitive pricing.
+   */
   "gemini-2.5-pro": {
     provider: "gemini",
     model: "gemini-2.5-pro-preview-03-25",
     costPer1MInput: 1.25,
     costPer1MOutput: 10,
     maxContext: 1e6,
+    /** Quality tier (0.95 = excellent reasoning) */
     quality: 0.95
   }
 };
 var CacheControlSchema = Schema.Struct({
+  /** Cache type: "ephemeral" for request-scoped caching */
   type: Schema.Literal("ephemeral")
 });
 var ImageSourceSchema = Schema.Struct({
+  /** Image source type: "base64" for encoded data or "url" for HTTP(S) URL */
   type: Schema.Literal("base64", "url"),
+  /** MIME type of image: PNG, JPEG, GIF, or WebP */
   media_type: Schema.Literal(
     "image/png",
     "image/jpeg",
     "image/gif",
     "image/webp"
   ),
+  /** Either base64-encoded data or HTTPS URL */
   data: Schema.String
 });
 var TextContentBlockSchema = Schema.Struct({
+  /** Content type identifier */
   type: Schema.Literal("text"),
+  /** Text content */
   text: Schema.String,
+  /** Optional Anthropic cache control directive */
   cache_control: Schema.optional(CacheControlSchema)
 });
 var ImageContentBlockSchema = Schema.Struct({
+  /** Content type identifier */
   type: Schema.Literal("image"),
+  /** Image source reference */
   source: ImageSourceSchema
 });
 var ToolUseContentBlockSchema = Schema.Struct({
+  /** Content type identifier */
   type: Schema.Literal("tool_use"),
+  /** Unique tool call identifier */
   id: Schema.String,
+  /** Tool name being invoked */
   name: Schema.String,
+  /** Tool parameters (JSON-compatible object) */
   input: Schema.Unknown
 });
 var ToolResultContentBlockSchema = Schema.Struct({
+  /** Content type identifier */
   type: Schema.Literal("tool_result"),
+  /** ID of tool call this result corresponds to */
   tool_use_id: Schema.String,
+  /** Tool result/output content */
   content: Schema.String
 });
 var makeCacheable = (text) => ({
@@ -1254,32 +1331,51 @@ var makeCacheable = (text) => ({
   cache_control: { type: "ephemeral" }
 });
 var TokenUsageSchema = Schema.Struct({
+  /** Tokens consumed by the input (messages + system prompt) */
   inputTokens: Schema.Number,
+  /** Tokens generated in the response */
   outputTokens: Schema.Number,
+  /** Sum of input and output tokens */
   totalTokens: Schema.Number,
+  /** Estimated cost in USD based on provider pricing */
   estimatedCost: Schema.Number
 });
 var StopReasonSchema = Schema.Literal(
+  /** Model concluded naturally — full response present. */
   "end_turn",
+  /** Hit `maxTokens` limit — response may be truncated. */
   "max_tokens",
+  /** Hit a configured stop sequence — generation halted by design. */
   "stop_sequence",
+  /** Model is invoking a tool — `toolCalls` array is populated. */
   "tool_use"
 );
 var ToolDefinitionSchema = Schema.Struct({
+  /** Tool identifier (used by model to invoke the tool) */
   name: Schema.String,
+  /** Human-readable tool description for the model */
   description: Schema.String,
+  /** Input schema describing expected parameters (JSON Schema format) */
   inputSchema: Schema.Record({ key: Schema.String, value: Schema.Unknown })
 });
 var ToolCallSchema = Schema.Struct({
+  /** Unique tool call identifier (generated by model) */
   id: Schema.String,
+  /** Tool name to invoke */
   name: Schema.String,
+  /** Tool input parameters (arbitrary JSON-compatible object) */
   input: Schema.Unknown
 });
 var CompletionResponseSchema = Schema.Struct({
+  /** Generated response content (text only, no content blocks) */
   content: Schema.String,
+  /** Why the model stopped generating */
   stopReason: StopReasonSchema,
+  /** Token usage statistics */
   usage: TokenUsageSchema,
+  /** Actual model identifier used (may differ from request) */
   model: Schema.String,
+  /** Tool calls emitted by the model (if any) */
   toolCalls: Schema.optional(Schema.Array(ToolCallSchema))
 });
 
@@ -2068,12 +2164,34 @@ var mapOpenAIResponse = (response, model) => {
 
 // src/providers/local.ts
 import { Effect as Effect6, Layer as Layer5, Stream as Stream3, Schema as Schema4 } from "effect";
-var toOllamaMessages = (messages) => messages.filter((m) => m.role !== "tool").map((m) => ({
-  role: m.role,
-  content: typeof m.content === "string" ? m.content : m.content.filter(
-    (b) => b.type === "text"
-  ).map((b) => b.text).join("")
-}));
+var toOllamaMessages = (messages) => messages.map((m) => {
+  if (m.role === "tool") {
+    return { role: "tool", content: m.content };
+  }
+  if (m.role === "assistant") {
+    const textContent = typeof m.content === "string" ? m.content : m.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+    const toolUseBlocks = typeof m.content !== "string" ? m.content.filter(
+      (b) => b.type === "tool_use"
+    ) : [];
+    return {
+      role: "assistant",
+      content: textContent,
+      ...toolUseBlocks.length > 0 ? {
+        tool_calls: toolUseBlocks.map((tc) => ({
+          function: {
+            name: tc.name,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            arguments: tc.input ?? {}
+          }
+        }))
+      } : {}
+    };
+  }
+  return {
+    role: m.role,
+    content: typeof m.content === "string" ? m.content : m.content.filter((b) => b.type === "text").map((b) => b.text).join("")
+  };
+});
 var toOllamaTools = (tools) => {
   if (!tools || tools.length === 0) return void 0;
   return tools.map((t) => ({
@@ -2657,10 +2775,349 @@ No markdown, no code fences, just raw JSON.`
   })
 );
 
-// src/testing.ts
+// src/providers/litellm.ts
 import { Effect as Effect8, Layer as Layer7, Stream as Stream5, Schema as Schema6 } from "effect";
+var toLiteLLMMessages = (messages) => messages.map((m) => {
+  if (m.role === "tool") {
+    return {
+      role: "tool",
+      tool_call_id: m.toolCallId,
+      content: m.content
+    };
+  }
+  return {
+    role: m.role,
+    content: typeof m.content === "string" ? m.content : m.content.filter(
+      (b) => b.type === "text"
+    ).map((b) => b.text).join("")
+  };
+});
+var toEffectError4 = (error) => {
+  const err = error;
+  if (err.status === 429) {
+    return new LLMRateLimitError({
+      message: err.message ?? "Rate limit exceeded",
+      provider: "litellm",
+      retryAfterMs: 6e4
+    });
+  }
+  return new LLMError({
+    message: err.message ?? String(error),
+    provider: "litellm",
+    cause: error
+  });
+};
+var toLiteLLMTool = (tool) => ({
+  type: "function",
+  function: {
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.inputSchema
+  }
+});
+var mapLiteLLMResponse = (response, model) => {
+  const message = response.choices[0]?.message;
+  const content = message?.content ?? "";
+  const rawToolCalls = message?.tool_calls;
+  const hasToolCalls = rawToolCalls && rawToolCalls.length > 0;
+  const stopReason = response.choices[0]?.finish_reason === "tool_calls" || hasToolCalls ? "tool_use" : response.choices[0]?.finish_reason === "stop" ? "end_turn" : response.choices[0]?.finish_reason === "length" ? "max_tokens" : "end_turn";
+  const toolCalls = hasToolCalls ? rawToolCalls.map((tc) => {
+    let input;
+    try {
+      input = JSON.parse(tc.function.arguments);
+    } catch {
+      input = { raw: tc.function.arguments };
+    }
+    return { id: tc.id, name: tc.function.name, input };
+  }) : void 0;
+  return {
+    content,
+    stopReason,
+    usage: {
+      inputTokens: response.usage?.prompt_tokens ?? 0,
+      outputTokens: response.usage?.completion_tokens ?? 0,
+      totalTokens: response.usage?.total_tokens ?? 0,
+      estimatedCost: calculateCost(
+        response.usage?.prompt_tokens ?? 0,
+        response.usage?.completion_tokens ?? 0,
+        model
+      )
+    },
+    model: response.model ?? model,
+    toolCalls
+  };
+};
+var liteLLMFetch = async (baseURL, path, body, apiKey) => {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`;
+  const res = await fetch(`${baseURL}${path}`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw Object.assign(
+      new Error(`LiteLLM ${res.status}: ${text || res.statusText}`),
+      { status: res.status }
+    );
+  }
+  return res.json();
+};
+var LiteLLMProviderLive = Layer7.effect(
+  LLMService,
+  Effect8.gen(function* () {
+    const config = yield* LLMConfig;
+    const baseURL = config.litellmBaseUrl ?? process.env.LITELLM_BASE_URL ?? "http://localhost:4000";
+    const apiKey = config.litellmApiKey ?? process.env.LITELLM_API_KEY ?? void 0;
+    const defaultModel = config.defaultModel;
+    return LLMService.of({
+      complete: (request) => Effect8.gen(function* () {
+        const model = typeof request.model === "string" ? request.model : request.model?.model ?? defaultModel;
+        const messages = toLiteLLMMessages(request.messages);
+        if (request.systemPrompt) {
+          messages.unshift({ role: "system", content: request.systemPrompt });
+        }
+        const requestBody = {
+          model,
+          max_tokens: request.maxTokens ?? config.defaultMaxTokens,
+          temperature: request.temperature ?? config.defaultTemperature,
+          messages,
+          stop: request.stopSequences ? [...request.stopSequences] : void 0
+        };
+        if (request.tools && request.tools.length > 0) {
+          requestBody.tools = request.tools.map(toLiteLLMTool);
+        }
+        const response = yield* Effect8.tryPromise({
+          try: () => liteLLMFetch(baseURL, "/chat/completions", requestBody, apiKey),
+          catch: (error) => toEffectError4(error)
+        });
+        return mapLiteLLMResponse(response, model);
+      }).pipe(
+        Effect8.retry(retryPolicy),
+        Effect8.timeout("30 seconds"),
+        Effect8.catchTag(
+          "TimeoutException",
+          () => Effect8.fail(
+            new LLMTimeoutError({
+              message: "LLM request timed out",
+              provider: "litellm",
+              timeoutMs: 3e4
+            })
+          )
+        )
+      ),
+      stream: (request) => Effect8.gen(function* () {
+        const model = typeof request.model === "string" ? request.model : request.model?.model ?? defaultModel;
+        return Stream5.async((emit) => {
+          const doStream = async () => {
+            try {
+              const headers = {
+                "Content-Type": "application/json"
+              };
+              if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`;
+              const messages = toLiteLLMMessages(request.messages);
+              if (request.systemPrompt) {
+                messages.unshift({
+                  role: "system",
+                  content: request.systemPrompt
+                });
+              }
+              const res = await fetch(`${baseURL}/chat/completions`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify({
+                  model,
+                  max_tokens: request.maxTokens ?? config.defaultMaxTokens,
+                  temperature: request.temperature ?? config.defaultTemperature,
+                  messages,
+                  stream: true
+                })
+              });
+              if (!res.ok || !res.body) {
+                throw new Error(`LiteLLM stream error: ${res.status}`);
+              }
+              const reader = res.body.getReader();
+              const decoder = new TextDecoder();
+              let buffer = "";
+              let fullContent = "";
+              while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop() ?? "";
+                for (const line of lines) {
+                  const trimmed = line.trim();
+                  if (!trimmed.startsWith("data:")) continue;
+                  const data = trimmed.slice(5).trim();
+                  if (data === "[DONE]") {
+                    emit.single({
+                      type: "content_complete",
+                      content: fullContent
+                    });
+                    emit.end();
+                    return;
+                  }
+                  try {
+                    const chunk = JSON.parse(data);
+                    const delta = chunk.choices[0]?.delta?.content;
+                    if (delta) {
+                      fullContent += delta;
+                      emit.single({ type: "text_delta", text: delta });
+                    }
+                    if (chunk.choices[0]?.finish_reason) {
+                      const inputTokens = chunk.usage?.prompt_tokens ?? 0;
+                      const outputTokens = chunk.usage?.completion_tokens ?? 0;
+                      emit.single({
+                        type: "usage",
+                        usage: {
+                          inputTokens,
+                          outputTokens,
+                          totalTokens: inputTokens + outputTokens,
+                          estimatedCost: calculateCost(
+                            inputTokens,
+                            outputTokens,
+                            model
+                          )
+                        }
+                      });
+                    }
+                  } catch {
+                  }
+                }
+              }
+            } catch (error) {
+              const err = error;
+              emit.fail(
+                new LLMError({
+                  message: err.message ?? String(error),
+                  provider: "litellm",
+                  cause: error
+                })
+              );
+            }
+          };
+          void doStream();
+        });
+      }),
+      completeStructured: (request) => Effect8.gen(function* () {
+        const schemaStr = JSON.stringify(
+          Schema6.encodedSchema(request.outputSchema),
+          null,
+          2
+        );
+        const messagesWithFormat = [
+          ...request.messages,
+          {
+            role: "user",
+            content: `
+Respond with ONLY valid JSON matching this schema:
+${schemaStr}
+
+No markdown, no code fences, just raw JSON.`
+          }
+        ];
+        let lastError = null;
+        const maxRetries = request.maxParseRetries ?? 2;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+          const msgs = attempt === 0 ? messagesWithFormat : [
+            ...messagesWithFormat,
+            {
+              role: "assistant",
+              content: String(lastError)
+            },
+            {
+              role: "user",
+              content: `That response was not valid JSON. The parse error was: ${String(lastError)}. Please try again with valid JSON only.`
+            }
+          ];
+          const model = typeof request.model === "string" ? request.model : request.model?.model ?? defaultModel;
+          const completeResult = yield* Effect8.tryPromise({
+            try: () => liteLLMFetch(
+              baseURL,
+              "/chat/completions",
+              {
+                model,
+                max_tokens: request.maxTokens ?? config.defaultMaxTokens,
+                temperature: request.temperature ?? config.defaultTemperature,
+                messages: toLiteLLMMessages(msgs)
+              },
+              apiKey
+            ),
+            catch: (error) => toEffectError4(error)
+          });
+          const response = mapLiteLLMResponse(
+            completeResult,
+            model
+          );
+          try {
+            const parsed = JSON.parse(response.content);
+            const decoded = Schema6.decodeUnknownEither(
+              request.outputSchema
+            )(parsed);
+            if (decoded._tag === "Right") {
+              return decoded.right;
+            }
+            lastError = decoded.left;
+          } catch (e) {
+            lastError = e;
+          }
+        }
+        return yield* Effect8.fail(
+          new LLMParseError({
+            message: `Failed to parse structured output after ${maxRetries + 1} attempts`,
+            rawOutput: String(lastError),
+            expectedSchema: schemaStr
+          })
+        );
+      }),
+      embed: (texts, model) => Effect8.tryPromise({
+        try: async () => {
+          const embeddingModel = model ?? config.embeddingConfig.model;
+          const batchSize = config.embeddingConfig.batchSize ?? 100;
+          const results = [];
+          for (let i = 0; i < texts.length; i += batchSize) {
+            const batch = texts.slice(i, i + batchSize);
+            const response = await liteLLMFetch(
+              baseURL,
+              "/embeddings",
+              {
+                model: embeddingModel,
+                input: [...batch],
+                dimensions: config.embeddingConfig.dimensions
+              },
+              apiKey
+            );
+            results.push(
+              ...response.data.map((d) => d.embedding)
+            );
+          }
+          return results;
+        },
+        catch: (error) => new LLMError({
+          message: `Embedding failed: ${error}`,
+          provider: "litellm",
+          cause: error
+        })
+      }),
+      countTokens: (messages) => Effect8.gen(function* () {
+        return yield* estimateTokenCount(messages);
+      }),
+      getModelConfig: () => Effect8.succeed({
+        provider: "litellm",
+        model: defaultModel
+      })
+    });
+  })
+);
+
+// src/testing.ts
+import { Effect as Effect9, Layer as Layer8, Stream as Stream6, Schema as Schema7 } from "effect";
 var TestLLMService = (responses) => ({
-  complete: (request) => Effect8.gen(function* () {
+  complete: (request) => Effect9.gen(function* () {
     const lastMessage = request.messages[request.messages.length - 1];
     const content = lastMessage && typeof lastMessage.content === "string" ? lastMessage.content : "";
     const systemPrompt = typeof request.systemPrompt === "string" ? request.systemPrompt : "";
@@ -2692,8 +3149,8 @@ var TestLLMService = (responses) => ({
       model: "test-model"
     };
   }),
-  stream: (_request) => Effect8.succeed(
-    Stream5.make(
+  stream: (_request) => Effect9.succeed(
+    Stream6.make(
       { type: "text_delta", text: "Test " },
       { type: "text_delta", text: "response" },
       {
@@ -2711,7 +3168,7 @@ var TestLLMService = (responses) => ({
       }
     )
   ),
-  completeStructured: (request) => Effect8.gen(function* () {
+  completeStructured: (request) => Effect9.gen(function* () {
     const lastMessage = request.messages[request.messages.length - 1];
     const content = lastMessage && typeof lastMessage.content === "string" ? lastMessage.content : "";
     let responseContent = "Test response";
@@ -2722,109 +3179,109 @@ var TestLLMService = (responses) => ({
       }
     }
     const parsed = JSON.parse(responseContent);
-    return Schema6.decodeUnknownSync(request.outputSchema)(parsed);
+    return Schema7.decodeUnknownSync(request.outputSchema)(parsed);
   }),
-  embed: (texts) => Effect8.succeed(
+  embed: (texts) => Effect9.succeed(
     texts.map(() => new Array(768).fill(0).map(() => Math.random()))
   ),
-  countTokens: (messages) => Effect8.succeed(
+  countTokens: (messages) => Effect9.succeed(
     messages.reduce(
       (sum, m) => sum + (typeof m.content === "string" ? Math.ceil(m.content.length / 4) : 100),
       0
     )
   ),
-  getModelConfig: () => Effect8.succeed({
+  getModelConfig: () => Effect9.succeed({
     provider: "anthropic",
     model: "test-model"
   })
 });
-var TestLLMServiceLayer = (responses = {}) => Layer7.succeed(LLMService, LLMService.of(TestLLMService(responses)));
+var TestLLMServiceLayer = (responses = {}) => Layer8.succeed(LLMService, LLMService.of(TestLLMService(responses)));
 
 // src/structured-output.ts
-import { Schema as Schema7 } from "effect";
-var ReActActionSchema = Schema7.Struct({
-  thought: Schema7.String,
-  action: Schema7.optional(
-    Schema7.Struct({
-      tool: Schema7.String,
-      input: Schema7.Unknown
+import { Schema as Schema8 } from "effect";
+var ReActActionSchema = Schema8.Struct({
+  thought: Schema8.String,
+  action: Schema8.optional(
+    Schema8.Struct({
+      tool: Schema8.String,
+      input: Schema8.Unknown
     })
   ),
-  finalAnswer: Schema7.optional(Schema7.String),
-  isComplete: Schema7.Boolean
+  finalAnswer: Schema8.optional(Schema8.String),
+  isComplete: Schema8.Boolean
 });
-var PlanSchema = Schema7.Struct({
-  goal: Schema7.String,
-  steps: Schema7.Array(
-    Schema7.Struct({
-      id: Schema7.Number,
-      description: Schema7.String,
-      tool: Schema7.optional(Schema7.String),
-      dependsOn: Schema7.optional(Schema7.Array(Schema7.Number)),
-      estimatedDuration: Schema7.optional(Schema7.String)
+var PlanSchema = Schema8.Struct({
+  goal: Schema8.String,
+  steps: Schema8.Array(
+    Schema8.Struct({
+      id: Schema8.Number,
+      description: Schema8.String,
+      tool: Schema8.optional(Schema8.String),
+      dependsOn: Schema8.optional(Schema8.Array(Schema8.Number)),
+      estimatedDuration: Schema8.optional(Schema8.String)
     })
   )
 });
-var ReflectionSchema = Schema7.Struct({
-  taskAccomplished: Schema7.Boolean,
-  confidence: Schema7.Number,
-  strengths: Schema7.Array(Schema7.String),
-  weaknesses: Schema7.Array(Schema7.String),
-  needsRefinement: Schema7.Boolean,
-  refinementSuggestions: Schema7.optional(Schema7.Array(Schema7.String))
+var ReflectionSchema = Schema8.Struct({
+  taskAccomplished: Schema8.Boolean,
+  confidence: Schema8.Number,
+  strengths: Schema8.Array(Schema8.String),
+  weaknesses: Schema8.Array(Schema8.String),
+  needsRefinement: Schema8.Boolean,
+  refinementSuggestions: Schema8.optional(Schema8.Array(Schema8.String))
 });
-var StrategySelectionSchema = Schema7.Struct({
-  selectedStrategy: Schema7.String,
-  reasoning: Schema7.String,
-  confidence: Schema7.Number,
-  alternativeStrategies: Schema7.Array(
-    Schema7.Struct({
-      strategy: Schema7.String,
-      whyNot: Schema7.String
+var StrategySelectionSchema = Schema8.Struct({
+  selectedStrategy: Schema8.String,
+  reasoning: Schema8.String,
+  confidence: Schema8.Number,
+  alternativeStrategies: Schema8.Array(
+    Schema8.Struct({
+      strategy: Schema8.String,
+      whyNot: Schema8.String
     })
   )
 });
-var ThoughtEvaluationSchema = Schema7.Struct({
-  score: Schema7.Number,
-  reasoning: Schema7.String,
-  strengths: Schema7.Array(Schema7.String),
-  weaknesses: Schema7.Array(Schema7.String),
-  shouldExpand: Schema7.Boolean
+var ThoughtEvaluationSchema = Schema8.Struct({
+  score: Schema8.Number,
+  reasoning: Schema8.String,
+  strengths: Schema8.Array(Schema8.String),
+  weaknesses: Schema8.Array(Schema8.String),
+  shouldExpand: Schema8.Boolean
 });
-var ComplexityAnalysisSchema = Schema7.Struct({
-  score: Schema7.Number,
-  factors: Schema7.Array(
-    Schema7.Struct({
-      factor: Schema7.String,
-      weight: Schema7.Number,
-      reasoning: Schema7.String
+var ComplexityAnalysisSchema = Schema8.Struct({
+  score: Schema8.Number,
+  factors: Schema8.Array(
+    Schema8.Struct({
+      factor: Schema8.String,
+      weight: Schema8.Number,
+      reasoning: Schema8.String
     })
   ),
-  recommendedStrategy: Schema7.String,
-  recommendedModel: Schema7.String
+  recommendedStrategy: Schema8.String,
+  recommendedModel: Schema8.String
 });
 
 // src/runtime.ts
-import { Layer as Layer8 } from "effect";
+import { Layer as Layer9 } from "effect";
 var createLLMProviderLayer = (provider = "anthropic", testResponses, model) => {
   if (provider === "test") {
-    return Layer8.mergeAll(
+    return Layer9.mergeAll(
       TestLLMServiceLayer(testResponses ?? {}),
       PromptManagerLive
     );
   }
-  const configLayer = model ? Layer8.succeed(LLMConfig, LLMConfig.of({ ...llmConfigFromEnv, defaultModel: model })) : LLMConfigFromEnv;
-  const providerLayer = provider === "anthropic" ? AnthropicProviderLive : provider === "openai" ? OpenAIProviderLive : provider === "gemini" ? GeminiProviderLive : LocalProviderLive;
-  return Layer8.mergeAll(
-    providerLayer.pipe(Layer8.provide(configLayer)),
+  const configLayer = model ? Layer9.succeed(LLMConfig, LLMConfig.of({ ...llmConfigFromEnv, defaultModel: model })) : LLMConfigFromEnv;
+  const providerLayer = provider === "anthropic" ? AnthropicProviderLive : provider === "openai" ? OpenAIProviderLive : provider === "gemini" ? GeminiProviderLive : provider === "litellm" ? LiteLLMProviderLive : LocalProviderLive;
+  return Layer9.mergeAll(
+    providerLayer.pipe(Layer9.provide(configLayer)),
     PromptManagerLive
   );
 };
 var createLLMProviderLayerWithConfig = (config, provider = "anthropic") => {
-  const configLayer = Layer8.succeed(LLMConfig, config);
-  const providerLayer = provider === "anthropic" ? AnthropicProviderLive : provider === "openai" ? OpenAIProviderLive : provider === "gemini" ? GeminiProviderLive : LocalProviderLive;
-  return Layer8.mergeAll(
-    providerLayer.pipe(Layer8.provide(configLayer)),
+  const configLayer = Layer9.succeed(LLMConfig, config);
+  const providerLayer = provider === "anthropic" ? AnthropicProviderLive : provider === "openai" ? OpenAIProviderLive : provider === "gemini" ? GeminiProviderLive : provider === "litellm" ? LiteLLMProviderLive : LocalProviderLive;
+  return Layer9.mergeAll(
+    providerLayer.pipe(Layer9.provide(configLayer)),
     PromptManagerLive
   );
 };
@@ -2847,6 +3304,7 @@ export {
   LLMRateLimitError,
   LLMService,
   LLMTimeoutError,
+  LiteLLMProviderLive,
   LocalProviderLive,
   ModelConfigSchema,
   ModelPresets,