@reactive-agents/llm-provider 0.1.0

package/dist/index.js

@@ -0,0 +1,1683 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/types.ts
+import { Schema } from "effect";
+var LLMProviderType = Schema.Literal(
+  "anthropic",
+  "openai",
+  "ollama",
+  "gemini",
+  "custom"
+);
+var EmbeddingConfigSchema = Schema.Struct({
+  model: Schema.String,
+  dimensions: Schema.Number,
+  provider: Schema.Literal("openai", "ollama"),
+  batchSize: Schema.optional(Schema.Number)
+});
+var DefaultEmbeddingConfig = {
+  model: "text-embedding-3-small",
+  dimensions: 1536,
+  provider: "openai",
+  batchSize: 100
+};
+var ModelConfigSchema = Schema.Struct({
+  provider: LLMProviderType,
+  model: Schema.String,
+  maxTokens: Schema.optional(Schema.Number),
+  temperature: Schema.optional(Schema.Number),
+  topP: Schema.optional(Schema.Number),
+  stopSequences: Schema.optional(Schema.Array(Schema.String))
+});
+var ModelPresets = {
+  "claude-haiku": {
+    provider: "anthropic",
+    model: "claude-3-5-haiku-20241022",
+    costPer1MInput: 1,
+    costPer1MOutput: 5,
+    maxContext: 2e5,
+    quality: 0.6
+  },
+  "claude-sonnet": {
+    provider: "anthropic",
+    model: "claude-sonnet-4-20250514",
+    costPer1MInput: 3,
+    costPer1MOutput: 15,
+    maxContext: 2e5,
+    quality: 0.85
+  },
+  "claude-sonnet-4-5": {
+    provider: "anthropic",
+    model: "claude-sonnet-4-5-20250929",
+    costPer1MInput: 3,
+    costPer1MOutput: 15,
+    maxContext: 2e5,
+    quality: 0.9
+  },
+  "claude-opus": {
+    provider: "anthropic",
+    model: "claude-opus-4-20250514",
+    costPer1MInput: 15,
+    costPer1MOutput: 75,
+    maxContext: 1e6,
+    quality: 1
+  },
+  "gpt-4o-mini": {
+    provider: "openai",
+    model: "gpt-4o-mini",
+    costPer1MInput: 0.15,
+    costPer1MOutput: 0.6,
+    maxContext: 128e3,
+    quality: 0.55
+  },
+  "gpt-4o": {
+    provider: "openai",
+    model: "gpt-4o",
+    costPer1MInput: 2.5,
+    costPer1MOutput: 10,
+    maxContext: 128e3,
+    quality: 0.8
+  },
+  "gemini-2.0-flash": {
+    provider: "gemini",
+    model: "gemini-2.0-flash",
+    costPer1MInput: 0.1,
+    costPer1MOutput: 0.4,
+    maxContext: 1e6,
+    quality: 0.75
+  },
+  "gemini-2.5-pro": {
+    provider: "gemini",
+    model: "gemini-2.5-pro-preview-03-25",
+    costPer1MInput: 1.25,
+    costPer1MOutput: 10,
+    maxContext: 1e6,
+    quality: 0.95
+  }
+};
+var CacheControlSchema = Schema.Struct({
+  type: Schema.Literal("ephemeral")
+});
+var ImageSourceSchema = Schema.Struct({
+  type: Schema.Literal("base64", "url"),
+  media_type: Schema.Literal(
+    "image/png",
+    "image/jpeg",
+    "image/gif",
+    "image/webp"
+  ),
+  data: Schema.String
+});
+var TextContentBlockSchema = Schema.Struct({
+  type: Schema.Literal("text"),
+  text: Schema.String,
+  cache_control: Schema.optional(CacheControlSchema)
+});
+var ImageContentBlockSchema = Schema.Struct({
+  type: Schema.Literal("image"),
+  source: ImageSourceSchema
+});
+var ToolUseContentBlockSchema = Schema.Struct({
+  type: Schema.Literal("tool_use"),
+  id: Schema.String,
+  name: Schema.String,
+  input: Schema.Unknown
+});
+var ToolResultContentBlockSchema = Schema.Struct({
+  type: Schema.Literal("tool_result"),
+  tool_use_id: Schema.String,
+  content: Schema.String
+});
+var makeCacheable = (text) => ({
+  type: "text",
+  text,
+  cache_control: { type: "ephemeral" }
+});
+var TokenUsageSchema = Schema.Struct({
+  inputTokens: Schema.Number,
+  outputTokens: Schema.Number,
+  totalTokens: Schema.Number,
+  estimatedCost: Schema.Number
+});
+var StopReasonSchema = Schema.Literal(
+  "end_turn",
+  "max_tokens",
+  "stop_sequence",
+  "tool_use"
+);
+var ToolDefinitionSchema = Schema.Struct({
+  name: Schema.String,
+  description: Schema.String,
+  inputSchema: Schema.Record({ key: Schema.String, value: Schema.Unknown })
+});
+var ToolCallSchema = Schema.Struct({
+  id: Schema.String,
+  name: Schema.String,
+  input: Schema.Unknown
+});
+var CompletionResponseSchema = Schema.Struct({
+  content: Schema.String,
+  stopReason: StopReasonSchema,
+  usage: TokenUsageSchema,
+  model: Schema.String,
+  toolCalls: Schema.optional(Schema.Array(ToolCallSchema))
+});
+
+// src/errors.ts
+import { Data } from "effect";
+var LLMError = class extends Data.TaggedError("LLMError") {
+};
+var LLMRateLimitError = class extends Data.TaggedError("LLMRateLimitError") {
+};
+var LLMTimeoutError = class extends Data.TaggedError("LLMTimeoutError") {
+};
+var LLMParseError = class extends Data.TaggedError("LLMParseError") {
+};
+var LLMContextOverflowError = class extends Data.TaggedError(
+  "LLMContextOverflowError"
+) {
+};
+
+// src/llm-service.ts
+import { Context } from "effect";
+var LLMService = class extends Context.Tag("LLMService")() {
+};
+
+// src/llm-config.ts
+import { Context as Context2, Layer } from "effect";
+var LLMConfig = class extends Context2.Tag("LLMConfig")() {
+};
+var LLMConfigFromEnv = Layer.succeed(
+  LLMConfig,
+  LLMConfig.of({
+    defaultProvider: "anthropic",
+    defaultModel: process.env.LLM_DEFAULT_MODEL ?? "claude-sonnet-4-20250514",
+    anthropicApiKey: process.env.ANTHROPIC_API_KEY,
+    openaiApiKey: process.env.OPENAI_API_KEY,
+    googleApiKey: process.env.GOOGLE_API_KEY,
+    ollamaEndpoint: process.env.OLLAMA_ENDPOINT ?? "http://localhost:11434",
+    embeddingConfig: {
+      model: process.env.EMBEDDING_MODEL ?? "text-embedding-3-small",
+      dimensions: Number(process.env.EMBEDDING_DIMENSIONS ?? 1536),
+      provider: process.env.EMBEDDING_PROVIDER ?? "openai",
+      batchSize: 100
+    },
+    supportsPromptCaching: (process.env.LLM_DEFAULT_MODEL ?? "claude-sonnet-4-20250514").startsWith("claude"),
+    maxRetries: Number(process.env.LLM_MAX_RETRIES ?? 3),
+    timeoutMs: Number(process.env.LLM_TIMEOUT_MS ?? 3e4),
+    defaultMaxTokens: 4096,
+    defaultTemperature: Number(process.env.LLM_DEFAULT_TEMPERATURE ?? 0.7)
+  })
+);
+
+// src/prompt-manager.ts
+import { Effect as Effect3, Context as Context3, Layer as Layer2 } from "effect";
+
+// src/token-counter.ts
+import { Effect as Effect2 } from "effect";
+var estimateTokenCount = (messages) => Effect2.sync(() => {
+  let totalChars = 0;
+  for (const msg of messages) {
+    if (typeof msg.content === "string") {
+      totalChars += msg.content.length;
+    } else {
+      for (const block of msg.content) {
+        if (block.type === "text") {
+          totalChars += block.text.length;
+        } else if (block.type === "tool_result") {
+          totalChars += block.content.length;
+        } else if (block.type === "tool_use") {
+          totalChars += JSON.stringify(block.input).length;
+        }
+      }
+    }
+    totalChars += 16;
+  }
+  return Math.ceil(totalChars / 4);
+});
+var calculateCost = (inputTokens, outputTokens, model) => {
+  const costMap = {
+    "claude-3-5-haiku-20241022": { input: 1, output: 5 },
+    "claude-sonnet-4-20250514": { input: 3, output: 15 },
+    "claude-sonnet-4-5-20250929": { input: 3, output: 15 },
+    "claude-opus-4-20250514": { input: 15, output: 75 },
+    "gpt-4o-mini": { input: 0.15, output: 0.6 },
+    "gpt-4o": { input: 2.5, output: 10 },
+    "gemini-2.0-flash": { input: 0.1, output: 0.4 },
+    "gemini-2.5-pro-preview-03-25": { input: 1.25, output: 10 },
+    "gemini-embedding-001": { input: 0, output: 0 }
+  };
+  const costs = costMap[model] ?? { input: 3, output: 15 };
+  return inputTokens / 1e6 * costs.input + outputTokens / 1e6 * costs.output;
+};
+
+// src/prompt-manager.ts
+var PromptManager = class extends Context3.Tag("PromptManager")() {
+};
+var PromptManagerLive = Layer2.succeed(
+  PromptManager,
+  PromptManager.of({
+    buildPrompt: (options) => Effect3.gen(function* () {
+      const {
+        systemPrompt,
+        messages,
+        reserveOutputTokens,
+        maxContextTokens,
+        truncationStrategy
+      } = options;
+      const budget = maxContextTokens - reserveOutputTokens;
+      const systemMessage = {
+        role: "system",
+        content: systemPrompt
+      };
+      const systemTokens = yield* estimateTokenCount([systemMessage]);
+      if (systemTokens >= budget) {
+        return [systemMessage];
+      }
+      const remainingBudget = budget - systemTokens;
+      const truncated = yield* applyTruncation(
+        messages,
+        remainingBudget,
+        truncationStrategy
+      );
+      return [systemMessage, ...truncated];
+    }),
+    fitsInContext: (messages, maxTokens) => Effect3.gen(function* () {
+      const count = yield* estimateTokenCount(messages);
+      return count <= maxTokens;
+    })
+  })
+);
+var applyTruncation = (messages, budget, strategy) => Effect3.gen(function* () {
+  const totalTokens = yield* estimateTokenCount(messages);
+  if (totalTokens <= budget) {
+    return messages;
+  }
+  switch (strategy) {
+    case "drop-oldest": {
+      const result = [];
+      let usedTokens = 0;
+      for (let i = messages.length - 1; i >= 0; i--) {
+        const msgTokens = yield* estimateTokenCount([messages[i]]);
+        if (usedTokens + msgTokens <= budget) {
+          result.unshift(messages[i]);
+          usedTokens += msgTokens;
+        } else {
+          break;
+        }
+      }
+      return result;
+    }
+    case "sliding-window": {
+      const result = [];
+      let usedTokens = 0;
+      for (let i = messages.length - 1; i >= 0; i--) {
+        const msgTokens = yield* estimateTokenCount([messages[i]]);
+        if (usedTokens + msgTokens <= budget) {
+          result.unshift(messages[i]);
+          usedTokens += msgTokens;
+        } else {
+          break;
+        }
+      }
+      return result;
+    }
+    case "summarize-middle":
+    case "importance-based": {
+      const result = [];
+      let usedTokens = 0;
+      if (messages.length > 0) {
+        const firstTokens = yield* estimateTokenCount([messages[0]]);
+        if (firstTokens <= budget) {
+          result.push(messages[0]);
+          usedTokens += firstTokens;
+        }
+      }
+      const tail = [];
+      for (let i = messages.length - 1; i >= 1; i--) {
+        const msgTokens = yield* estimateTokenCount([messages[i]]);
+        if (usedTokens + msgTokens <= budget) {
+          tail.unshift(messages[i]);
+          usedTokens += msgTokens;
+        } else {
+          break;
+        }
+      }
+      return [...result, ...tail];
+    }
+  }
+});
+
+// src/providers/anthropic.ts
+import { Effect as Effect4, Layer as Layer3, Stream, Schema as Schema2 } from "effect";
+
+// src/retry.ts
+import { Schedule } from "effect";
+var retryPolicy = Schedule.intersect(
+  Schedule.recurs(3),
+  Schedule.exponential("1 second", 2)
+).pipe(
+  Schedule.whileInput(
+    (error) => error._tag === "LLMRateLimitError" || error._tag === "LLMTimeoutError"
+  )
+);
+
+// src/providers/anthropic.ts
+var toAnthropicMessages = (messages) => messages.filter((m) => m.role !== "system").map((m) => ({
+  role: m.role,
+  content: typeof m.content === "string" ? m.content : m.content.map(
+    (b) => b
+  )
+}));
+var toAnthropicTool = (tool) => ({
+  name: tool.name,
+  description: tool.description,
+  input_schema: {
+    type: "object",
+    ...tool.inputSchema
+  }
+});
+var toEffectError = (error, provider) => {
+  const err = error;
+  if (err.status === 429) {
+    const retryAfter = err.headers?.["retry-after"];
+    return new LLMRateLimitError({
+      message: err.message ?? "Rate limit exceeded",
+      provider,
+      retryAfterMs: retryAfter ? Number(retryAfter) * 1e3 : 6e4
+    });
+  }
+  return new LLMError({
+    message: err.message ?? String(error),
+    provider,
+    cause: error
+  });
+};
+var AnthropicProviderLive = Layer3.effect(
+  LLMService,
+  Effect4.gen(function* () {
+    const config = yield* LLMConfig;
+    const createClient = () => {
+      const Anthropic = __require("@anthropic-ai/sdk").default;
+      return new Anthropic({ apiKey: config.anthropicApiKey });
+    };
+    let _client = null;
+    const getClient = () => {
+      if (!_client) _client = createClient();
+      return _client;
+    };
+    return LLMService.of({
+      complete: (request) => Effect4.gen(function* () {
+        const client = getClient();
+        const model = request.model?.model ?? config.defaultModel;
+        const response = yield* Effect4.tryPromise({
+          try: () => client.messages.create({
+            model,
+            max_tokens: request.maxTokens ?? config.defaultMaxTokens,
+            temperature: request.temperature ?? config.defaultTemperature,
+            system: request.systemPrompt,
+            messages: toAnthropicMessages(request.messages),
+            stop_sequences: request.stopSequences ? [...request.stopSequences] : void 0,
+            tools: request.tools?.map(toAnthropicTool)
+          }),
+          catch: (error) => toEffectError(error, "anthropic")
+        });
+        return mapAnthropicResponse(response, model);
+      }).pipe(
+        Effect4.retry(retryPolicy),
+        Effect4.timeout("30 seconds"),
+        Effect4.catchTag(
+          "TimeoutException",
+          () => Effect4.fail(
+            new LLMTimeoutError({
+              message: "LLM request timed out",
+              provider: "anthropic",
+              timeoutMs: 3e4
+            })
+          )
+        )
+      ),
+      stream: (request) => Effect4.gen(function* () {
+        const client = getClient();
+        const model = request.model?.model ?? config.defaultModel;
+        return Stream.async((emit) => {
+          const stream = client.messages.stream({
+            model,
+            max_tokens: request.maxTokens ?? config.defaultMaxTokens,
+            temperature: request.temperature ?? config.defaultTemperature,
+            system: request.systemPrompt,
+            messages: toAnthropicMessages(request.messages)
+          });
+          stream.on("text", (text) => {
+            emit.single({ type: "text_delta", text });
+          });
+          stream.on("finalMessage", (message) => {
+            const msg = message;
+            const content = msg.content.filter(
+              (b) => b.type === "text"
+            ).map((b) => b.text).join("");
+            emit.single({ type: "content_complete", content });
+            emit.single({
+              type: "usage",
+              usage: {
+                inputTokens: msg.usage.input_tokens,
+                outputTokens: msg.usage.output_tokens,
+                totalTokens: msg.usage.input_tokens + msg.usage.output_tokens,
+                estimatedCost: calculateCost(
+                  msg.usage.input_tokens,
+                  msg.usage.output_tokens,
+                  model
+                )
+              }
+            });
+            emit.end();
+          });
+          stream.on("error", (error) => {
+            const err = error;
+            emit.fail(
+              new LLMError({
+                message: err.message ?? String(error),
+                provider: "anthropic",
+                cause: error
+              })
+            );
+          });
+        });
+      }),
+      completeStructured: (request) => Effect4.gen(function* () {
+        const schemaStr = JSON.stringify(
+          Schema2.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 completeResult = yield* Effect4.tryPromise({
+            try: () => {
+              const client = getClient();
+              return client.messages.create({
+                model: request.model?.model ?? config.defaultModel,
+                max_tokens: request.maxTokens ?? config.defaultMaxTokens,
+                temperature: request.temperature ?? config.defaultTemperature,
+                system: request.systemPrompt,
+                messages: toAnthropicMessages(msgs)
+              });
+            },
+            catch: (error) => toEffectError(error, "anthropic")
+          });
+          const response = mapAnthropicResponse(
+            completeResult,
+            request.model?.model ?? config.defaultModel
+          );
+          try {
+            const parsed = JSON.parse(response.content);
+            const decoded = Schema2.decodeUnknownEither(
+              request.outputSchema
+            )(parsed);
+            if (decoded._tag === "Right") {
+              return decoded.right;
+            }
+            lastError = decoded.left;
+          } catch (e) {
+            lastError = e;
+          }
+        }
+        return yield* Effect4.fail(
+          new LLMParseError({
+            message: `Failed to parse structured output after ${maxRetries + 1} attempts`,
+            rawOutput: String(lastError),
+            expectedSchema: schemaStr
+          })
+        );
+      }),
+      embed: (texts, model) => Effect4.tryPromise({
+        try: async () => {
+          const embeddingModel = model ?? config.embeddingConfig.model;
+          const embProvider = config.embeddingConfig.provider;
+          if (embProvider === "openai") {
+            const { default: OpenAI } = await import("openai");
+            const openaiClient = new OpenAI({
+              apiKey: config.openaiApiKey
+            });
+            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 openaiClient.embeddings.create({
+                model: embeddingModel,
+                input: [...batch],
+                dimensions: config.embeddingConfig.dimensions
+              });
+              results.push(
+                ...response.data.map(
+                  (d) => d.embedding
+                )
+              );
+            }
+            return results;
+          }
+          const endpoint = config.ollamaEndpoint ?? "http://localhost:11434";
+          return Promise.all(
+            [...texts].map(async (text) => {
+              const res = await fetch(`${endpoint}/api/embed`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                  model: embeddingModel,
+                  input: text
+                })
+              });
+              const data = await res.json();
+              return data.embeddings[0];
+            })
+          );
+        },
+        catch: (error) => new LLMError({
+          message: `Embedding failed: ${error}`,
+          provider: "anthropic",
+          cause: error
+        })
+      }),
+      countTokens: (messages) => Effect4.gen(function* () {
+        return yield* estimateTokenCount(messages);
+      }),
+      getModelConfig: () => Effect4.succeed({
+        provider: "anthropic",
+        model: config.defaultModel
+      })
+    });
+  })
+);
+var mapAnthropicResponse = (response, model) => {
+  const textContent = response.content.filter(
+    (b) => b.type === "text"
+  ).map((b) => b.text).join("");
+  const toolCalls = response.content.filter(
+    (b) => b.type === "tool_use"
+  ).map((b) => ({
+    id: b.id,
+    name: b.name,
+    input: b.input
+  }));
+  const stopReason = response.stop_reason === "end_turn" ? "end_turn" : response.stop_reason === "max_tokens" ? "max_tokens" : response.stop_reason === "stop_sequence" ? "stop_sequence" : response.stop_reason === "tool_use" ? "tool_use" : "end_turn";
+  return {
+    content: textContent,
+    stopReason,
+    usage: {
+      inputTokens: response.usage.input_tokens,
+      outputTokens: response.usage.output_tokens,
+      totalTokens: response.usage.input_tokens + response.usage.output_tokens,
+      estimatedCost: calculateCost(
+        response.usage.input_tokens,
+        response.usage.output_tokens,
+        model
+      )
+    },
+    model: response.model ?? model,
+    toolCalls: toolCalls.length > 0 ? toolCalls : void 0
+  };
+};
+
+// src/providers/openai.ts
+import { Effect as Effect5, Layer as Layer4, Stream as Stream2, Schema as Schema3 } from "effect";
+var toOpenAIMessages = (messages) => messages.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 toEffectError2 = (error, provider) => {
+  const err = error;
+  if (err.status === 429) {
+    return new LLMRateLimitError({
+      message: err.message ?? "Rate limit exceeded",
+      provider,
+      retryAfterMs: 6e4
+    });
+  }
+  return new LLMError({
+    message: err.message ?? String(error),
+    provider,
+    cause: error
+  });
+};
+var OpenAIProviderLive = Layer4.effect(
+  LLMService,
+  Effect5.gen(function* () {
+    const config = yield* LLMConfig;
+    const createClient = () => {
+      const OpenAI = __require("openai").default;
+      return new OpenAI({ apiKey: config.openaiApiKey });
+    };
+    let _client = null;
+    const getClient = () => {
+      if (!_client) _client = createClient();
+      return _client;
+    };
+    const defaultModel = config.defaultModel.startsWith("claude") ? "gpt-4o" : config.defaultModel;
+    return LLMService.of({
+      complete: (request) => Effect5.gen(function* () {
+        const client = getClient();
+        const model = request.model?.model ?? defaultModel;
+        const response = yield* Effect5.tryPromise({
+          try: () => client.chat.completions.create({
+            model,
+            max_tokens: request.maxTokens ?? config.defaultMaxTokens,
+            temperature: request.temperature ?? config.defaultTemperature,
+            messages: toOpenAIMessages(request.messages),
+            stop: request.stopSequences ? [...request.stopSequences] : void 0
+          }),
+          catch: (error) => toEffectError2(error, "openai")
+        });
+        return mapOpenAIResponse(response, model);
+      }).pipe(
+        Effect5.retry(retryPolicy),
+        Effect5.timeout("30 seconds"),
+        Effect5.catchTag(
+          "TimeoutException",
+          () => Effect5.fail(
+            new LLMTimeoutError({
+              message: "LLM request timed out",
+              provider: "openai",
+              timeoutMs: 3e4
+            })
+          )
+        )
+      ),
+      stream: (request) => Effect5.gen(function* () {
+        const client = getClient();
+        const model = request.model?.model ?? defaultModel;
+        return Stream2.async((emit) => {
+          const doStream = async () => {
+            try {
+              const stream = await client.chat.completions.create({
+                model,
+                max_tokens: request.maxTokens ?? config.defaultMaxTokens,
+                temperature: request.temperature ?? config.defaultTemperature,
+                messages: toOpenAIMessages(request.messages),
+                stream: true
+              });
+              let fullContent = "";
+              for await (const chunk of stream) {
+                const delta = chunk.choices[0]?.delta?.content;
+                if (delta) {
+                  fullContent += delta;
+                  emit.single({ type: "text_delta", text: delta });
+                }
+                if (chunk.choices[0]?.finish_reason) {
+                  emit.single({
+                    type: "content_complete",
+                    content: fullContent
+                  });
+                  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
+                      )
+                    }
+                  });
+                  emit.end();
+                }
+              }
+            } catch (error) {
+              const err = error;
+              emit.fail(
+                new LLMError({
+                  message: err.message ?? String(error),
+                  provider: "openai",
+                  cause: error
+                })
+              );
+            }
+          };
+          void doStream();
+        });
+      }),
+      completeStructured: (request) => Effect5.gen(function* () {
+        const schemaStr = JSON.stringify(
+          Schema3.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 client = getClient();
+          const completeResult = yield* Effect5.tryPromise({
+            try: () => client.chat.completions.create({
+              model: request.model?.model ?? defaultModel,
+              max_tokens: request.maxTokens ?? config.defaultMaxTokens,
+              temperature: request.temperature ?? config.defaultTemperature,
+              messages: toOpenAIMessages(msgs)
+            }),
+            catch: (error) => toEffectError2(error, "openai")
+          });
+          const response = mapOpenAIResponse(
+            completeResult,
+            request.model?.model ?? defaultModel
+          );
+          try {
+            const parsed = JSON.parse(response.content);
+            const decoded = Schema3.decodeUnknownEither(
+              request.outputSchema
+            )(parsed);
+            if (decoded._tag === "Right") {
+              return decoded.right;
+            }
+            lastError = decoded.left;
+          } catch (e) {
+            lastError = e;
+          }
+        }
+        return yield* Effect5.fail(
+          new LLMParseError({
+            message: `Failed to parse structured output after ${maxRetries + 1} attempts`,
+            rawOutput: String(lastError),
+            expectedSchema: schemaStr
+          })
+        );
+      }),
+      embed: (texts, model) => Effect5.tryPromise({
+        try: async () => {
+          const client = getClient();
+          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 client.embeddings.create({
+              model: embeddingModel,
+              input: [...batch],
+              dimensions: config.embeddingConfig.dimensions
+            });
+            results.push(
+              ...response.data.map(
+                (d) => d.embedding
+              )
+            );
+          }
+          return results;
+        },
+        catch: (error) => new LLMError({
+          message: `Embedding failed: ${error}`,
+          provider: "openai",
+          cause: error
+        })
+      }),
+      countTokens: (messages) => Effect5.gen(function* () {
+        return yield* estimateTokenCount(messages);
+      }),
+      getModelConfig: () => Effect5.succeed({
+        provider: "openai",
+        model: defaultModel
+      })
+    });
+  })
+);
+var mapOpenAIResponse = (response, model) => {
+  const content = response.choices[0]?.message?.content ?? "";
+  const stopReason = response.choices[0]?.finish_reason === "stop" ? "end_turn" : response.choices[0]?.finish_reason === "length" ? "max_tokens" : "end_turn";
+  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
+  };
+};
+
+// src/providers/local.ts
+import { Effect as Effect6, Layer as Layer5, Stream as Stream3, Schema as Schema4 } from "effect";
+var toOllamaMessages = (messages) => messages.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 LocalProviderLive = Layer5.effect(
+  LLMService,
+  Effect6.gen(function* () {
+    const config = yield* LLMConfig;
+    const endpoint = config.ollamaEndpoint ?? "http://localhost:11434";
+    const defaultModel = config.defaultModel.startsWith("claude") || config.defaultModel.startsWith("gpt") ? "llama3" : config.defaultModel;
+    return LLMService.of({
+      complete: (request) => Effect6.gen(function* () {
+        const model = request.model?.model ?? defaultModel;
+        const response = yield* Effect6.tryPromise({
+          try: async () => {
+            const res = await fetch(`${endpoint}/api/chat`, {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({
+                model,
+                messages: toOllamaMessages(request.messages),
+                stream: false,
+                options: {
+                  temperature: request.temperature ?? config.defaultTemperature,
+                  num_predict: request.maxTokens ?? config.defaultMaxTokens,
+                  stop: request.stopSequences ? [...request.stopSequences] : void 0
+                }
+              })
+            });
+            if (!res.ok) {
+              throw new Error(
+                `Ollama request failed: ${res.status} ${res.statusText}`
+              );
+            }
+            return await res.json();
+          },
+          catch: (error) => new LLMError({
+            message: `Ollama request failed: ${error}`,
+            provider: "ollama",
+            cause: error
+          })
+        });
+        const content = response.message?.content ?? "";
+        const inputTokens = response.prompt_eval_count ?? 0;
+        const outputTokens = response.eval_count ?? 0;
+        return {
+          content,
+          stopReason: response.done_reason === "stop" ? "end_turn" : response.done_reason === "length" ? "max_tokens" : "end_turn",
+          usage: {
+            inputTokens,
+            outputTokens,
+            totalTokens: inputTokens + outputTokens,
+            estimatedCost: 0
+            // Local models are free
+          },
+          model: response.model ?? model
+        };
+      }).pipe(
+        Effect6.retry(retryPolicy),
+        Effect6.timeout("60 seconds"),
+        Effect6.catchTag(
+          "TimeoutException",
+          () => Effect6.fail(
+            new LLMTimeoutError({
+              message: "Local LLM request timed out",
+              provider: "ollama",
+              timeoutMs: 6e4
+            })
+          )
+        )
+      ),
+      stream: (request) => Effect6.gen(function* () {
+        const model = request.model?.model ?? defaultModel;
+        return Stream3.async((emit) => {
+          const doStream = async () => {
+            try {
+              const res = await fetch(`${endpoint}/api/chat`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                  model,
+                  messages: toOllamaMessages(request.messages),
+                  stream: true,
+                  options: {
+                    temperature: request.temperature ?? config.defaultTemperature,
+                    num_predict: request.maxTokens ?? config.defaultMaxTokens
+                  }
+                })
+              });
+              if (!res.ok || !res.body) {
+                throw new Error(`Ollama stream failed: ${res.status}`);
+              }
+              const reader = res.body.getReader();
+              const decoder = new TextDecoder();
+              let fullContent = "";
+              while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+                const lines = decoder.decode(value, { stream: true }).split("\n").filter(Boolean);
+                for (const line of lines) {
+                  const parsed = JSON.parse(line);
+                  if (parsed.message?.content) {
+                    fullContent += parsed.message.content;
+                    emit.single({
+                      type: "text_delta",
+                      text: parsed.message.content
+                    });
+                  }
+                  if (parsed.done) {
+                    emit.single({
+                      type: "content_complete",
+                      content: fullContent
+                    });
+                    emit.single({
+                      type: "usage",
+                      usage: {
+                        inputTokens: parsed.prompt_eval_count ?? 0,
+                        outputTokens: parsed.eval_count ?? 0,
+                        totalTokens: (parsed.prompt_eval_count ?? 0) + (parsed.eval_count ?? 0),
+                        estimatedCost: 0
+                      }
+                    });
+                    emit.end();
+                  }
+                }
+              }
+            } catch (error) {
+              const err = error;
+              emit.fail(
+                new LLMError({
+                  message: err.message ?? String(error),
+                  provider: "ollama",
+                  cause: error
+                })
+              );
+            }
+          };
+          void doStream();
+        });
+      }),
+      completeStructured: (request) => Effect6.gen(function* () {
+        const schemaStr = JSON.stringify(
+          Schema4.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;
+        const llm = {
+          complete: (req) => Effect6.gen(function* () {
+            const model = req.model?.model ?? defaultModel;
+            const res = yield* Effect6.tryPromise({
+              try: async () => {
+                const resp = await fetch(`${endpoint}/api/chat`, {
+                  method: "POST",
+                  headers: { "Content-Type": "application/json" },
+                  body: JSON.stringify({
+                    model,
+                    messages: toOllamaMessages(req.messages),
+                    stream: false,
+                    options: {
+                      temperature: req.temperature ?? config.defaultTemperature,
+                      num_predict: req.maxTokens ?? config.defaultMaxTokens
+                    }
+                  })
+                });
+                return await resp.json();
+              },
+              catch: (error) => new LLMError({
+                message: `Ollama request failed: ${error}`,
+                provider: "ollama",
+                cause: error
+              })
+            });
+            const content = res.message?.content ?? "";
+            const inputTokens = res.prompt_eval_count ?? 0;
+            const outputTokens = res.eval_count ?? 0;
+            return {
+              content,
+              stopReason: "end_turn",
+              usage: {
+                inputTokens,
+                outputTokens,
+                totalTokens: inputTokens + outputTokens,
+                estimatedCost: 0
+              },
+              model: res.model ?? model
+            };
+          })
+        };
+        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 response = yield* llm.complete({
+            ...request,
+            messages: msgs
+          });
+          try {
+            const parsed = JSON.parse(response.content);
+            const decoded = Schema4.decodeUnknownEither(
+              request.outputSchema
+            )(parsed);
+            if (decoded._tag === "Right") {
+              return decoded.right;
+            }
+            lastError = decoded.left;
+          } catch (e) {
+            lastError = e;
+          }
+        }
+        return yield* Effect6.fail(
+          new LLMParseError({
+            message: `Failed to parse structured output after ${maxRetries + 1} attempts`,
+            rawOutput: String(lastError),
+            expectedSchema: schemaStr
+          })
+        );
+      }),
+      embed: (texts, model) => Effect6.tryPromise({
+        try: async () => {
+          const embeddingModel = model ?? config.embeddingConfig.model ?? "nomic-embed-text";
+          return Promise.all(
+            [...texts].map(async (text) => {
+              const res = await fetch(`${endpoint}/api/embed`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                  model: embeddingModel,
+                  input: text
+                })
+              });
+              const data = await res.json();
+              return data.embeddings[0];
+            })
+          );
+        },
+        catch: (error) => new LLMError({
+          message: `Embedding failed: ${error}`,
+          provider: "ollama",
+          cause: error
+        })
+      }),
+      countTokens: (messages) => Effect6.gen(function* () {
+        return yield* estimateTokenCount(messages);
+      }),
+      getModelConfig: () => Effect6.succeed({
+        provider: "ollama",
+        model: defaultModel
+      })
+    });
+  })
+);
+
+// src/providers/gemini.ts
+import { Effect as Effect7, Layer as Layer6, Stream as Stream4, Schema as Schema5 } from "effect";
+var toGeminiContents = (messages) => {
+  const result = [];
+  for (const msg of messages) {
+    if (msg.role === "system") continue;
+    const role = msg.role === "assistant" ? "model" : "user";
+    if (typeof msg.content === "string") {
+      result.push({ role, parts: [{ text: msg.content }] });
+    } else {
+      const parts = [];
+      for (const block of msg.content) {
+        if (block.type === "text") {
+          parts.push({ text: block.text });
+        } else if (block.type === "tool_use") {
+          parts.push({
+            functionCall: { name: block.name, args: block.input }
+          });
+        } else if (block.type === "tool_result") {
+          parts.push({
+            functionResponse: {
+              name: "tool",
+              response: { content: block.content }
+            }
+          });
+        }
+      }
+      if (parts.length > 0) {
+        result.push({ role, parts });
+      }
+    }
+  }
+  return result;
+};
+var extractSystemPrompt = (messages) => {
+  const sys = messages.find((m) => m.role === "system");
+  if (!sys) return void 0;
+  return typeof sys.content === "string" ? sys.content : void 0;
+};
+var toGeminiTools = (tools) => tools.length === 0 ? void 0 : [
+  {
+    functionDeclarations: tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      parameters: { type: "object", ...t.inputSchema }
+    }))
+  }
+];
+var toEffectError3 = (error) => {
+  const err = error;
+  if (err.status === 429 || err.code === 429) {
+    return new LLMRateLimitError({
+      message: err.message ?? "Rate limit exceeded",
+      provider: "gemini",
+      retryAfterMs: 6e4
+    });
+  }
+  return new LLMError({
+    message: err.message ?? String(error),
+    provider: "gemini",
+    cause: error
+  });
+};
+var mapGeminiResponse = (response, model) => {
+  const toolCalls = response.functionCalls?.map((fc, i) => ({
+    id: `call_${i}`,
+    name: fc.name,
+    input: fc.args
+  }));
+  const inputTokens = response.usageMetadata?.promptTokenCount ?? 0;
+  const outputTokens = response.usageMetadata?.candidatesTokenCount ?? 0;
+  return {
+    content: response.text ?? "",
+    stopReason: toolCalls?.length ? "tool_use" : "end_turn",
+    usage: {
+      inputTokens,
+      outputTokens,
+      totalTokens: inputTokens + outputTokens,
+      estimatedCost: calculateCost(inputTokens, outputTokens, model)
+    },
+    model,
+    toolCalls: toolCalls?.length ? toolCalls : void 0
+  };
+};
+var GeminiProviderLive = Layer6.effect(
+  LLMService,
+  Effect7.gen(function* () {
+    const config = yield* LLMConfig;
+    let _clientPromise = null;
+    const getClient = () => {
+      if (!_clientPromise) {
+        _clientPromise = import("@google/genai").then(({ GoogleGenAI }) => new GoogleGenAI({ apiKey: config.googleApiKey }));
+      }
+      return _clientPromise;
+    };
+    const buildGeminiConfig = (opts) => {
+      const cfg = {
+        maxOutputTokens: opts.maxTokens ?? config.defaultMaxTokens,
+        temperature: opts.temperature ?? config.defaultTemperature
+      };
+      const sys = opts.systemPrompt;
+      if (sys) cfg.systemInstruction = sys;
+      if (opts.stopSequences?.length) cfg.stopSequences = [...opts.stopSequences];
+      if (opts.tools?.length) {
+        cfg.tools = toGeminiTools([...opts.tools]);
+      }
+      return cfg;
+    };
+    return LLMService.of({
+      complete: (request) => Effect7.gen(function* () {
+        const client = yield* Effect7.promise(() => getClient());
+        const model = request.model?.model ?? config.defaultModel;
+        const contents = toGeminiContents(request.messages);
+        const systemPrompt = extractSystemPrompt(request.messages) ?? request.systemPrompt;
+        const response = yield* Effect7.tryPromise({
+          try: () => client.models.generateContent({
+            model,
+            contents,
+            config: buildGeminiConfig({
+              maxTokens: request.maxTokens,
+              temperature: request.temperature,
+              systemPrompt,
+              stopSequences: request.stopSequences,
+              tools: request.tools
+            })
+          }),
+          catch: toEffectError3
+        });
+        return mapGeminiResponse(response, model);
+      }).pipe(
+        Effect7.retry(retryPolicy),
+        Effect7.timeout("30 seconds"),
+        Effect7.catchTag(
+          "TimeoutException",
+          () => Effect7.fail(
+            new LLMTimeoutError({
+              message: "LLM request timed out",
+              provider: "gemini",
+              timeoutMs: 3e4
+            })
+          )
+        )
+      ),
+      stream: (request) => Effect7.gen(function* () {
+        const model = request.model?.model ?? config.defaultModel;
+        const contents = toGeminiContents(request.messages);
+        const systemPrompt = extractSystemPrompt(request.messages) ?? request.systemPrompt;
+        return Stream4.async((emit) => {
+          void (async () => {
+            try {
+              const client = await getClient();
+              const stream = await client.models.generateContentStream({
+                model,
+                contents,
+                config: buildGeminiConfig({
+                  maxTokens: request.maxTokens,
+                  temperature: request.temperature,
+                  systemPrompt
+                })
+              });
+              let fullContent = "";
+              let inputTokens = 0;
+              let outputTokens = 0;
+              for await (const chunk of stream) {
+                if (chunk.text) {
+                  emit.single({ type: "text_delta", text: chunk.text });
+                  fullContent += chunk.text;
+                }
+                if (chunk.usageMetadata) {
+                  inputTokens = chunk.usageMetadata.promptTokenCount ?? 0;
+                  outputTokens = chunk.usageMetadata.candidatesTokenCount ?? 0;
+                }
+              }
+              emit.single({ type: "content_complete", content: fullContent });
+              emit.single({
+                type: "usage",
+                usage: {
+                  inputTokens,
+                  outputTokens,
+                  totalTokens: inputTokens + outputTokens,
+                  estimatedCost: calculateCost(inputTokens, outputTokens, model)
+                }
+              });
+              emit.end();
+            } catch (error) {
+              const err = error;
+              emit.fail(
+                new LLMError({
+                  message: err.message ?? String(error),
+                  provider: "gemini",
+                  cause: error
+                })
+              );
+            }
+          })();
+        });
+      }),
+      completeStructured: (request) => Effect7.gen(function* () {
+        const schemaStr = JSON.stringify(
+          Schema5.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 client = yield* Effect7.promise(() => getClient());
+          const model = request.model?.model ?? config.defaultModel;
+          const response = yield* Effect7.tryPromise({
+            try: () => client.models.generateContent({
+              model,
+              contents: toGeminiContents(msgs),
+              config: buildGeminiConfig({
+                maxTokens: request.maxTokens,
+                temperature: request.temperature,
+                systemPrompt: request.systemPrompt
+              })
+            }),
+            catch: toEffectError3
+          });
+          const mapped = mapGeminiResponse(response, model);
+          try {
+            const parsed = JSON.parse(mapped.content);
+            const decoded = Schema5.decodeUnknownEither(
+              request.outputSchema
+            )(parsed);
+            if (decoded._tag === "Right") {
+              return decoded.right;
+            }
+            lastError = decoded.left;
+          } catch (e) {
+            lastError = e;
+          }
+        }
+        return yield* Effect7.fail(
+          new LLMParseError({
+            message: `Failed to parse structured output after ${maxRetries + 1} attempts`,
+            rawOutput: String(lastError),
+            expectedSchema: schemaStr
+          })
+        );
+      }),
+      embed: (texts, model) => Effect7.tryPromise({
+        try: async () => {
+          const client = await getClient();
+          const embeddingModel = model ?? "gemini-embedding-001";
+          const result = await client.models.embedContent({
+            model: embeddingModel,
+            contents: [...texts],
+            config: {
+              outputDimensionality: config.embeddingConfig.dimensions
+            }
+          });
+          return result.embeddings.map((e) => e.values);
+        },
+        catch: (error) => new LLMError({
+          message: `Embedding failed: ${error}`,
+          provider: "gemini",
+          cause: error
+        })
+      }),
+      countTokens: (messages) => Effect7.gen(function* () {
+        return yield* estimateTokenCount(messages);
+      }),
+      getModelConfig: () => Effect7.succeed({
+        provider: "gemini",
+        model: config.defaultModel
+      })
+    });
+  })
+);
+
+// src/testing.ts
+import { Effect as Effect8, Layer as Layer7, Stream as Stream5, Schema as Schema6 } from "effect";
+var TestLLMService = (responses) => ({
+  complete: (request) => Effect8.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 : "";
+    const searchText = `${content} ${systemPrompt}`;
+    for (const [pattern, response] of Object.entries(responses)) {
+      if (pattern.length > 0 && searchText.includes(pattern)) {
+        return {
+          content: response,
+          stopReason: "end_turn",
+          usage: {
+            inputTokens: Math.ceil(content.length / 4),
+            outputTokens: Math.ceil(response.length / 4),
+            totalTokens: Math.ceil(content.length / 4) + Math.ceil(response.length / 4),
+            estimatedCost: 0
+          },
+          model: "test-model"
+        };
+      }
+    }
+    return {
+      content: "Test response",
+      stopReason: "end_turn",
+      usage: {
+        inputTokens: 0,
+        outputTokens: 0,
+        totalTokens: 0,
+        estimatedCost: 0
+      },
+      model: "test-model"
+    };
+  }),
+  stream: (_request) => Effect8.succeed(
+    Stream5.make(
+      { type: "text_delta", text: "Test " },
+      { type: "text_delta", text: "response" },
+      {
+        type: "content_complete",
+        content: "Test response"
+      },
+      {
+        type: "usage",
+        usage: {
+          inputTokens: 0,
+          outputTokens: 0,
+          totalTokens: 0,
+          estimatedCost: 0
+        }
+      }
+    )
+  ),
+  completeStructured: (request) => Effect8.gen(function* () {
+    const lastMessage = request.messages[request.messages.length - 1];
+    const content = lastMessage && typeof lastMessage.content === "string" ? lastMessage.content : "";
+    let responseContent = "Test response";
+    for (const [pattern, response] of Object.entries(responses)) {
+      if (content.includes(pattern)) {
+        responseContent = response;
+        break;
+      }
+    }
+    const parsed = JSON.parse(responseContent);
+    return Schema6.decodeUnknownSync(request.outputSchema)(parsed);
+  }),
+  embed: (texts) => Effect8.succeed(
+    texts.map(() => new Array(768).fill(0).map(() => Math.random()))
+  ),
+  countTokens: (messages) => Effect8.succeed(
+    messages.reduce(
+      (sum, m) => sum + (typeof m.content === "string" ? Math.ceil(m.content.length / 4) : 100),
+      0
+    )
+  ),
+  getModelConfig: () => Effect8.succeed({
+    provider: "anthropic",
+    model: "test-model"
+  })
+});
+var TestLLMServiceLayer = (responses = {}) => Layer7.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
+    })
+  ),
+  finalAnswer: Schema7.optional(Schema7.String),
+  isComplete: Schema7.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 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 StrategySelectionSchema = Schema7.Struct({
+  selectedStrategy: Schema7.String,
+  reasoning: Schema7.String,
+  confidence: Schema7.Number,
+  alternativeStrategies: Schema7.Array(
+    Schema7.Struct({
+      strategy: Schema7.String,
+      whyNot: Schema7.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 ComplexityAnalysisSchema = Schema7.Struct({
+  score: Schema7.Number,
+  factors: Schema7.Array(
+    Schema7.Struct({
+      factor: Schema7.String,
+      weight: Schema7.Number,
+      reasoning: Schema7.String
+    })
+  ),
+  recommendedStrategy: Schema7.String,
+  recommendedModel: Schema7.String
+});
+
+// src/runtime.ts
+import { Layer as Layer8 } from "effect";
+var createLLMProviderLayer = (provider = "anthropic", testResponses) => {
+  if (provider === "test") {
+    return Layer8.mergeAll(
+      TestLLMServiceLayer(testResponses ?? {}),
+      PromptManagerLive
+    );
+  }
+  const configLayer = LLMConfigFromEnv;
+  const providerLayer = provider === "anthropic" ? AnthropicProviderLive : provider === "openai" ? OpenAIProviderLive : provider === "gemini" ? GeminiProviderLive : LocalProviderLive;
+  return Layer8.mergeAll(
+    providerLayer.pipe(Layer8.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)),
+    PromptManagerLive
+  );
+};
+export {
+  AnthropicProviderLive,
+  CacheControlSchema,
+  CompletionResponseSchema,
+  ComplexityAnalysisSchema,
+  DefaultEmbeddingConfig,
+  EmbeddingConfigSchema,
+  GeminiProviderLive,
+  ImageContentBlockSchema,
+  ImageSourceSchema,
+  LLMConfig,
+  LLMConfigFromEnv,
+  LLMContextOverflowError,
+  LLMError,
+  LLMParseError,
+  LLMProviderType,
+  LLMRateLimitError,
+  LLMService,
+  LLMTimeoutError,
+  LocalProviderLive,
+  ModelConfigSchema,
+  ModelPresets,
+  OpenAIProviderLive,
+  PlanSchema,
+  PromptManager,
+  PromptManagerLive,
+  ReActActionSchema,
+  ReflectionSchema,
+  StopReasonSchema,
+  StrategySelectionSchema,
+  TestLLMService,
+  TestLLMServiceLayer,
+  TextContentBlockSchema,
+  ThoughtEvaluationSchema,
+  TokenUsageSchema,
+  ToolCallSchema,
+  ToolDefinitionSchema,
+  ToolResultContentBlockSchema,
+  ToolUseContentBlockSchema,
+  calculateCost,
+  createLLMProviderLayer,
+  createLLMProviderLayerWithConfig,
+  estimateTokenCount,
+  makeCacheable,
+  retryPolicy
+};
+//# sourceMappingURL=index.js.map