@abassey/aid 0.1.0

package/dist/chunk-YNIEOBDF.js

@@ -0,0 +1,1436 @@
+import {
+  AidError,
+  DEFAULT_CONFIG,
+  executePipeline,
+  getGlobalConfig,
+  resolveProvider
+} from "./chunk-2TNYBUNK.js";
+
+// src/core/streaming.ts
+var AiStream = class {
+  _generatorFn;
+  _aborted = false;
+  _textCallbacks = [];
+  _doneCallbacks = [];
+  _errorCallbacks = [];
+  constructor(generatorFn) {
+    this._generatorFn = generatorFn;
+  }
+  on(event, cb) {
+    switch (event) {
+      case "text":
+        this._textCallbacks.push(cb);
+        break;
+      case "done":
+        this._doneCallbacks.push(cb);
+        break;
+      case "error":
+        this._errorCallbacks.push(cb);
+        break;
+    }
+  }
+  /**
+   * Signal the stream to stop after the current chunk.
+   * The for-await loop will end gracefully without throwing.
+   */
+  abort() {
+    this._aborted = true;
+  }
+  /**
+   * Implement the AsyncIterable protocol so this works with `for await`.
+   */
+  [Symbol.asyncIterator]() {
+    const generator = this._generatorFn();
+    const self = this;
+    return {
+      async next() {
+        if (self._aborted) {
+          await generator.return(void 0);
+          return { value: void 0, done: true };
+        }
+        try {
+          const result = await generator.next();
+          if (result.done) {
+            return { value: void 0, done: true };
+          }
+          const chunk = result.value;
+          if (chunk.done) {
+            if (chunk.response) {
+              for (const cb of self._doneCallbacks) {
+                cb(chunk.response);
+              }
+            }
+          } else {
+            for (const cb of self._textCallbacks) {
+              cb(chunk.delta);
+            }
+          }
+          if (self._aborted) {
+          }
+          return { value: chunk, done: false };
+        } catch (err) {
+          const error = err instanceof Error ? err : new Error(String(err));
+          for (const cb of self._errorCallbacks) {
+            cb(error);
+          }
+          throw error;
+        }
+      },
+      async return(value) {
+        await generator.return(value);
+        return { value: void 0, done: true };
+      },
+      async throw(err) {
+        await generator.throw(err);
+        return { value: void 0, done: true };
+      }
+    };
+  }
+};
+
+// src/utils/http.ts
+async function fetchWithTimeout(url, init, timeoutMs, signal) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const mergedSignal = signal ? createMergedSignal(signal, controller.signal) : controller.signal;
+    const response = await fetch(url, {
+      ...init,
+      signal: mergedSignal
+    });
+    clearTimeout(timeoutId);
+    return response;
+  } catch (error) {
+    clearTimeout(timeoutId);
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new AidError(
+        "timeout",
+        `Request timed out after ${timeoutMs}ms`,
+        { cause: error }
+      );
+    }
+    if (error instanceof TypeError) {
+      throw new AidError(
+        "network",
+        `Network error: ${error.message}`,
+        { cause: error }
+      );
+    }
+    if (error instanceof AidError) {
+      throw error;
+    }
+    throw new AidError(
+      "network",
+      error instanceof Error ? error.message : "Unknown network error",
+      { cause: error instanceof Error ? error : void 0 }
+    );
+  }
+}
+function mapHttpError(status, body, provider) {
+  let code;
+  let message;
+  if (status === 401 || status === 403) {
+    code = "auth_error";
+    message = `Authentication failed: ${body}`;
+  } else if (status === 429) {
+    code = "rate_limit";
+    message = `Rate limit exceeded: ${body}`;
+  } else if (status === 400) {
+    code = "invalid_request";
+    message = `Invalid request: ${body}`;
+  } else if (status === 413) {
+    code = "context_length";
+    message = `Context length exceeded: ${body}`;
+  } else if (status >= 500) {
+    code = "provider_error";
+    message = `Provider error: ${body}`;
+  } else {
+    code = "provider_error";
+    message = `HTTP ${status}: ${body}`;
+  }
+  return new AidError(code, message, {
+    provider,
+    statusCode: status,
+    raw: body
+  });
+}
+function createMergedSignal(signal1, signal2) {
+  const controller = new AbortController();
+  const abort = () => controller.abort();
+  if (signal1.aborted || signal2.aborted) {
+    controller.abort();
+  } else {
+    signal1.addEventListener("abort", abort, { once: true });
+    signal2.addEventListener("abort", abort, { once: true });
+  }
+  return controller.signal;
+}
+
+// src/utils/cost.ts
+var PRICING_TABLE = {
+  "claude-sonnet-4-6-20250217": { input: 3, output: 15 },
+  "claude-sonnet-4-5-20250929": { input: 3, output: 15 },
+  "claude-opus-4-6-20250205": { input: 15, output: 75 },
+  "claude-opus-4-5-20250120": { input: 15, output: 75 },
+  "claude-haiku-4-5-20251001": { input: 0.8, output: 4 },
+  "gpt-5.4-2026-03-05": { input: 2.5, output: 10 },
+  "gpt-5.3-2025-12-01": { input: 2.5, output: 10 },
+  "gpt-4o": { input: 2.5, output: 10 },
+  "gpt-4o-2024-08-06": { input: 2.5, output: 10 },
+  "gpt-4o-mini": { input: 0.15, output: 0.6 },
+  "o3-2025-04-16": { input: 10, output: 40 },
+  "o3-mini": { input: 1.1, output: 4.4 },
+  "o4-mini": { input: 1.1, output: 4.4 },
+  "o4-mini-2025-04-16": { input: 1.1, output: 4.4 }
+};
+function calculateCost(model, inputTokens, outputTokens) {
+  const pricing = PRICING_TABLE[model];
+  if (!pricing) {
+    return 0;
+  }
+  return (inputTokens * pricing.input + outputTokens * pricing.output) / 1e6;
+}
+function estimateCost(params) {
+  const { model, inputTokens, maxOutputTokens } = params;
+  const min = calculateCost(model, inputTokens, 1);
+  const max = calculateCost(model, inputTokens, maxOutputTokens);
+  return { min, max };
+}
+
+// src/providers/anthropic.ts
+var AnthropicAdapter = class {
+  name = "anthropic";
+  supportsImages = true;
+  supportsTools = true;
+  apiKey;
+  baseUrl;
+  apiVersion;
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.baseUrl = options.baseUrl ?? "https://api.anthropic.com";
+    this.apiVersion = options.apiVersion ?? "2023-06-01";
+  }
+  async call(request) {
+    const startTime = Date.now();
+    let systemPrompt;
+    const filteredMessages = [];
+    for (const msg of request.messages) {
+      if (msg.role === "system") {
+        systemPrompt = msg.content;
+      } else {
+        filteredMessages.push(msg);
+      }
+    }
+    const anthropicMessages = filteredMessages.map(
+      (msg) => this.mapMessage(msg)
+    );
+    const body = {
+      model: request.model,
+      messages: anthropicMessages,
+      max_tokens: request.options.maxTokens
+    };
+    if (systemPrompt) {
+      body.system = systemPrompt;
+    }
+    if (request.options.temperature !== void 0) {
+      body.temperature = request.options.temperature;
+    } else if (request.options.topP !== void 0) {
+      body.top_p = request.options.topP;
+    }
+    if (request.options.stop && request.options.stop.length > 0) {
+      body.stop_sequences = request.options.stop;
+    }
+    if (request.tools && request.tools.length > 0) {
+      body.tools = request.tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        input_schema: tool.parameters
+      }));
+    }
+    const url = `${this.baseUrl}/v1/messages`;
+    const headers = {
+      "content-type": "application/json",
+      "x-api-key": this.apiKey,
+      "anthropic-version": this.apiVersion
+    };
+    const response = await fetchWithTimeout(
+      url,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body)
+      },
+      request.options.timeout
+    );
+    if (!response.ok) {
+      const responseBody = await response.text();
+      const status = response.status;
+      if (status === 429) {
+        const retryAfterHeader = response.headers.get("retry-after");
+        const retryAfter = retryAfterHeader ? parseInt(retryAfterHeader, 10) : void 0;
+        throw new AidError("rate_limit", `Rate limit exceeded: ${responseBody}`, {
+          provider: this.name,
+          model: request.model,
+          statusCode: status,
+          retryAfter,
+          raw: responseBody
+        });
+      }
+      let code;
+      if (status === 401 || status === 403) {
+        code = "auth_error";
+      } else if (status === 400) {
+        const lowerBody = responseBody.toLowerCase();
+        if (lowerBody.includes("context") || lowerBody.includes("token") || lowerBody.includes("too long")) {
+          code = "context_length";
+        } else {
+          code = "invalid_request";
+        }
+      } else if (status >= 500 || status === 529) {
+        code = "provider_error";
+      } else {
+        code = "provider_error";
+      }
+      throw new AidError(code, `Anthropic API error (${status}): ${responseBody}`, {
+        provider: this.name,
+        model: request.model,
+        statusCode: status,
+        raw: responseBody
+      });
+    }
+    const data = await response.json();
+    const latencyMs = Date.now() - startTime;
+    return this.normalizeResponse(data, request.model, latencyMs);
+  }
+  stream(request) {
+    const self = this;
+    return new AiStream(async function* () {
+      const startTime = Date.now();
+      let systemPrompt;
+      const filteredMessages = [];
+      for (const msg of request.messages) {
+        if (msg.role === "system") {
+          systemPrompt = msg.content;
+        } else {
+          filteredMessages.push(msg);
+        }
+      }
+      const anthropicMessages = filteredMessages.map(
+        (msg) => self.mapMessage(msg)
+      );
+      const body = {
+        model: request.model,
+        messages: anthropicMessages,
+        max_tokens: request.options.maxTokens,
+        stream: true
+      };
+      if (systemPrompt) {
+        body.system = systemPrompt;
+      }
+      if (request.options.temperature !== void 0) {
+        body.temperature = request.options.temperature;
+      } else if (request.options.topP !== void 0) {
+        body.top_p = request.options.topP;
+      }
+      if (request.options.stop && request.options.stop.length > 0) {
+        body.stop_sequences = request.options.stop;
+      }
+      if (request.tools && request.tools.length > 0) {
+        body.tools = request.tools.map((tool) => ({
+          name: tool.name,
+          description: tool.description,
+          input_schema: tool.parameters
+        }));
+      }
+      const url = `${self.baseUrl}/v1/messages`;
+      const headers = {
+        "content-type": "application/json",
+        "x-api-key": self.apiKey,
+        "anthropic-version": self.apiVersion
+      };
+      const response = await fetchWithTimeout(
+        url,
+        {
+          method: "POST",
+          headers,
+          body: JSON.stringify(body)
+        },
+        request.options.timeout
+      );
+      if (!response.ok) {
+        const responseBody = await response.text();
+        const status = response.status;
+        if (status === 429) {
+          const retryAfterHeader = response.headers.get("retry-after");
+          const retryAfter = retryAfterHeader ? parseInt(retryAfterHeader, 10) : void 0;
+          throw new AidError("rate_limit", `Rate limit exceeded: ${responseBody}`, {
+            provider: self.name,
+            model: request.model,
+            statusCode: status,
+            retryAfter,
+            raw: responseBody
+          });
+        }
+        let code;
+        if (status === 401 || status === 403) {
+          code = "auth_error";
+        } else if (status === 400) {
+          const lowerBody = responseBody.toLowerCase();
+          if (lowerBody.includes("context") || lowerBody.includes("token") || lowerBody.includes("too long")) {
+            code = "context_length";
+          } else {
+            code = "invalid_request";
+          }
+        } else if (status >= 500 || status === 529) {
+          code = "provider_error";
+        } else {
+          code = "provider_error";
+        }
+        throw new AidError(code, `Anthropic API error (${status}): ${responseBody}`, {
+          provider: self.name,
+          model: request.model,
+          statusCode: status,
+          raw: responseBody
+        });
+      }
+      const text = await response.text();
+      const events = self.parseSSE(text);
+      let accumulated = "";
+      let inputTokens = 0;
+      let outputTokens = 0;
+      let stopReason = "end_turn";
+      let modelName = request.model;
+      for (const event of events) {
+        if (event.type === "message_start" && event.data.message) {
+          const msg = event.data.message;
+          if (msg.usage?.input_tokens !== void 0) {
+            inputTokens = msg.usage.input_tokens;
+          }
+          if (msg.model) {
+            modelName = msg.model;
+          }
+        } else if (event.type === "content_block_delta") {
+          const delta = event.data.delta;
+          if (delta?.type === "text_delta" && delta.text) {
+            accumulated += delta.text;
+            yield {
+              text: accumulated,
+              delta: delta.text,
+              done: false
+            };
+          }
+        } else if (event.type === "message_delta") {
+          if (event.data.delta?.stop_reason) {
+            stopReason = event.data.delta.stop_reason;
+          }
+          if (event.data.usage?.output_tokens !== void 0) {
+            outputTokens = event.data.usage.output_tokens;
+          }
+        } else if (event.type === "message_stop") {
+          const latencyMs = Date.now() - startTime;
+          const cost = calculateCost(modelName, inputTokens, outputTokens);
+          const finishReason = self.mapFinishReason(stopReason);
+          const aiResponse = {
+            text: accumulated,
+            model: modelName,
+            tokens: {
+              input: inputTokens,
+              output: outputTokens,
+              total: inputTokens + outputTokens
+            },
+            cost,
+            latencyMs,
+            finishReason,
+            raw: null
+          };
+          yield {
+            text: accumulated,
+            delta: "",
+            done: true,
+            response: aiResponse
+          };
+        }
+      }
+    });
+  }
+  parseSSE(text) {
+    const events = [];
+    const lines = text.split("\n");
+    let currentEvent = "";
+    let currentData = "";
+    for (const line of lines) {
+      if (line.startsWith("event: ")) {
+        currentEvent = line.slice(7).trim();
+      } else if (line.startsWith("data: ")) {
+        currentData = line.slice(6);
+      } else if (line.trim() === "" && currentEvent) {
+        try {
+          const parsed = JSON.parse(currentData);
+          events.push({ type: currentEvent, data: parsed });
+        } catch {
+        }
+        currentEvent = "";
+        currentData = "";
+      }
+    }
+    if (currentEvent && currentData) {
+      try {
+        const parsed = JSON.parse(currentData);
+        events.push({ type: currentEvent, data: parsed });
+      } catch {
+      }
+    }
+    return events;
+  }
+  mapMessage(msg) {
+    if (msg.role === "user") {
+      if (typeof msg.content === "string") {
+        return { role: "user", content: msg.content };
+      }
+      return {
+        role: "user",
+        content: msg.content.map((block) => {
+          if (block.type === "text") {
+            return { type: "text", text: block.text };
+          }
+          if (block.type === "image") {
+            return {
+              type: "image",
+              source: {
+                type: block.source.type,
+                media_type: block.source.mediaType,
+                data: block.source.data
+              }
+            };
+          }
+          if (block.type === "tool_result") {
+            return {
+              type: "tool_result",
+              tool_use_id: block.toolUseId,
+              content: block.content,
+              ...block.isError !== void 0 && { is_error: block.isError }
+            };
+          }
+          return block;
+        })
+      };
+    }
+    if (msg.role === "assistant") {
+      if (typeof msg.content === "string") {
+        return { role: "assistant", content: msg.content };
+      }
+      return {
+        role: "assistant",
+        content: msg.content.map((block) => {
+          if (block.type === "text") {
+            return { type: "text", text: block.text };
+          }
+          if (block.type === "tool_use") {
+            return {
+              type: "tool_use",
+              id: block.id,
+              name: block.name,
+              input: block.input
+            };
+          }
+          return block;
+        })
+      };
+    }
+    if (msg.role === "tool") {
+      return {
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: msg.toolCallId,
+            content: msg.content
+          }
+        ]
+      };
+    }
+    throw new AidError("invalid_request", `Unsupported message role: ${msg.role}`, {
+      provider: this.name
+    });
+  }
+  normalizeResponse(data, model, latencyMs) {
+    const textBlocks = data.content.filter((b) => b.type === "text");
+    const text = textBlocks.map((b) => b.text ?? "").join("");
+    const toolUseBlocks = data.content.filter((b) => b.type === "tool_use");
+    const toolCalls = toolUseBlocks.map((b) => ({
+      id: b.id,
+      name: b.name,
+      args: b.input ?? {}
+    }));
+    const finishReason = this.mapFinishReason(data.stop_reason);
+    const inputTokens = data.usage.input_tokens;
+    const outputTokens = data.usage.output_tokens;
+    const cost = calculateCost(model, inputTokens, outputTokens);
+    const response = {
+      text,
+      model: data.model,
+      tokens: {
+        input: inputTokens,
+        output: outputTokens,
+        total: inputTokens + outputTokens
+      },
+      cost,
+      latencyMs,
+      finishReason,
+      raw: data
+    };
+    if (toolCalls.length > 0) {
+      response.toolCalls = toolCalls;
+    }
+    return response;
+  }
+  mapFinishReason(stopReason) {
+    switch (stopReason) {
+      case "end_turn":
+        return "stop";
+      case "max_tokens":
+        return "length";
+      case "tool_use":
+        return "tool_use";
+      default:
+        return "error";
+    }
+  }
+};
+
+// src/providers/openai.ts
+var OpenAIAdapter = class {
+  name = "openai";
+  supportsImages = true;
+  supportsTools = true;
+  apiKey;
+  baseUrl;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl ?? "https://api.openai.com/v1";
+  }
+  async call(request) {
+    const startTime = Date.now();
+    const messages = this.mapMessages(request.messages);
+    const body = this.buildRequestBody(request, messages);
+    const response = await fetchWithTimeout(
+      `${this.baseUrl}/chat/completions`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify(body)
+      },
+      request.options.timeout
+    );
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw mapHttpError(response.status, errorBody, this.name);
+    }
+    const data = await response.json();
+    const latencyMs = Date.now() - startTime;
+    return this.normalizeResponse(data, latencyMs);
+  }
+  stream(request) {
+    const adapter = this;
+    return new AiStream(async function* () {
+      const startTime = Date.now();
+      const messages = adapter.mapMessages(request.messages);
+      const body = adapter.buildRequestBody(request, messages);
+      body.stream = true;
+      body.stream_options = { include_usage: true };
+      const response = await fetchWithTimeout(
+        `${adapter.baseUrl}/chat/completions`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${adapter.apiKey}`
+          },
+          body: JSON.stringify(body)
+        },
+        request.options.timeout
+      );
+      if (!response.ok) {
+        const errorBody = await response.text();
+        throw mapHttpError(response.status, errorBody, adapter.name);
+      }
+      if (!response.body) {
+        throw new AidError("provider_error", "Response body is null", {
+          provider: adapter.name
+        });
+      }
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let accumulated = "";
+      let model = request.model;
+      let inputTokens = 0;
+      let outputTokens = 0;
+      let totalTokens = 0;
+      let finishReason = "stop";
+      try {
+        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 || trimmed.startsWith(":")) continue;
+            if (!trimmed.startsWith("data: ")) continue;
+            const data = trimmed.slice(6);
+            if (data === "[DONE]") {
+              const latencyMs = Date.now() - startTime;
+              const aiResponse = {
+                text: accumulated,
+                model,
+                tokens: {
+                  input: inputTokens,
+                  output: outputTokens,
+                  total: totalTokens
+                },
+                cost: calculateCost(model, inputTokens, outputTokens),
+                latencyMs,
+                finishReason,
+                raw: { streaming: true }
+              };
+              yield {
+                text: accumulated,
+                delta: "",
+                done: true,
+                response: aiResponse
+              };
+              return;
+            }
+            let chunk;
+            try {
+              chunk = JSON.parse(data);
+            } catch {
+              continue;
+            }
+            if (chunk.model) {
+              model = chunk.model;
+            }
+            if (chunk.usage) {
+              inputTokens = chunk.usage.prompt_tokens ?? 0;
+              outputTokens = chunk.usage.completion_tokens ?? 0;
+              totalTokens = chunk.usage.total_tokens ?? 0;
+            }
+            const choice = chunk.choices?.[0];
+            if (!choice) continue;
+            if (choice.finish_reason) {
+              finishReason = adapter.mapFinishReason(choice.finish_reason);
+            }
+            const delta = choice.delta?.content ?? "";
+            if (delta) {
+              accumulated += delta;
+              yield {
+                text: accumulated,
+                delta,
+                done: false
+              };
+            }
+          }
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    });
+  }
+  mapMessages(messages) {
+    return messages.map((msg) => {
+      switch (msg.role) {
+        case "system":
+          return { role: "system", content: msg.content };
+        case "user":
+          return {
+            role: "user",
+            content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
+          };
+        case "assistant":
+          return {
+            role: "assistant",
+            content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
+          };
+        case "tool":
+          return {
+            role: "tool",
+            content: msg.content,
+            tool_call_id: msg.toolCallId
+          };
+      }
+    });
+  }
+  buildRequestBody(request, messages) {
+    const body = {
+      model: request.model,
+      messages,
+      temperature: request.options.temperature,
+      top_p: request.options.topP
+    };
+    body.max_completion_tokens = request.options.maxTokens;
+    if (request.options.stop && request.options.stop.length > 0) {
+      body.stop = request.options.stop;
+    }
+    if (request.tools && request.tools.length > 0) {
+      body.tools = request.tools.map((tool) => ({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.parameters
+        }
+      }));
+    }
+    return body;
+  }
+  normalizeResponse(data, latencyMs) {
+    const choice = data.choices[0];
+    const text = choice.message.content ?? "";
+    const finishReason = this.mapFinishReason(choice.finish_reason);
+    const inputTokens = data.usage.prompt_tokens;
+    const outputTokens = data.usage.completion_tokens;
+    const toolCalls = this.extractToolCalls(choice);
+    return {
+      text,
+      model: data.model,
+      tokens: {
+        input: inputTokens,
+        output: outputTokens,
+        total: data.usage.total_tokens
+      },
+      cost: calculateCost(data.model, inputTokens, outputTokens),
+      latencyMs,
+      finishReason,
+      toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+      raw: data
+    };
+  }
+  mapFinishReason(reason) {
+    switch (reason) {
+      case "stop":
+        return "stop";
+      case "length":
+        return "length";
+      case "tool_calls":
+        return "tool_use";
+      default:
+        return "error";
+    }
+  }
+  extractToolCalls(choice) {
+    if (!choice.message.tool_calls) {
+      return [];
+    }
+    return choice.message.tool_calls.map((tc) => ({
+      id: tc.id,
+      name: tc.function.name,
+      args: JSON.parse(tc.function.arguments)
+    }));
+  }
+};
+
+// src/core/tool-loop.ts
+async function executeToolLoop(options) {
+  const {
+    call,
+    request,
+    tools,
+    maxIterations,
+    initialResponse,
+    onToolCall,
+    onToolResult,
+    onLlmCall
+  } = options;
+  if (!initialResponse || initialResponse.finishReason !== "tool_use" || !initialResponse.toolCalls || initialResponse.toolCalls.length === 0) {
+    return {
+      response: initialResponse ?? {},
+      messages: [...request.messages],
+      iterations: 0,
+      toolCalls: []
+    };
+  }
+  const toolHandlers = /* @__PURE__ */ new Map();
+  for (const t of tools) {
+    toolHandlers.set(t.name, t.handler);
+  }
+  let currentMessages = [...request.messages];
+  let currentResponse = initialResponse;
+  let iteration = 0;
+  const allToolCalls = [];
+  while (currentResponse.finishReason === "tool_use" && currentResponse.toolCalls && currentResponse.toolCalls.length > 0 && iteration < maxIterations) {
+    iteration++;
+    const assistantContent = [];
+    if (currentResponse.text) {
+      assistantContent.push({ type: "text", text: currentResponse.text });
+    }
+    for (const tc of currentResponse.toolCalls) {
+      assistantContent.push({
+        type: "tool_use",
+        id: tc.id,
+        name: tc.name,
+        input: tc.args
+      });
+    }
+    currentMessages.push({ role: "assistant", content: assistantContent });
+    const toolResults = [];
+    for (const tc of currentResponse.toolCalls) {
+      allToolCalls.push(tc);
+      if (onToolCall) {
+        onToolCall(tc);
+      }
+      const handler = toolHandlers.get(tc.name);
+      if (!handler) {
+        toolResults.push({
+          type: "tool_result",
+          toolUseId: tc.id,
+          content: `Error: unknown tool '${tc.name}'`,
+          isError: true
+        });
+        if (onToolResult) {
+          onToolResult(tc, `Error: unknown tool '${tc.name}'`, 0);
+        }
+        continue;
+      }
+      const startMs = Date.now();
+      try {
+        const result = await handler(tc.args);
+        const durationMs = Date.now() - startMs;
+        toolResults.push({
+          type: "tool_result",
+          toolUseId: tc.id,
+          content: result
+        });
+        if (onToolResult) {
+          onToolResult(tc, result, durationMs);
+        }
+      } catch (err) {
+        const durationMs = Date.now() - startMs;
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        toolResults.push({
+          type: "tool_result",
+          toolUseId: tc.id,
+          content: `Error: ${errorMessage}`,
+          isError: true
+        });
+        if (onToolResult) {
+          onToolResult(tc, `Error: ${errorMessage}`, durationMs);
+        }
+      }
+    }
+    currentMessages.push({ role: "user", content: toolResults });
+    const newRequest = {
+      ...request,
+      messages: currentMessages
+    };
+    currentResponse = await call(newRequest);
+    if (onLlmCall) {
+      onLlmCall(currentResponse);
+    }
+  }
+  if (iteration >= maxIterations && currentResponse.finishReason === "tool_use") {
+    throw new AidError("tool_loop_limit", `Tool loop exceeded maximum iterations (${maxIterations})`);
+  }
+  return {
+    response: currentResponse,
+    messages: currentMessages,
+    iterations: iteration,
+    toolCalls: allToolCalls
+  };
+}
+
+// src/core/conversation.ts
+var ConversationImpl = class _ConversationImpl {
+  aiCall;
+  systemPrompt;
+  messages;
+  options;
+  constructor(aiCall, systemOrOptions, existingMessages) {
+    this.aiCall = aiCall;
+    if (typeof systemOrOptions === "string") {
+      this.systemPrompt = systemOrOptions;
+      this.options = { system: systemOrOptions };
+    } else {
+      this.systemPrompt = systemOrOptions?.system ?? "";
+      this.options = systemOrOptions ?? {};
+    }
+    this.messages = existingMessages ?? [];
+  }
+  async say(message, options) {
+    this.messages.push({ role: "user", content: message });
+    const allMessages = [...this.messages];
+    const response = await this.aiCall(message, {
+      ...options,
+      model: this.options.model,
+      system: this.systemPrompt || void 0,
+      _messages: allMessages
+    });
+    this.messages.push({ role: "assistant", content: response.text });
+    if (this.options.maxHistory && this.messages.length > this.options.maxHistory) {
+      this.messages = this.messages.slice(-this.options.maxHistory);
+    }
+    return response;
+  }
+  save() {
+    return {
+      system: this.systemPrompt,
+      messages: [...this.messages],
+      options: { ...this.options }
+    };
+  }
+  fork() {
+    return new _ConversationImpl(
+      this.aiCall,
+      { ...this.options },
+      this.messages.map((m) => ({ ...m }))
+    );
+  }
+  static load(aiCall, serialized) {
+    return new _ConversationImpl(
+      aiCall,
+      serialized.options,
+      [...serialized.messages]
+    );
+  }
+};
+
+// src/core/ai.ts
+function resolveOptions(baseOptions, perCallOptions) {
+  const global = getGlobalConfig();
+  const model = perCallOptions?.model ?? baseOptions?.model ?? global.model ?? DEFAULT_CONFIG.model;
+  const temperature = perCallOptions?.temperature ?? baseOptions?.temperature ?? global.temperature ?? DEFAULT_CONFIG.temperature;
+  const maxTokens = perCallOptions?.maxTokens ?? baseOptions?.maxTokens ?? global.maxTokens ?? DEFAULT_CONFIG.maxTokens;
+  const topP = perCallOptions?.topP ?? baseOptions?.topP ?? global.topP ?? DEFAULT_CONFIG.topP;
+  const stop = perCallOptions?.stop ?? baseOptions?.stop ?? global.stop ?? DEFAULT_CONFIG.stop;
+  const timeout = perCallOptions?.timeout ?? baseOptions?.timeout ?? global.timeout ?? DEFAULT_CONFIG.timeout;
+  const tools = [
+    ...DEFAULT_CONFIG.tools,
+    ...global.tools,
+    ...baseOptions?.tools ?? [],
+    ...perCallOptions?.tools ?? []
+  ];
+  const middleware = [
+    ...DEFAULT_CONFIG.middleware,
+    ...global.middleware,
+    ...baseOptions?.middleware ?? [],
+    ...perCallOptions?.middleware ?? []
+  ];
+  return {
+    model,
+    temperature,
+    maxTokens,
+    topP,
+    stop,
+    timeout,
+    tools,
+    middleware
+  };
+}
+function buildProviderRequest(prompt, options, baseOptions, resolved, modelId) {
+  const system = options?.system ?? baseOptions?.system;
+  const context = options?.context ?? baseOptions?.context;
+  const messages = options?._messages ?? baseOptions?._messages;
+  let messageList;
+  if (messages) {
+    messageList = [...messages];
+  } else {
+    const userContent = context ? `${context}
+
+${prompt}` : prompt;
+    messageList = [{ role: "user", content: userContent }];
+  }
+  if (system) {
+    messageList = [{ role: "system", content: system }, ...messageList];
+  }
+  const toolDefinitions = resolved.tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.parameters
+  }));
+  const request = {
+    model: modelId,
+    messages: messageList,
+    options: resolved
+  };
+  if (toolDefinitions.length > 0) {
+    request.tools = toolDefinitions;
+  }
+  return request;
+}
+function getAdapter(providerName, config, adapterCache) {
+  const cached = adapterCache.get(providerName);
+  if (cached) {
+    return cached;
+  }
+  let adapter;
+  if (providerName === "anthropic") {
+    const apiKey = config.providers.anthropic?.apiKey ?? process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+      throw new AidError(
+        "auth_error",
+        "No API key found for Anthropic. Set ANTHROPIC_API_KEY or configure providers.anthropic.apiKey."
+      );
+    }
+    adapter = new AnthropicAdapter({
+      apiKey,
+      baseUrl: config.providers.anthropic?.baseUrl
+    });
+  } else if (providerName === "openai") {
+    const apiKey = config.providers.openai?.apiKey ?? process.env.OPENAI_API_KEY;
+    if (!apiKey) {
+      throw new AidError(
+        "auth_error",
+        "No API key found for OpenAI. Set OPENAI_API_KEY or configure providers.openai.apiKey."
+      );
+    }
+    adapter = new OpenAIAdapter({
+      apiKey,
+      baseUrl: config.providers.openai?.baseUrl
+    });
+  } else {
+    throw new AidError(
+      "invalid_request",
+      `Unknown provider: ${providerName}`
+    );
+  }
+  adapterCache.set(providerName, adapter);
+  return adapter;
+}
+function zodToJsonSchema(schema) {
+  const shape = schema.shape ?? schema._def?.shape?.();
+  if (!shape) {
+    return { type: "object", properties: {}, required: [] };
+  }
+  const properties = {};
+  const required = [];
+  for (const [key, fieldSchema] of Object.entries(shape)) {
+    const field = fieldSchema;
+    const typeName = field._def?.typeName;
+    let jsonType = "string";
+    if (typeName === "ZodNumber") jsonType = "number";
+    else if (typeName === "ZodBoolean") jsonType = "boolean";
+    else if (typeName === "ZodArray") jsonType = "array";
+    else if (typeName === "ZodEnum") {
+      properties[key] = { type: "string", enum: field._def.values };
+      required.push(key);
+      continue;
+    }
+    properties[key] = { type: jsonType };
+    if (typeName !== "ZodOptional") {
+      required.push(key);
+    }
+  }
+  return { type: "object", properties, required };
+}
+function createAi(baseOptions) {
+  const adapterCache = /* @__PURE__ */ new Map();
+  async function aiCall(prompt, options) {
+    const resolved = resolveOptions(baseOptions, options);
+    const { providerName, modelId } = resolveProvider(resolved.model);
+    const config = getGlobalConfig();
+    const adapter = getAdapter(providerName, config, adapterCache);
+    const request = buildProviderRequest(prompt, options, baseOptions, resolved, modelId);
+    let response;
+    if (resolved.middleware.length > 0) {
+      response = await executePipeline(
+        resolved.middleware,
+        request,
+        (req) => adapter.call(req)
+      );
+    } else {
+      response = await adapter.call(request);
+    }
+    if (resolved.tools.length > 0 && response.finishReason === "tool_use" && response.toolCalls && response.toolCalls.length > 0) {
+      const callFn = resolved.middleware.length > 0 ? (req) => executePipeline(resolved.middleware, req, (r) => adapter.call(r)) : (req) => adapter.call(req);
+      const loopResult = await executeToolLoop({
+        call: callFn,
+        request,
+        tools: resolved.tools,
+        maxIterations: 10,
+        initialResponse: response
+      });
+      return loopResult.response;
+    }
+    return response;
+  }
+  function withOptions(options) {
+    const merged = { ...baseOptions, ...options };
+    return createAi(merged);
+  }
+  async function safe(prompt, options) {
+    try {
+      const response = await aiCall(prompt, options);
+      return [response, null];
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      return [null, error];
+    }
+  }
+  function stream(prompt, options) {
+    const resolved = resolveOptions(baseOptions, options);
+    const { providerName, modelId } = resolveProvider(resolved.model);
+    const config = getGlobalConfig();
+    const adapter = getAdapter(providerName, config, adapterCache);
+    const request = buildProviderRequest(prompt, options, baseOptions, resolved, modelId);
+    return adapter.stream(request);
+  }
+  function model(name) {
+    return buildFluent({ model: name });
+  }
+  function buildFluent(opts) {
+    return {
+      system(prompt) {
+        return buildFluent({ ...opts, system: prompt });
+      },
+      temperature(value) {
+        return buildFluent({ ...opts, temperature: value });
+      },
+      maxTokens(value) {
+        return buildFluent({ ...opts, maxTokens: value });
+      },
+      run(prompt) {
+        return aiCall(prompt, opts);
+      },
+      stream(prompt) {
+        const resolved = resolveOptions(baseOptions, opts);
+        const result = resolveProvider(resolved.model);
+        const config = getGlobalConfig();
+        const adapter = getAdapter(result.providerName, config, adapterCache);
+        const request = buildProviderRequest(prompt, opts, baseOptions, resolved, result.modelId);
+        return adapter.stream(request);
+      }
+    };
+  }
+  async function multi(prompt, models) {
+    const promises = models.map(
+      (m) => aiCall(prompt, { model: m })
+    );
+    const results = await Promise.allSettled(promises);
+    const responses = results.map((result, index) => {
+      if (result.status === "fulfilled") {
+        return result.value;
+      }
+      const errorMessage = result.reason instanceof Error ? result.reason.message : String(result.reason);
+      return {
+        text: errorMessage,
+        model: models[index],
+        tokens: { input: 0, output: 0, total: 0 },
+        cost: 0,
+        latencyMs: 0,
+        finishReason: "error",
+        raw: result.reason
+      };
+    });
+    const allFailed = results.every((r) => r.status === "rejected");
+    if (allFailed && results.length > 0) {
+      const firstRejected = results[0];
+      if (firstRejected.status === "rejected") {
+        throw firstRejected.reason;
+      }
+    }
+    return responses;
+  }
+  async function race(prompt, models) {
+    const promises = models.map((m) => aiCall(prompt, { model: m }));
+    return Promise.race(promises);
+  }
+  async function all(promises) {
+    return Promise.all(promises);
+  }
+  async function batch(prompts, options) {
+    const concurrency = options?.concurrency ?? 10;
+    const failFast = options?.failFast ?? false;
+    const onProgress = options?.onProgress;
+    const results = new Array(prompts.length);
+    let completed = 0;
+    let abortError = null;
+    let nextIndex = 0;
+    async function worker() {
+      while (nextIndex < prompts.length) {
+        if (failFast && abortError) {
+          return;
+        }
+        const index = nextIndex;
+        nextIndex++;
+        try {
+          results[index] = await aiCall(prompts[index]);
+        } catch (err) {
+          if (failFast) {
+            abortError = err instanceof Error ? err : new Error(String(err));
+            throw abortError;
+          }
+          results[index] = {
+            text: err instanceof Error ? err.message : String(err),
+            model: "unknown",
+            tokens: { input: 0, output: 0, total: 0 },
+            cost: 0,
+            latencyMs: 0,
+            finishReason: "error",
+            raw: err
+          };
+        }
+        completed++;
+        if (onProgress) {
+          onProgress(completed, prompts.length);
+        }
+      }
+    }
+    const workerCount = Math.min(concurrency, prompts.length);
+    const workers = [];
+    for (let i = 0; i < workerCount; i++) {
+      workers.push(worker());
+    }
+    if (failFast) {
+      await Promise.all(workers);
+    } else {
+      await Promise.allSettled(workers);
+    }
+    if (failFast && abortError) {
+      throw abortError;
+    }
+    return results;
+  }
+  async function summarize(text, options) {
+    const style = options?.style ?? "paragraph";
+    const systemPrompt = `Summarize the following text. Style: ${style}.`;
+    const { style: _style, maxLength: _maxLength, ...restOptions } = options ?? {};
+    const callOptions = {
+      ...restOptions,
+      system: systemPrompt
+    };
+    if (options?.maxLength) {
+      callOptions.system = `${systemPrompt} Keep it under ${options.maxLength} characters.`;
+    }
+    const response = await aiCall(text, callOptions);
+    return response.text;
+  }
+  async function translate(text, language, options) {
+    const response = await aiCall(text, {
+      ...options,
+      system: `Translate the following text to ${language}. Output only the translation.`
+    });
+    return response.text;
+  }
+  async function rewrite(text, style, options) {
+    const response = await aiCall(text, {
+      ...options,
+      system: `Rewrite the following text in a ${style} style.`
+    });
+    return response.text;
+  }
+  async function extract(text, schema, options) {
+    const zodSchema = schema;
+    const jsonSchema = zodToJsonSchema(zodSchema);
+    const resolved = resolveOptions(baseOptions, options);
+    const { providerName, modelId } = resolveProvider(resolved.model);
+    const config = getGlobalConfig();
+    const adapter = getAdapter(providerName, config, adapterCache);
+    const messages = [{ role: "user", content: text }];
+    if (options?.system) {
+      messages.unshift({ role: "system", content: options.system });
+    }
+    const request = {
+      model: modelId,
+      messages,
+      options: resolved,
+      tools: [{
+        name: "extract",
+        description: "Extract structured data from the text",
+        parameters: jsonSchema
+      }]
+    };
+    const response = await adapter.call(request);
+    if (response.toolCalls && response.toolCalls.length > 0) {
+      return zodSchema.parse(response.toolCalls[0].args);
+    }
+    throw new AidError("parse_error", "Model did not return a tool_use response for extract()");
+  }
+  async function classify(text, categories, options) {
+    const resolved = resolveOptions(baseOptions, options);
+    const { providerName, modelId } = resolveProvider(resolved.model);
+    const config = getGlobalConfig();
+    const adapter = getAdapter(providerName, config, adapterCache);
+    const classifySchema = {
+      type: "object",
+      properties: {
+        category: { type: "string", enum: [...categories] }
+      },
+      required: ["category"]
+    };
+    const systemPrompt = `Classify the following text into one of these categories: ${categories.join(", ")}. Use the classify tool.`;
+    const messages = [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: text }
+    ];
+    const request = {
+      model: modelId,
+      messages,
+      options: resolved,
+      tools: [{
+        name: "classify",
+        description: "Report the classification result",
+        parameters: classifySchema
+      }]
+    };
+    const response = await adapter.call(request);
+    if (response.toolCalls && response.toolCalls.length > 0) {
+      return response.toolCalls[0].args.category;
+    }
+    throw new AidError("parse_error", "Model did not return a tool_use response for classify()");
+  }
+  async function json(prompt, options) {
+    const response = await aiCall(prompt, {
+      ...options,
+      system: "Respond with valid JSON only. No markdown, no explanation."
+    });
+    let text = response.text.trim();
+    if (text.startsWith("```")) {
+      text = text.replace(/^```(?:json)?\s*\n?/, "").replace(/\n?```\s*$/, "");
+    }
+    try {
+      return JSON.parse(text);
+    } catch {
+      throw new AidError("parse_error", `Failed to parse JSON from response: ${response.text.slice(0, 100)}`);
+    }
+  }
+  function conversationFn(systemOrOptions) {
+    return new ConversationImpl(aiCall, systemOrOptions);
+  }
+  function conversationLoad(serialized) {
+    return ConversationImpl.load(aiCall, serialized);
+  }
+  const conversation = Object.assign(conversationFn, {
+    load: conversationLoad
+  });
+  const ai2 = Object.assign(aiCall, {
+    with: withOptions,
+    safe,
+    stream,
+    model,
+    multi,
+    race,
+    all,
+    batch,
+    extract,
+    classify,
+    json,
+    summarize,
+    translate,
+    rewrite,
+    conversation
+  });
+  return ai2;
+}
+var ai = createAi();
+
+export {
+  AiStream,
+  estimateCost,
+  executeToolLoop,
+  createAi,
+  ai
+};