@umituz/web-ai 1.1.0 → 1.2.0

package/dist/index.cjs

@@ -305,6 +305,23 @@ function errorFromUnknown(err) {
   return new AiError("upstream_error");
 }
 
+// src/core/errors/error-status.ts
+var AI_ERROR_STATUS = {
+  invalid_key: 502,
+  missing_key: 503,
+  rate_limited: 429,
+  capacity: 503,
+  timeout: 504,
+  invalid_request: 400,
+  model_unavailable: 503,
+  upstream_error: 502,
+  network: 502,
+  cancelled: 400
+};
+function aiErrorStatus(code) {
+  return AI_ERROR_STATUS[code];
+}
+
 // src/core/executor/retry-executor.strategy.ts
 var RetryExecutor = class {
   constructor(retryManager2, options) {
@@ -1428,13 +1445,14 @@ function buildContext(history, systemPrompt, budget) {
   const selected = [];
   for (let i = history.length - 1; i >= 0; i -= 1) {
     const message = history[i];
+    if (!message) continue;
     const cost = estimateMessageTokens(message);
     if (used + cost > available && selected.length > 0) break;
     used += cost;
     selected.push(message);
   }
   selected.reverse();
-  while (selected.length > 1 && (selected[0].role === "assistant" || selected[0].role === "tool")) {
+  while (selected.length > 1 && (selected[0]?.role === "assistant" || selected[0]?.role === "tool")) {
     selected.shift();
   }
   return [{ role: "system", content: systemPrompt }, ...selected];
@@ -1637,7 +1655,10 @@ function diffLines(before, after) {
   const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
   for (let i2 = m - 1; i2 >= 0; i2 -= 1) {
     for (let j2 = n - 1; j2 >= 0; j2 -= 1) {
-      dp[i2][j2] = a[i2] === b[j2] ? dp[i2 + 1][j2 + 1] + 1 : Math.max(dp[i2 + 1][j2], dp[i2][j2 + 1]);
+      const row = dp[i2];
+      if (row) {
+        row[j2] = a[i2] === b[j2] ? (dp[i2 + 1]?.[j2 + 1] ?? 0) + 1 : Math.max(dp[i2 + 1]?.[j2] ?? 0, row[j2 + 1] ?? 0);
+      }
     }
   }
   const out = [];
@@ -1645,23 +1666,23 @@ function diffLines(before, after) {
   let j = 0;
   while (i < m && j < n) {
     if (a[i] === b[j]) {
-      out.push({ type: "same", text: a[i] });
+      out.push({ type: "same", text: a[i] ?? "" });
       i += 1;
       j += 1;
-    } else if (dp[i + 1][j] >= dp[i][j + 1]) {
-      out.push({ type: "remove", text: a[i] });
+    } else if ((dp[i + 1]?.[j] ?? 0) >= (dp[i]?.[j + 1] ?? 0)) {
+      out.push({ type: "remove", text: a[i] ?? "" });
       i += 1;
     } else {
-      out.push({ type: "add", text: b[j] });
+      out.push({ type: "add", text: b[j] ?? "" });
       j += 1;
     }
   }
   while (i < m) {
-    out.push({ type: "remove", text: a[i] });
+    out.push({ type: "remove", text: a[i] ?? "" });
     i += 1;
   }
   while (j < n) {
-    out.push({ type: "add", text: b[j] });
+    out.push({ type: "add", text: b[j] ?? "" });
     j += 1;
   }
   return out;
@@ -1776,14 +1797,14 @@ function dotProduct(a, b) {
   const length = Math.min(a.length, b.length);
   let sum = 0;
   for (let i = 0; i < length; i += 1) {
-    sum += a[i] * b[i];
+    sum += (a[i] ?? 0) * (b[i] ?? 0);
   }
   return sum;
 }
 function magnitude(v) {
   let sum = 0;
   for (let i = 0; i < v.length; i += 1) {
-    sum += v[i] * v[i];
+    sum += (v[i] ?? 0) * (v[i] ?? 0);
   }
   return Math.sqrt(sum);
 }
@@ -1928,6 +1949,115 @@ function validateToolArgs(toolKey, args, schemas) {
   return { ok: false, error: `Invalid schema definition for tool: ${toolKey}` };
 }
 
+// src/core/analytics/usage-series.ts
+function num(value) {
+  const parsed = typeof value === "number" ? value : Number(value ?? 0);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+function utcDateKey(base, offsetDays) {
+  const shifted = new Date(base.getTime() - offsetDays * 864e5);
+  return shifted.toISOString().slice(0, 10);
+}
+function buildUsageDailySeries(days, usageRows, messageRows, today = /* @__PURE__ */ new Date()) {
+  const usageByDate = new Map(usageRows.map((row) => [row.date, row]));
+  const messageByDate = new Map(messageRows.map((row) => [row.date, row]));
+  const series = [];
+  for (let offset = days - 1; offset >= 0; offset -= 1) {
+    const date = utcDateKey(today, offset);
+    const usage = usageByDate.get(date);
+    const message = messageByDate.get(date);
+    series.push({
+      date,
+      requests: num(usage?.requests),
+      attempts: num(message?.attempts),
+      errors: num(message?.errors),
+      inputTokens: num(usage?.inputTokens),
+      outputTokens: num(usage?.outputTokens),
+      reasoningTokens: num(usage?.reasoningTokens),
+      costMicros: num(usage?.costMicros)
+    });
+  }
+  return series;
+}
+function usageWindowTotals(series, from, to) {
+  const slice = series.slice(from, to);
+  return slice.reduce(
+    (acc, day) => ({
+      requests: acc.requests + day.requests,
+      attempts: acc.attempts + day.attempts,
+      errors: acc.errors + day.errors,
+      inputTokens: acc.inputTokens + day.inputTokens,
+      outputTokens: acc.outputTokens + day.outputTokens,
+      costMicros: acc.costMicros + day.costMicros
+    }),
+    { requests: 0, attempts: 0, errors: 0, inputTokens: 0, outputTokens: 0, costMicros: 0 }
+  );
+}
+function usageTrendOf(current, previous) {
+  return {
+    current,
+    previous,
+    deltaPct: previous > 0 ? (current - previous) / previous * 100 : null
+  };
+}
+function errorRatePct(errors, attempts) {
+  if (attempts <= 0) return 0;
+  return errors / attempts * 100;
+}
+
+// src/core/remote/remote-chat-client.ts
+async function surfaceHttpError(response, callbacks) {
+  const payload = await response.json().catch(() => null);
+  callbacks.onError?.(payload?.code ?? "request_failed", payload?.error ?? "Request failed");
+}
+function createRemoteChatClient(options) {
+  const doFetch = options.fetchImpl ?? fetch;
+  const { urls } = options;
+  return {
+    streamChat(conversationId, body, callbacks) {
+      const controller = new AbortController();
+      const promise = (async () => {
+        const response = await doFetch(urls.stream(conversationId), {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify(body),
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          await surfaceHttpError(response, callbacks);
+          return;
+        }
+        if (!response.body) {
+          callbacks.onError?.("request_failed", "The server returned an empty stream.");
+          return;
+        }
+        await readSseResponse(response, callbacks);
+      })();
+      return {
+        promise,
+        abort: () => controller.abort()
+      };
+    },
+    async resolveToolCall(conversationId, toolCallId, approved, callbacks) {
+      const response = await doFetch(urls.resolveToolCall(conversationId, toolCallId), {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ approved })
+      });
+      if (!response.ok) {
+        await surfaceHttpError(response, callbacks);
+        return false;
+      }
+      const contentType = response.headers.get("content-type") ?? "";
+      if (!contentType.includes("text/event-stream") || !response.body) {
+        return false;
+      }
+      await readSseResponse(response, callbacks);
+      return true;
+    }
+  };
+}
+
 // src/providers/base/provider.types.ts
 function isTextProvider(provider) {
   return provider.capabilities.includes("text");
@@ -2658,7 +2788,7 @@ var AnthropicProvider = class {
       );
     }
     const structuredPrompt = new StructuredPromptBuilder(
-      messages[lastUserIndex].content
+      messages[lastUserIndex]?.content ?? ""
     ).withSchema(request.schema).build();
     messages[lastUserIndex] = { role: "user", content: structuredPrompt };
     const wireRequest = new AnthropicRequestBuilder(model).withRequest({ ...request, messages }).withEffort(this.config.effort).build();
@@ -2738,7 +2868,8 @@ function mapAnthropicUsage(usage) {
 }
 function findLastIndex(items, predicate) {
   for (let i = items.length - 1; i >= 0; i--) {
-    if (predicate(items[i])) return i;
+    const item = items[i];
+    if (item !== void 0 && predicate(item)) return i;
   }
   return -1;
 }
@@ -3238,7 +3369,7 @@ var GroqProvider = class {
       );
     }
     const structuredPrompt = new StructuredPromptBuilder(
-      messages[lastUserIndex].content
+      messages[lastUserIndex]?.content ?? ""
     ).withSchema(request.schema).build();
     messages[lastUserIndex] = { role: "user", content: structuredPrompt };
     const wireRequest = GroqChatRequestBuilder.for(model).withMessages(messages).withConfig(this.generationConfig(request, STRUCTURED_TEMPERATURE)).withJsonResponse(true).build();
@@ -3335,7 +3466,8 @@ function createGroqProvider(config) {
 }
 function findLastIndex2(items, predicate) {
   for (let i = items.length - 1; i >= 0; i--) {
-    if (predicate(items[i])) return i;
+    const item = items[i];
+    if (item !== void 0 && predicate(item)) return i;
   }
   return -1;
 }
@@ -3485,7 +3617,7 @@ var GeminiProvider = class extends BaseProvider {
     }
     messages[lastUserIndex] = {
       role: "user",
-      content: new StructuredPromptBuilder(messages[lastUserIndex].content).withSchema(request.schema).build()
+      content: new StructuredPromptBuilder(messages[lastUserIndex]?.content ?? "").withSchema(request.schema).build()
     };
     const result = await this.generate({ ...request, messages, temperature: 0.1 });
     return { value: this.jsonParser.parse(result.text), result };
@@ -3591,7 +3723,8 @@ function mapGeminiFinishReason(reason) {
 }
 function findLastIndex3(items, predicate) {
   for (let i = items.length - 1; i >= 0; i--) {
-    if (predicate(items[i])) return i;
+    const item = items[i];
+    if (item !== void 0 && predicate(item)) return i;
   }
   return -1;
 }
@@ -4809,98 +4942,636 @@ function createPrunaProvider(config) {
   return new PrunaProvider(config);
 }
 
-// src/providers/factory/create-ai.ts
-function createAI(config = {}) {
-  const factory = new ProviderFactory({
-    priority: config.priority,
-    fallbackEnabled: config.fallbackEnabled,
-    defaultTier: config.defaultTier
-  });
-  if (config.anthropic?.apiKey) {
-    factory.register(new AnthropicProvider(config.anthropic));
+// src/providers/adapters/openai-compatible.adapter.ts
+function toWireMessage(message) {
+  if (message.role === "tool") {
+    return { role: "tool", content: message.content, tool_call_id: message.toolCallId ?? "" };
   }
-  if (config.groq?.apiKey) {
-    factory.register(new GroqProvider(config.groq));
+  if (message.role === "assistant" && message.toolCalls && message.toolCalls.length > 0) {
+    return {
+      role: "assistant",
+      content: message.content,
+      tool_calls: message.toolCalls.map((call) => ({
+        id: call.id,
+        type: "function",
+        function: { name: call.name, arguments: call.arguments }
+      }))
+    };
   }
-  if (config.gemini?.apiKey) {
-    factory.register(new GeminiProvider({ ...config.gemini, enabled: true }));
+  if (message.role === "user") return { role: "user", content: message.content };
+  return { role: message.role, content: message.content };
+}
+function mergeImages(messages, images) {
+  if (images.length === 0) return [...messages];
+  const parts = images.map((image) => ({
+    type: "image_url",
+    image_url: { url: `data:${image.mimeType};base64,${image.dataBase64}` }
+  }));
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (!message || message.role !== "user") continue;
+    const textParts = typeof message.content === "string" ? message.content.length > 0 ? [{ type: "text", text: message.content }] : [] : message.content;
+    return [
+      ...messages.slice(0, index),
+      { role: "user", content: [...textParts, ...parts] },
+      ...messages.slice(index + 1)
+    ];
   }
-  if (config.fal?.apiKey) {
-    factory.register(new FalProvider({ ...config.fal, enabled: true }));
+  return [...messages, { role: "user", content: [...parts] }];
+}
+async function extractErrorDetail(response) {
+  try {
+    const body = await response.json();
+    return body.error;
+  } catch {
+    return void 0;
   }
-  if (config.pruna?.apiKey) {
-    factory.register(new PrunaProvider({ ...config.pruna, enabled: true }));
+}
+async function* parseSseEvent2(rawEvent, toolCallAccumulator) {
+  for (const line of rawEvent.split("\n")) {
+    if (!line.startsWith("data:")) continue;
+    const payload = line.slice(5).trim();
+    if (payload.length === 0 || payload === "[DONE]") continue;
+    let chunk;
+    try {
+      chunk = JSON.parse(payload);
+    } catch {
+      continue;
+    }
+    const delta = chunk.choices?.[0]?.delta;
+    if (delta?.reasoning) {
+      yield { type: "delta", channel: "reasoning", text: delta.reasoning };
+    }
+    if (delta?.content) {
+      yield { type: "delta", channel: "answer", text: delta.content };
+    }
+    if (delta?.tool_calls) {
+      for (const toolCallDelta of delta.tool_calls) toolCallAccumulator.push(toolCallDelta);
+    }
+    if (chunk.usage) {
+      yield {
+        type: "usage",
+        usage: {
+          inputTokens: chunk.usage.prompt_tokens ?? 0,
+          outputTokens: chunk.usage.completion_tokens ?? 0,
+          reasoningTokens: chunk.usage.completion_tokens_details?.reasoning_tokens
+        }
+      };
+    }
   }
-  return factory;
 }
-
-// src/providers/groq/groq-messages.ts
-var createUserMessage = (content) => ({
-  role: "user",
-  content
-});
-var createAssistantMessage = (content) => ({
-  role: "assistant",
-  content
-});
-var createSystemMessage = (content) => ({
-  role: "system",
-  content
-});
-var createMessage = (role, content) => ({
-  role,
-  content
-});
-var promptToMessages = (prompt) => [
-  createUserMessage(prompt)
-];
-var extractTextFromMessages = (messages) => messages.map((m) => m.content).join("\n\n");
-var formatMessagesForDisplay = (messages) => messages.map((m) => `[${m.role.toUpperCase()}]: ${m.content}`).join("\n\n---\n\n");
-
-// src/providers/groq/groq-structured-json.ts
-async function requestStructuredJson(client, request) {
-  const chatRequest = {
-    model: request.model,
-    messages: [createUserMessage(request.instructions)],
-    temperature: request.temperature,
-    max_tokens: request.maxTokens,
-    response_format: { type: "json_object" },
-    ...request.reasoningEffort !== void 0 ? { reasoning_effort: request.reasoningEffort } : {}
-  };
-  const response = await client.postChatCompletion(chatRequest);
-  const content = response.choices[0]?.message?.content ?? "";
-  const candidate = extractJsonCandidate(content);
+async function* parseSseStream(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  const toolCallAccumulator = new ToolCallAccumulator();
+  let buffer = "";
   try {
-    return JSON.parse(candidate);
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let separator = buffer.indexOf("\n\n");
+      while (separator !== -1) {
+        const rawEvent = buffer.slice(0, separator);
+        buffer = buffer.slice(separator + 2);
+        separator = buffer.indexOf("\n\n");
+        yield* parseSseEvent2(rawEvent, toolCallAccumulator);
+      }
+    }
   } catch (err) {
-    throw new GroqError(
-      "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
-      "model response contained no parsable json object",
-      err instanceof Error ? err : void 0
-    );
+    throw errorFromUnknown(err);
+  } finally {
+    reader.releaseLock();
+  }
+  const calls = toolCallAccumulator.finish();
+  if (calls.length > 0) yield { type: "tool_calls", calls };
+}
+function createOpenAiCompatibleAdapter(config) {
+  if (!config.baseUrl && !config.endpointUrl) {
+    throw new Error("createOpenAiCompatibleAdapter requires baseUrl or endpointUrl");
   }
+  const endpoint = config.endpointUrl ?? `${config.baseUrl}/chat/completions`;
+  return {
+    async *stream(req) {
+      const timeout = AbortSignal.timeout(config.timeoutMs);
+      const signal = req.signal ? AbortSignal.any([req.signal, timeout]) : timeout;
+      let response;
+      try {
+        response = await fetch(endpoint, {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${config.apiKey}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            model: req.externalModelId,
+            messages: mergeImages(req.messages.map(toWireMessage), req.images ?? []),
+            temperature: req.temperature,
+            max_completion_tokens: req.maxOutputTokens,
+            top_p: req.topP,
+            stream: true,
+            stream_options: { include_usage: true },
+            ...req.tools && req.tools.length > 0 ? {
+              tools: req.tools.map((tool) => ({ type: "function", function: tool })),
+              tool_choice: "auto"
+            } : {}
+          }),
+          signal
+        });
+      } catch (err) {
+        throw errorFromUnknown(err);
+      }
+      if (!response.ok || !response.body) {
+        const detail = await extractErrorDetail(response);
+        throw errorFromStatus(response.status, detail?.message, detail);
+      }
+      yield* parseSseStream(response.body);
+    }
+  };
 }
 
-// src/providers/groq/text-generation.service.ts
-var STRUCTURED_OUTPUT_TEMPERATURE = 0.1;
-var TextGenerationService = class {
-  constructor(httpClient, cache = new CacheManager(), defaultModel = DEFAULT_MODELS.TEXT) {
-    this.httpClient = httpClient;
-    this.cache = cache;
-    this.defaultModel = defaultModel;
+// src/providers/openai-compatible/openai-compatible.provider.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var STRUCTURED_TEMPERATURE2 = 0.1;
+var OpenAiCompatibleProvider = class {
+  constructor(config) {
+    this.config = config;
+    if (!config.baseUrl && !config.endpointUrl) {
+      throw new AIError(
+        "MISSING_CONFIG" /* MISSING_CONFIG */,
+        "OpenAiCompatibleProvider requires baseUrl or endpointUrl"
+      );
+    }
+    this.adapter = createOpenAiCompatibleAdapter({
+      baseUrl: config.baseUrl,
+      endpointUrl: config.endpointUrl,
+      apiKey: config.apiKey,
+      timeoutMs: config.timeoutMs ?? DEFAULT_TIMEOUT_MS
+    });
+    this.tiers = mergeTierOverrides(
+      config.model ? { fast: config.model, balanced: config.model, powerful: config.model } : {},
+      config.models
+    );
   }
-  httpClient;
-  cache;
-  defaultModel;
-  id = "groq-text-generation";
-  name = "Groq Text Generation";
+  config;
+  id = "openai-compatible";
+  name = "OpenAI-compatible";
   capabilities = ["text"];
+  adapter;
+  tiers;
   jsonParser = new JsonResponseParser();
-  generateCompletion(prompt, options = {}) {
-    const model = options.model ?? this.defaultModel;
-    return this.executeWithCache(
-      {
-        type: CACHE_KEY_TYPE_COMPLETION,
+  resolveModel(tier) {
+    return resolveModel(this.tiers, tier, this.id);
+  }
+  async healthCheck() {
+    return this.config.apiKey && (this.config.baseUrl || this.config.endpointUrl) ? "healthy" : "unavailable";
+  }
+  async estimateCost() {
+    return 0;
+  }
+  async generate(request) {
+    const model = this.modelFor(request);
+    const outcome = await this.consume(this.toAdapterRequest(model, request));
+    if (outcome.text.length === 0) {
+      throw this.noContentError(model);
+    }
+    return {
+      text: outcome.text,
+      usage: outcome.usage,
+      model,
+      providerId: this.id,
+      finishReason: "stop"
+    };
+  }
+  async generateStructured(request) {
+    const model = this.modelFor(request);
+    const messages = this.toWireMessages(request.messages, request.systemPrompt);
+    const lastUserIndex = findLastIndex4(messages, (m) => m.role === "user");
+    if (lastUserIndex === -1) {
+      throw new AIError(
+        "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+        "generateStructured requires at least one user message"
+      );
+    }
+    const structuredPrompt = new StructuredPromptBuilder(
+      messages[lastUserIndex]?.content ?? ""
+    ).withSchema(request.schema).build();
+    messages[lastUserIndex] = { role: "user", content: structuredPrompt };
+    const outcome = await this.consume({
+      externalModelId: model,
+      messages,
+      temperature: STRUCTURED_TEMPERATURE2,
+      signal: request.signal
+    });
+    if (outcome.text.length === 0) {
+      throw this.noContentError(model);
+    }
+    return {
+      value: this.jsonParser.parse(outcome.text),
+      result: {
+        text: outcome.text,
+        usage: outcome.usage,
+        model,
+        providerId: this.id,
+        finishReason: "stop"
+      }
+    };
+  }
+  async stream(request, callbacks) {
+    const model = this.modelFor(request);
+    try {
+      const outcome = await this.consume(this.toAdapterRequest(model, request), (text) => {
+        callbacks.onChunk?.(text);
+      });
+      if (outcome.text.length === 0) {
+        throw this.noContentError(model);
+      }
+      const result = {
+        text: outcome.text,
+        usage: outcome.usage,
+        model,
+        providerId: this.id,
+        finishReason: "stop"
+      };
+      callbacks.onComplete?.(result);
+      return result;
+    } catch (error) {
+      callbacks.onError?.(error instanceof Error ? error : new Error(String(error)));
+      throw error;
+    }
+  }
+  /* ---------- internals ---------- */
+  /** Drain one adapter stream to its end. `onChunk`, when given, sees answer
+   *  deltas as they arrive — the streaming surface is this same drain. */
+  async consume(req, onChunk) {
+    let text = "";
+    let usage;
+    for await (const event of this.adapter.stream(req)) {
+      if (event.type === "delta" && event.channel === "answer") {
+        text += event.text;
+        onChunk?.(event.text);
+      } else if (event.type === "usage") {
+        usage = event.usage;
+      }
+    }
+    return { text, usage };
+  }
+  modelFor(request) {
+    return request.model ?? this.resolveModel(request.tier ?? "balanced");
+  }
+  noContentError(model) {
+    return new AIError(
+      "SERVER_ERROR" /* SERVER_ERROR */,
+      "No content generated from the OpenAI-compatible endpoint",
+      void 0,
+      { model }
+    );
+  }
+  toAdapterRequest(model, request) {
+    return {
+      externalModelId: model,
+      messages: this.toWireMessages(request.messages, request.systemPrompt),
+      ...request.temperature !== void 0 ? { temperature: request.temperature } : {},
+      ...request.maxTokens !== void 0 ? { maxOutputTokens: request.maxTokens } : {},
+      ...request.topP !== void 0 ? { topP: request.topP } : {},
+      ...request.signal ? { signal: request.signal } : {}
+    };
+  }
+  /** Neutral messages onto the adapter's shape; systemPrompt becomes the
+   *  leading system message (in-band, the OpenAI way). */
+  toWireMessages(messages, systemPrompt) {
+    const wire = [];
+    if (systemPrompt && systemPrompt.length > 0) {
+      wire.push({ role: "system", content: systemPrompt });
+    }
+    for (const message of messages) {
+      wire.push({ role: message.role, content: message.content });
+    }
+    return wire;
+  }
+};
+function createOpenAiCompatibleProvider(config) {
+  return new OpenAiCompatibleProvider(config);
+}
+function findLastIndex4(items, predicate) {
+  for (let index = items.length - 1; index >= 0; index -= 1) {
+    if (predicate(items[index])) return index;
+  }
+  return -1;
+}
+
+// src/providers/workers-ai/workers-ai.entities.ts
+var WorkersAIError = class extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.name = "WorkersAIError";
+    this.status = status;
+  }
+};
+
+// src/providers/workers-ai/workers-ai.text.ts
+var WORKERS_AI_LLM_MODEL = "@cf/meta/llama-3.3-70b-instruct-fp8-fast";
+var WORKERS_AI_TEXT_TIMEOUT_MS = 25e3;
+function workersAIConfigured(env) {
+  return typeof env.AI?.run === "function";
+}
+function requireAi(env) {
+  const ai = env.AI;
+  if (!ai || typeof ai.run !== "function") throw new WorkersAIError("Workers AI is not configured");
+  return ai;
+}
+async function runWorkersAIText(env, messages, opts = {}) {
+  const ai = requireAi(env);
+  const model = opts.model ?? WORKERS_AI_LLM_MODEL;
+  let result;
+  try {
+    result = await Promise.race([
+      ai.run(model, {
+        messages: messages.map((m) => ({ role: m.role, content: m.content })),
+        max_tokens: opts.maxTokens ?? 900,
+        temperature: opts.temperature ?? 0.7
+      }),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new WorkersAIError("Workers AI timed out")), WORKERS_AI_TEXT_TIMEOUT_MS)
+      )
+    ]);
+  } catch (err) {
+    throw err instanceof WorkersAIError ? err : new WorkersAIError(err instanceof Error ? err.message : "Workers AI request failed");
+  }
+  const response = result ?? {};
+  let text = response.response;
+  if (typeof text !== "string" || text.length === 0) {
+    text = response.choices?.[0]?.message?.content;
+  }
+  if (typeof text !== "string" || text.length === 0) {
+    throw new WorkersAIError("Workers AI returned no text");
+  }
+  return text;
+}
+async function* streamWorkersAIText(env, messages, opts = {}) {
+  const ai = requireAi(env);
+  const model = opts.model ?? WORKERS_AI_LLM_MODEL;
+  let body;
+  try {
+    body = await Promise.race([
+      ai.run(model, {
+        messages: messages.map((m) => ({ role: m.role, content: m.content })),
+        stream: true,
+        max_tokens: opts.maxTokens ?? 600,
+        temperature: opts.temperature ?? 0.7
+      }),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new WorkersAIError("Workers AI timed out")), WORKERS_AI_TEXT_TIMEOUT_MS)
+      )
+    ]);
+  } catch (err) {
+    throw err instanceof WorkersAIError ? err : new WorkersAIError(err instanceof Error ? err.message : "Workers AI request failed");
+  }
+  const stream = body;
+  const getReader = typeof stream === "object" && stream !== null && "getReader" in stream && typeof stream.getReader === "function" ? stream.getReader : void 0;
+  if (!getReader) throw new WorkersAIError("Workers AI stream was not readable");
+  const reader = getReader.call(stream);
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let newlineAt;
+      while ((newlineAt = buffer.indexOf("\n")) !== -1) {
+        let line = buffer.slice(0, newlineAt);
+        buffer = buffer.slice(newlineAt + 1);
+        if (line.endsWith("\r")) line = line.slice(0, -1);
+        if (line.startsWith(":") || line.trim() === "") continue;
+        if (!line.startsWith("data: ")) continue;
+        const payload = line.slice(6).trim();
+        if (payload === "[DONE]") return;
+        try {
+          const parsed = JSON.parse(payload);
+          if (typeof parsed.response === "string" && parsed.response.length > 0) yield parsed.response;
+        } catch {
+          buffer = `${line}
+${buffer}`;
+          break;
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+// src/providers/workers-ai/workers-ai.provider.ts
+var WORKERS_AI_TIERS = {
+  fast: "@cf/meta/llama-3.1-8b-instruct-fp8-fast",
+  balanced: WORKERS_AI_LLM_MODEL,
+  powerful: WORKERS_AI_LLM_MODEL
+};
+var WorkersAIProvider = class {
+  id = "workers-ai";
+  name = "Cloudflare Workers AI";
+  capabilities = ["text"];
+  binding;
+  tiers;
+  jsonParser = new JsonResponseParser();
+  constructor(config) {
+    this.binding = config.binding;
+    this.tiers = mergeTierOverrides(WORKERS_AI_TIERS, config.models);
+  }
+  resolveModel(tier) {
+    return resolveModel(this.tiers, tier, this.id);
+  }
+  async healthCheck() {
+    return typeof this.binding?.run === "function" ? "healthy" : "unavailable";
+  }
+  /** Workers AI is allocation-priced (neurons per deployment), not per
+   *  request — there is no per-call cost to estimate. */
+  async estimateCost(_request) {
+    return 0;
+  }
+  async generate(request) {
+    const model = request.model ?? this.resolveModel(request.tier ?? "balanced");
+    const messages = withSystemPrompt(request);
+    try {
+      const text = await runWorkersAIText(
+        { AI: this.binding },
+        messages,
+        {
+          model,
+          maxTokens: request.maxTokens,
+          temperature: request.temperature
+        }
+      );
+      return { text, model, providerId: this.id, finishReason: "stop" };
+    } catch (error) {
+      throw toAIError(error);
+    }
+  }
+  async generateStructured(request) {
+    const messages = [...request.messages];
+    const lastUserIndex = findLastIndex5(messages, (m) => m.role === "user");
+    if (lastUserIndex === -1) {
+      throw new AIError("UNKNOWN_ERROR" /* UNKNOWN_ERROR */, "generateStructured requires at least one user message");
+    }
+    messages[lastUserIndex] = {
+      role: "user",
+      content: new StructuredPromptBuilder(messages[lastUserIndex]?.content ?? "").withSchema(request.schema).build()
+    };
+    const result = await this.generate({ ...request, messages, temperature: 0.1 });
+    return { value: this.jsonParser.parse(result.text), result };
+  }
+  async stream(request, callbacks) {
+    const model = request.model ?? this.resolveModel(request.tier ?? "balanced");
+    const messages = withSystemPrompt(request);
+    let text = "";
+    try {
+      for await (const chunk of streamWorkersAIText({ AI: this.binding }, messages, {
+        model,
+        maxTokens: request.maxTokens,
+        temperature: request.temperature
+      })) {
+        text += chunk;
+        callbacks.onChunk?.(chunk);
+      }
+    } catch (error) {
+      const aiError = toAIError(error);
+      callbacks.onError?.(aiError);
+      throw aiError;
+    }
+    const result = { text, model, providerId: this.id, finishReason: "stop" };
+    callbacks.onComplete?.(result);
+    return result;
+  }
+};
+function withSystemPrompt(request) {
+  if (request.systemPrompt && request.systemPrompt.length > 0) {
+    return [
+      { role: "system", content: request.systemPrompt },
+      ...request.messages.filter((m) => m.role !== "system")
+    ];
+  }
+  return request.messages;
+}
+function toAIError(error) {
+  if (error instanceof AIError) return error;
+  const message = error instanceof Error ? error.message : "Workers AI request failed";
+  const type = error instanceof WorkersAIError && error.message.includes("not configured") ? "INVALID_API_KEY" /* INVALID_API_KEY */ : "SERVER_ERROR" /* SERVER_ERROR */;
+  return new AIError(type, message, error instanceof Error ? error : void 0);
+}
+function findLastIndex5(items, predicate) {
+  for (let i = items.length - 1; i >= 0; i--) {
+    const item = items[i];
+    if (item !== void 0 && predicate(item)) return i;
+  }
+  return -1;
+}
+function createWorkersAIProvider(config) {
+  return new WorkersAIProvider(config);
+}
+
+// src/providers/factory/create-ai.ts
+function createAI(config = {}) {
+  const factory = new ProviderFactory({
+    priority: config.priority,
+    fallbackEnabled: config.fallbackEnabled,
+    defaultTier: config.defaultTier
+  });
+  if (config.anthropic?.apiKey) {
+    factory.register(new AnthropicProvider(config.anthropic));
+  }
+  if (config.groq?.apiKey) {
+    factory.register(new GroqProvider(config.groq));
+  }
+  if (config.gemini?.apiKey) {
+    factory.register(new GeminiProvider({ ...config.gemini, enabled: true }));
+  }
+  if (config.fal?.apiKey) {
+    factory.register(new FalProvider({ ...config.fal, enabled: true }));
+  }
+  if (config.pruna?.apiKey) {
+    factory.register(new PrunaProvider({ ...config.pruna, enabled: true }));
+  }
+  const openaiCompatible = config.openaiCompatible;
+  if (openaiCompatible?.apiKey && (openaiCompatible.baseUrl || openaiCompatible.endpointUrl)) {
+    factory.register(
+      new OpenAiCompatibleProvider({ ...openaiCompatible, apiKey: openaiCompatible.apiKey })
+    );
+  }
+  if (config.workersAI?.binding) {
+    factory.register(new WorkersAIProvider(config.workersAI));
+  }
+  return factory;
+}
+
+// src/providers/groq/groq-messages.ts
+var createUserMessage = (content) => ({
+  role: "user",
+  content
+});
+var createAssistantMessage = (content) => ({
+  role: "assistant",
+  content
+});
+var createSystemMessage = (content) => ({
+  role: "system",
+  content
+});
+var createMessage = (role, content) => ({
+  role,
+  content
+});
+var promptToMessages = (prompt) => [
+  createUserMessage(prompt)
+];
+var extractTextFromMessages = (messages) => messages.map((m) => m.content).join("\n\n");
+var formatMessagesForDisplay = (messages) => messages.map((m) => `[${m.role.toUpperCase()}]: ${m.content}`).join("\n\n---\n\n");
+
+// src/providers/groq/groq-structured-json.ts
+async function requestStructuredJson(client, request) {
+  const chatRequest = {
+    model: request.model,
+    messages: [createUserMessage(request.instructions)],
+    temperature: request.temperature,
+    max_tokens: request.maxTokens,
+    response_format: { type: "json_object" },
+    ...request.reasoningEffort !== void 0 ? { reasoning_effort: request.reasoningEffort } : {}
+  };
+  const response = await client.postChatCompletion(chatRequest);
+  const content = response.choices[0]?.message?.content ?? "";
+  const candidate = extractJsonCandidate(content);
+  try {
+    return JSON.parse(candidate);
+  } catch (err) {
+    throw new GroqError(
+      "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+      "model response contained no parsable json object",
+      err instanceof Error ? err : void 0
+    );
+  }
+}
+
+// src/providers/groq/text-generation.service.ts
+var STRUCTURED_OUTPUT_TEMPERATURE = 0.1;
+var TextGenerationService = class {
+  constructor(httpClient, cache = new CacheManager(), defaultModel = DEFAULT_MODELS.TEXT) {
+    this.httpClient = httpClient;
+    this.cache = cache;
+    this.defaultModel = defaultModel;
+  }
+  httpClient;
+  cache;
+  defaultModel;
+  id = "groq-text-generation";
+  name = "Groq Text Generation";
+  capabilities = ["text"];
+  jsonParser = new JsonResponseParser();
+  generateCompletion(prompt, options = {}) {
+    const model = options.model ?? this.defaultModel;
+    return this.executeWithCache(
+      {
+        type: CACHE_KEY_TYPE_COMPLETION,
         model,
         prompt,
         config: options.generationConfig
@@ -5200,6 +5871,7 @@ var ChatService = class {
     if (messages.length === 0) return null;
     const last = messages[messages.length - 1];
     const first = messages[0];
+    if (!last || !first) return null;
     const companionId = String(first.metadata?.["companionId"] ?? "unknown");
     const companionName = String(first.metadata?.["companionName"] ?? "Unknown");
     return {
@@ -5343,6 +6015,211 @@ function resetProvider() {
   container = null;
 }
 
+// src/providers/workers-ai/workers-ai.speech.ts
+var WORKERS_AI_SPEECH_TIMEOUT_MS = 45e3;
+async function readAll(stream) {
+  const reader = stream.getReader();
+  const chunks = [];
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (value) chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const combined = new Uint8Array(chunks.reduce((acc, chunk) => acc + chunk.length, 0));
+  let offset = 0;
+  for (const chunk of chunks) {
+    combined.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return combined;
+}
+function base64ToBytes2(base64) {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i += 1) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+async function speakWithWorkersAI(env, engine, text) {
+  const ai = env.AI;
+  if (!ai || typeof ai.run !== "function") throw new WorkersAIError("Workers AI is not configured");
+  const input = engine.langParam ? { prompt: text, lang: engine.langParam } : { text };
+  let result;
+  try {
+    result = await Promise.race([
+      ai.run(engine.model, input),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new WorkersAIError("The speech engine timed out")), WORKERS_AI_SPEECH_TIMEOUT_MS)
+      )
+    ]);
+  } catch (err) {
+    throw err instanceof WorkersAIError ? err : new WorkersAIError(err instanceof Error ? err.message : "Workers AI speech request failed");
+  }
+  if (result instanceof ReadableStream) {
+    const bytes = await readAll(result);
+    if (bytes.length === 0) throw new WorkersAIError("The speech engine returned no audio");
+    return { bytes };
+  }
+  const audio = result ?? {};
+  if (typeof audio.audio === "string" && audio.audio.length > 0) {
+    return { bytes: base64ToBytes2(audio.audio) };
+  }
+  throw new WorkersAIError("The speech engine returned no audio");
+}
+
+// src/providers/fal/queue/fal-queue.entities.ts
+var FalQueueError = class extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.name = "FalQueueError";
+    this.status = status;
+  }
+};
+var FAL_ASPECT_IMAGE_SIZES = {
+  "1:1": "square_hd",
+  "16:9": "landscape_16_9",
+  "9:16": "portrait_16_9"
+};
+
+// src/providers/fal/queue/fal-queue.client.ts
+var FAL_QUEUE_BASE = "https://queue.fal.run";
+var FAL_SUBMIT_TIMEOUT_MS = 15e3;
+var FAL_POLL_TIMEOUT_MS = 1e4;
+function falQueueConfigured(env) {
+  return Boolean(env.FAL_KEY);
+}
+async function falFetch(env, url, timeoutMs, body) {
+  if (!falQueueConfigured(env)) throw new FalQueueError("fal.ai is not configured");
+  const request = async () => fetch(url, {
+    method: body !== void 0 ? "POST" : "GET",
+    headers: {
+      Authorization: `Key ${env.FAL_KEY}`,
+      ...body !== void 0 ? { "Content-Type": "application/json" } : {}
+    },
+    body: body !== void 0 ? JSON.stringify(body) : void 0,
+    signal: AbortSignal.timeout(timeoutMs)
+  });
+  let res;
+  try {
+    res = await request();
+    if (res.status >= 500) res = await request();
+  } catch (err) {
+    throw new FalQueueError(err instanceof Error ? err.message : "fal.ai request failed");
+  }
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new FalQueueError(`fal ${res.status}: ${text.slice(0, 200)}`, res.status);
+  }
+  return await res.json();
+}
+function createFalQueue(env) {
+  return {
+    async submit(model, input) {
+      const res = await falFetch(env, `${FAL_QUEUE_BASE}/${model}`, FAL_SUBMIT_TIMEOUT_MS, input);
+      return { requestId: res.request_id, statusUrl: res.status_url, responseUrl: res.response_url };
+    },
+    async checkStatus(statusUrl) {
+      const res = await falFetch(env, statusUrl, FAL_POLL_TIMEOUT_MS);
+      return {
+        status: res.status,
+        queuePosition: res.queue_position,
+        logs: res.logs?.map((l) => l.message ?? "").filter(Boolean)
+      };
+    },
+    fetchResult(responseUrl) {
+      return falFetch(env, responseUrl, FAL_POLL_TIMEOUT_MS);
+    }
+  };
+}
+
+// src/providers/fal/queue/fal-wire.ts
+function buildFalImageInput(model, input) {
+  const base = { prompt: input.prompt, num_images: input.numImages };
+  if (model.includes("flux")) {
+    const imageSize = input.aspectRatio ? FAL_ASPECT_IMAGE_SIZES[input.aspectRatio] : void 0;
+    if (imageSize) base.image_size = imageSize;
+  }
+  return base;
+}
+function parseFalImageOutput(raw) {
+  const obj = raw ?? {};
+  const entries = Array.isArray(obj.images) ? obj.images : obj.image && typeof obj.image === "object" ? [obj.image] : [];
+  const imageUrls = entries.map((e) => typeof e.url === "string" ? e.url : "").filter((url) => url.length > 0);
+  const first = entries.find((e) => typeof e.width === "number" || typeof e.height === "number");
+  return {
+    imageUrls,
+    ...typeof obj.seed === "number" ? { seed: obj.seed } : {},
+    ...typeof first?.width === "number" ? { width: first.width } : {},
+    ...typeof first?.height === "number" ? { height: first.height } : {}
+  };
+}
+function buildFalVideoInput(spec, input) {
+  const base = { prompt: input.prompt };
+  if (spec.durationFormat !== "none" && typeof input.durationSeconds === "number") {
+    base.duration = spec.durationFormat === "s-suffix" ? `${input.durationSeconds}s` : String(input.durationSeconds);
+  }
+  if (spec.aspectRatios && input.aspectRatio) base.aspect_ratio = input.aspectRatio;
+  if (spec.resolutions && input.resolution) base.resolution = input.resolution;
+  if (input.imageUrl) base.image_url = input.imageUrl;
+  if (spec.supportsNegativePrompt && input.negativePrompt) base.negative_prompt = input.negativePrompt;
+  if (spec.generateAudio) base.generate_audio = true;
+  return base;
+}
+function parseFalVideoOutput(raw) {
+  const obj = raw ?? {};
+  const video = obj.video && typeof obj.video === "object" ? obj.video : void 0;
+  if (!video || typeof video.url !== "string" || video.url.length === 0) return null;
+  return {
+    videoUrl: video.url,
+    ...typeof video.content_type === "string" ? { contentType: video.content_type } : {},
+    ...typeof video.file_size === "number" ? { fileSize: video.file_size } : {}
+  };
+}
+function buildFalTagPrompt(prompt) {
+  return prompt.toLowerCase().split(/[,\s]+/).filter((word) => word.length > 3).slice(0, 5).join(", ");
+}
+function buildFalAudioLyrics(input) {
+  if (input.instrumental) return "[inst]";
+  const lyrics = input.lyrics?.trim();
+  if (!lyrics) return void 0;
+  if (lyrics.includes("[verse]") || lyrics.includes("[chorus]")) return lyrics;
+  return `[verse]
+${lyrics}
+[/verse]`;
+}
+function buildFalAudioInput(spec, input) {
+  const tags = buildFalTagPrompt(input.prompt);
+  const base = { prompt: tags, duration: input.durationSeconds };
+  if (spec.supportsLyrics) {
+    const lyrics = buildFalAudioLyrics(input);
+    if (lyrics) base.lyrics = lyrics;
+  }
+  if (spec.supportsInstrumental && input.instrumental !== void 0) {
+    base.instrumental = input.instrumental;
+  }
+  return base;
+}
+function parseFalAudioOutput(raw) {
+  const obj = raw ?? {};
+  const nested = (key) => {
+    const value = obj[key];
+    if (!value || typeof value !== "object") return void 0;
+    const url = value.url;
+    return typeof url === "string" && url.length > 0 ? url : void 0;
+  };
+  const flat = (key) => {
+    const value = obj[key];
+    return typeof value === "string" && value.length > 0 ? value : void 0;
+  };
+  const audioUrl = nested("audio_url") ?? nested("audio_file") ?? nested("audio") ?? flat("audio_url") ?? flat("audio");
+  if (!audioUrl) return null;
+  return { audioUrl };
+}
+
 // src/providers/embeddings/openai-embeddings.ts
 var DEFAULT_EMBED_TIMEOUT_MS = 6e4;
 function createOpenAiEmbeddingsAdapter(config) {
@@ -5530,150 +6407,6 @@ function createOpenAiImageAdapter(config) {
   };
 }
 
-// src/providers/adapters/openai-compatible.adapter.ts
-function toWireMessage(message) {
-  if (message.role === "tool") {
-    return { role: "tool", content: message.content, tool_call_id: message.toolCallId ?? "" };
-  }
-  if (message.role === "assistant" && message.toolCalls && message.toolCalls.length > 0) {
-    return {
-      role: "assistant",
-      content: message.content,
-      tool_calls: message.toolCalls.map((call) => ({
-        id: call.id,
-        type: "function",
-        function: { name: call.name, arguments: call.arguments }
-      }))
-    };
-  }
-  if (message.role === "user") return { role: "user", content: message.content };
-  return { role: message.role, content: message.content };
-}
-function mergeImages(messages, images) {
-  if (images.length === 0) return [...messages];
-  const parts = images.map((image) => ({
-    type: "image_url",
-    image_url: { url: `data:${image.mimeType};base64,${image.dataBase64}` }
-  }));
-  for (let index = messages.length - 1; index >= 0; index -= 1) {
-    const message = messages[index];
-    if (message.role !== "user") continue;
-    const textParts = typeof message.content === "string" ? message.content.length > 0 ? [{ type: "text", text: message.content }] : [] : message.content;
-    return [
-      ...messages.slice(0, index),
-      { role: "user", content: [...textParts, ...parts] },
-      ...messages.slice(index + 1)
-    ];
-  }
-  return [...messages, { role: "user", content: [...parts] }];
-}
-async function extractErrorDetail(response) {
-  try {
-    const body = await response.json();
-    return body.error;
-  } catch {
-    return void 0;
-  }
-}
-async function* parseSseEvent2(rawEvent, toolCallAccumulator) {
-  for (const line of rawEvent.split("\n")) {
-    if (!line.startsWith("data:")) continue;
-    const payload = line.slice(5).trim();
-    if (payload.length === 0 || payload === "[DONE]") continue;
-    let chunk;
-    try {
-      chunk = JSON.parse(payload);
-    } catch {
-      continue;
-    }
-    const delta = chunk.choices?.[0]?.delta;
-    if (delta?.reasoning) {
-      yield { type: "delta", channel: "reasoning", text: delta.reasoning };
-    }
-    if (delta?.content) {
-      yield { type: "delta", channel: "answer", text: delta.content };
-    }
-    if (delta?.tool_calls) {
-      for (const toolCallDelta of delta.tool_calls) toolCallAccumulator.push(toolCallDelta);
-    }
-    if (chunk.usage) {
-      yield {
-        type: "usage",
-        usage: {
-          inputTokens: chunk.usage.prompt_tokens ?? 0,
-          outputTokens: chunk.usage.completion_tokens ?? 0,
-          reasoningTokens: chunk.usage.completion_tokens_details?.reasoning_tokens
-        }
-      };
-    }
-  }
-}
-async function* parseSseStream(body) {
-  const reader = body.getReader();
-  const decoder = new TextDecoder();
-  const toolCallAccumulator = new ToolCallAccumulator();
-  let buffer = "";
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      let separator = buffer.indexOf("\n\n");
-      while (separator !== -1) {
-        const rawEvent = buffer.slice(0, separator);
-        buffer = buffer.slice(separator + 2);
-        separator = buffer.indexOf("\n\n");
-        yield* parseSseEvent2(rawEvent, toolCallAccumulator);
-      }
-    }
-  } catch (err) {
-    throw errorFromUnknown(err);
-  } finally {
-    reader.releaseLock();
-  }
-  const calls = toolCallAccumulator.finish();
-  if (calls.length > 0) yield { type: "tool_calls", calls };
-}
-function createOpenAiCompatibleAdapter(config) {
-  return {
-    async *stream(req) {
-      const timeout = AbortSignal.timeout(config.timeoutMs);
-      const signal = req.signal ? AbortSignal.any([req.signal, timeout]) : timeout;
-      let response;
-      try {
-        response = await fetch(`${config.baseUrl}/chat/completions`, {
-          method: "POST",
-          headers: {
-            Authorization: `Bearer ${config.apiKey}`,
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({
-            model: req.externalModelId,
-            messages: mergeImages(req.messages.map(toWireMessage), req.images ?? []),
-            temperature: req.temperature,
-            max_completion_tokens: req.maxOutputTokens,
-            top_p: req.topP,
-            stream: true,
-            stream_options: { include_usage: true },
-            ...req.tools && req.tools.length > 0 ? {
-              tools: req.tools.map((tool) => ({ type: "function", function: tool })),
-              tool_choice: "auto"
-            } : {}
-          }),
-          signal
-        });
-      } catch (err) {
-        throw errorFromUnknown(err);
-      }
-      if (!response.ok || !response.body) {
-        const detail = await extractErrorDetail(response);
-        throw errorFromStatus(response.status, detail?.message, detail);
-      }
-      yield* parseSseStream(response.body);
-    }
-  };
-}
-
 // src/providers/adapters/anthropic.adapter.ts
 var ANTHROPIC_VERSION = "2023-06-01";
 var ERROR_TYPE_TO_CODE = {
@@ -5694,7 +6427,7 @@ function mergeImages2(messages, images) {
   }));
   for (let index = messages.length - 1; index >= 0; index -= 1) {
     const message = messages[index];
-    if (message.role !== "user") continue;
+    if (!message || message.role !== "user") continue;
     const textBlocks = typeof message.content === "string" ? message.content.length > 0 ? [{ type: "text", text: message.content }] : [] : message.content;
     return [
       ...messages.slice(0, index),
@@ -5810,7 +6543,7 @@ function createAnthropicAdapter(config) {
             model: req.externalModelId,
             messages,
             ...system.length > 0 ? { system } : {},
-            max_tokens: req.maxOutputTokens,
+            max_tokens: req.maxOutputTokens ?? 4096,
             stream: true
           }),
           signal
@@ -5827,6 +6560,170 @@ function createAnthropicAdapter(config) {
   };
 }
 
+// src/providers/adapters/adapter-resolver.ts
+var ADAPTER_TIMEOUT_MS = 6e4;
+var ADAPTER_MEDIA_TIMEOUT_MS = 12e4;
+function resolveApiKey(env, apiKeyEnv) {
+  const value = env[apiKeyEnv];
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new AiError("missing_key");
+  }
+  return value.trim();
+}
+function apiKeyAvailable(env, apiKeyEnv) {
+  try {
+    resolveApiKey(env, apiKeyEnv);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function normalizeBaseUrl(url) {
+  return url.replace(/\/$/, "");
+}
+function openAiApiKey(binding, capability) {
+  if (binding.adapter !== "openai-compatible") {
+    throw new AiError(
+      "model_unavailable",
+      `Adapter kind does not support ${capability}: ${binding.adapter}`
+    );
+  }
+  return binding.apiKey;
+}
+function chatAdapterFor(binding, timing = {}) {
+  const timeoutMs = timing.timeoutMs ?? ADAPTER_TIMEOUT_MS;
+  if (binding.adapter === "openai-compatible") {
+    return createOpenAiCompatibleAdapter({
+      baseUrl: normalizeBaseUrl(binding.baseUrl),
+      apiKey: binding.apiKey,
+      timeoutMs
+    });
+  }
+  if (binding.adapter === "anthropic") {
+    return createAnthropicAdapter({
+      baseUrl: normalizeBaseUrl(binding.baseUrl),
+      apiKey: binding.apiKey,
+      timeoutMs
+    });
+  }
+  throw new AiError("model_unavailable", `Unsupported adapter kind: ${binding.adapter}`);
+}
+function imageAdapterFor(binding, timing = {}) {
+  return createOpenAiImageAdapter({
+    baseUrl: normalizeBaseUrl(binding.baseUrl),
+    apiKey: openAiApiKey(binding, "images"),
+    timeoutMs: timing.mediaTimeoutMs ?? ADAPTER_MEDIA_TIMEOUT_MS
+  });
+}
+function embeddingsAdapterFor(binding, timing = {}) {
+  return createOpenAiEmbeddingsAdapter({
+    baseUrl: normalizeBaseUrl(binding.baseUrl),
+    apiKey: openAiApiKey(binding, "embeddings"),
+    timeoutMs: timing.timeoutMs ?? ADAPTER_TIMEOUT_MS
+  });
+}
+function audioTranscriptionAdapterFor(binding, timing = {}) {
+  return createOpenAiAudioTranscriptionAdapter({
+    baseUrl: normalizeBaseUrl(binding.baseUrl),
+    apiKey: openAiApiKey(binding, "audio transcription"),
+    timeoutMs: timing.timeoutMs ?? ADAPTER_TIMEOUT_MS
+  });
+}
+function speechAdapterFor(binding, timing = {}) {
+  return createOpenAiSpeechAdapter({
+    baseUrl: normalizeBaseUrl(binding.baseUrl),
+    apiKey: openAiApiKey(binding, "speech synthesis"),
+    timeoutMs: timing.mediaTimeoutMs ?? ADAPTER_MEDIA_TIMEOUT_MS
+  });
+}
+function createAdapterResolver(env, timing = {}) {
+  const toProviderBinding = (binding) => ({
+    adapter: binding.adapter,
+    baseUrl: binding.baseUrl,
+    apiKey: resolveApiKey(env, binding.apiKeyEnv)
+  });
+  return {
+    chat: (binding) => chatAdapterFor(toProviderBinding(binding), timing),
+    image: (binding) => imageAdapterFor(toProviderBinding(binding), timing),
+    embeddings: (binding) => embeddingsAdapterFor(toProviderBinding(binding), timing),
+    audioTranscription: (binding) => audioTranscriptionAdapterFor(toProviderBinding(binding), timing),
+    speech: (binding) => speechAdapterFor(toProviderBinding(binding), timing),
+    available: (binding) => apiKeyAvailable(env, binding.apiKeyEnv)
+  };
+}
+
+// src/providers/execution/run-conversation.ts
+async function* runConversation(input) {
+  const tools = input.tools && input.tools.length > 0 ? { tools: input.tools } : {};
+  const images = input.images && input.images.length > 0 ? { images: input.images } : {};
+  for (const [index, attempt] of input.attempts.entries()) {
+    let answer = "";
+    let reasoning = "";
+    let usage = null;
+    let toolCalls = [];
+    const startedAt = Date.now();
+    const context = buildContext(input.history, input.systemPrompt, {
+      contextWindow: attempt.model.contextWindow,
+      // No explicit output reservation → keep the whole window for input.
+      maxOutputTokens: attempt.settings.maxOutputTokens ?? 0
+    });
+    yield { type: "attempt", index };
+    try {
+      for await (const event of attempt.adapter.stream({
+        externalModelId: attempt.model.externalModelId,
+        messages: context,
+        temperature: attempt.settings.temperature,
+        maxOutputTokens: attempt.settings.maxOutputTokens,
+        topP: attempt.settings.topP,
+        ...tools,
+        ...images,
+        signal: input.signal
+      })) {
+        if (event.type === "delta") {
+          if (event.channel === "reasoning") reasoning += event.text;
+          else answer += event.text;
+          yield { type: "delta", channel: event.channel, text: event.text };
+        } else if (event.type === "tool_calls") {
+          toolCalls = [...event.calls];
+        } else {
+          usage = event.usage;
+        }
+      }
+    } catch (err) {
+      const result2 = {
+        answer,
+        reasoning,
+        usage,
+        toolCalls,
+        durationMs: Date.now() - startedAt
+      };
+      if (input.signal?.aborted === true) {
+        yield { type: "stopped", result: result2 };
+        return;
+      }
+      if (index + 1 < input.attempts.length && canFailover(err, answer.length + reasoning.length)) {
+        continue;
+      }
+      const aiError = err instanceof AiError ? err : errorFromUnknown(err);
+      yield { type: "failed", code: aiError.code, message: aiError.userMessage, result: result2 };
+      return;
+    }
+    const result = {
+      answer,
+      reasoning,
+      usage,
+      toolCalls,
+      durationMs: Date.now() - startedAt
+    };
+    if (toolCalls.length > 0 && input.tools && input.tools.length > 0) {
+      yield { type: "tool_calls", result };
+      return;
+    }
+    yield { type: "done", result };
+    return;
+  }
+}
+
 // src/content/domain/calculations/ContentCreditCost.ts
 var CREDIT_COSTS = {
   "text-to-image": { standard: 1, hd: 2, "4k": 4 },
@@ -6461,7 +7358,7 @@ async function batchRequest(requests, options = {}) {
         errors.push(result.reason);
         if (stopOnError) {
           throw new Error(
-            `Batch request failed: ${errors[0].message}`
+            `Batch request failed: ${errors[0]?.message}`
           );
         }
       }
@@ -6923,7 +7820,7 @@ function safeJSONParse(text, fallback, onError) {
     }
     if (error instanceof SyntaxError) {
       const positionMatch = error.message.match(/position (\d+)/);
-      const position = positionMatch ? parseInt(positionMatch[1], 10) : -1;
+      const position = positionMatch ? parseInt(positionMatch[1] ?? "", 10) : -1;
       if (position > 0) {
         const context = text.substring(Math.max(0, position - 50), position + 50);
         onError?.(`JSON parse error at position ${position}: "${context}"`);
@@ -7422,9 +8319,12 @@ function buildVideoRequest(data) {
 }
 
 exports.ABTestService = ABTestService;
+exports.ADAPTER_MEDIA_TIMEOUT_MS = ADAPTER_MEDIA_TIMEOUT_MS;
+exports.ADAPTER_TIMEOUT_MS = ADAPTER_TIMEOUT_MS;
 exports.AIContentService = AIContentService;
 exports.AIError = AIError;
 exports.AIErrorType = AIErrorType;
+exports.AI_ERROR_STATUS = AI_ERROR_STATUS;
 exports.ANTHROPIC_API_VERSION = ANTHROPIC_API_VERSION;
 exports.ANTHROPIC_DEFAULT_MAX_TOKENS = ANTHROPIC_DEFAULT_MAX_TOKENS;
 exports.ANTHROPIC_MODELS = ANTHROPIC_MODELS;
@@ -7470,7 +8370,9 @@ exports.DEFAULT_RETRY_MAX_DELAY_MS = DEFAULT_RETRY_MAX_DELAY_MS;
 exports.DEFAULT_TASK_POLICIES = DEFAULT_TASK_POLICIES;
 exports.DebounceManager = DebounceManager;
 exports.DedupeExecutor = DedupeExecutor;
+exports.FAL_ASPECT_IMAGE_SIZES = FAL_ASPECT_IMAGE_SIZES;
 exports.FalProvider = FalProvider;
+exports.FalQueueError = FalQueueError;
 exports.GEMINI_TIERS = GEMINI_TIERS;
 exports.GENERATION_BOUNDS = GENERATION_BOUNDS;
 exports.GENERATION_COSTS = CREDIT_COSTS;
@@ -7501,6 +8403,7 @@ exports.MEMORY_TOTAL_LIMIT = MEMORY_TOTAL_LIMIT;
 exports.MICROS_PER_UNIT = MICROS_PER_UNIT;
 exports.MOTION_OPTIONS = MOTION_OPTIONS;
 exports.MediaGenerationService = MediaGenerationService;
+exports.OpenAiCompatibleProvider = OpenAiCompatibleProvider;
 exports.PromptBuilder = PromptBuilder;
 exports.ProviderError = ProviderError;
 exports.ProviderFactory = ProviderFactory;
@@ -7549,21 +8452,34 @@ exports.VIDEO_QUALITY_VALUES = VIDEO_QUALITY_VALUES;
 exports.VIDEO_WIZARD_STEPS = VIDEO_WIZARD_STEPS;
 exports.ValidationError = ValidationError2;
 exports.VideoScriptService = VideoScriptService;
+exports.WORKERS_AI_LLM_MODEL = WORKERS_AI_LLM_MODEL;
+exports.WORKERS_AI_TIERS = WORKERS_AI_TIERS;
+exports.WorkersAIError = WorkersAIError;
+exports.WorkersAIProvider = WorkersAIProvider;
 exports.accumulateReport = accumulateReport;
 exports.aiErrorMessage = aiErrorMessage;
+exports.aiErrorStatus = aiErrorStatus;
+exports.apiKeyAvailable = apiKeyAvailable;
 exports.asObjectArray = asObjectArray;
 exports.asRecord = asRecord;
 exports.asStringArray = asStringArray;
 exports.asTrimmedOptionalString = asTrimmedOptionalString;
+exports.audioTranscriptionAdapterFor = audioTranscriptionAdapterFor;
 exports.batchEmbed = batchEmbed;
 exports.batchRequest = batchRequest;
 exports.buildCacheKey = buildCacheKey;
 exports.buildContentRequest = buildContentRequest;
 exports.buildContext = buildContext;
+exports.buildFalAudioInput = buildFalAudioInput;
+exports.buildFalAudioLyrics = buildFalAudioLyrics;
+exports.buildFalImageInput = buildFalImageInput;
+exports.buildFalTagPrompt = buildFalTagPrompt;
+exports.buildFalVideoInput = buildFalVideoInput;
 exports.buildHttpStatusFallback = buildHttpStatusFallback;
 exports.buildImageRequest = buildImageRequest;
 exports.buildResearchMessages = buildResearchMessages;
 exports.buildSystemPrompt = buildSystemPrompt;
+exports.buildUsageDailySeries = buildUsageDailySeries;
 exports.buildUsageData = buildUsageData;
 exports.buildVideoRequest = buildVideoRequest;
 exports.cacheManager = cacheManager;
@@ -7574,6 +8490,7 @@ exports.calculateTrailingDelay = calculateTrailingDelay;
 exports.canFailover = canFailover;
 exports.canStartTask = canStartTask;
 exports.capText = capText;
+exports.chatAdapterFor = chatAdapterFor;
 exports.chatIdGenerator = chatIdGenerator;
 exports.chunkText = chunkText;
 exports.clampScore = clampScore;
@@ -7585,22 +8502,27 @@ exports.consumeGroqStream = consumeGroqStream;
 exports.cosineSimilarity = cosineSimilarity;
 exports.countChanges = countChanges;
 exports.createAI = createAI;
+exports.createAdapterResolver = createAdapterResolver;
 exports.createAnthropicAdapter = createAnthropicAdapter;
 exports.createAssistantMessage = createAssistantMessage;
 exports.createFalProvider = createFalProvider;
+exports.createFalQueue = createFalQueue;
 exports.createGeminiProvider = createGeminiProvider;
 exports.createGroqProvider = createGroqProvider;
 exports.createMessage = createMessage;
 exports.createOpenAiAudioTranscriptionAdapter = createOpenAiAudioTranscriptionAdapter;
 exports.createOpenAiCompatibleAdapter = createOpenAiCompatibleAdapter;
+exports.createOpenAiCompatibleProvider = createOpenAiCompatibleProvider;
 exports.createOpenAiEmbeddingsAdapter = createOpenAiEmbeddingsAdapter;
 exports.createOpenAiImageAdapter = createOpenAiImageAdapter;
 exports.createOpenAiSpeechAdapter = createOpenAiSpeechAdapter;
 exports.createProviderFactory = createProviderFactory;
 exports.createPrunaProvider = createPrunaProvider;
+exports.createRemoteChatClient = createRemoteChatClient;
 exports.createSseResponse = createSseResponse;
 exports.createSystemMessage = createSystemMessage;
 exports.createUserMessage = createUserMessage;
+exports.createWorkersAIProvider = createWorkersAIProvider;
 exports.debounce = debounce;
 exports.debounceManager = debounceManager;
 exports.defaultEffortForModel = defaultEffortForModel;
@@ -7609,8 +8531,10 @@ exports.deriveSnippetTitle = deriveSnippetTitle;
 exports.describeAIErrorType = describeAIErrorType;
 exports.diffLines = diffLines;
 exports.dotProduct = dotProduct;
+exports.embeddingsAdapterFor = embeddingsAdapterFor;
 exports.errorFromStatus = errorFromStatus;
 exports.errorFromUnknown = errorFromUnknown;
+exports.errorRatePct = errorRatePct;
 exports.estimateMessageTokens = estimateMessageTokens;
 exports.estimateTokens = estimateTokens;
 exports.extractContentFromSsePayload = extractContentFromSsePayload;
@@ -7626,6 +8550,7 @@ exports.extractText = extractText;
 exports.extractTextFromMessages = extractTextFromMessages;
 exports.extractTokenUsage = extractTokenUsage;
 exports.failoverCandidate = failoverCandidate;
+exports.falQueueConfigured = falQueueConfigured;
 exports.findTopKSimilar = findTopKSimilar;
 exports.formatCost = formatCost;
 exports.formatErrorForLogging = formatErrorForLogging;
@@ -7638,6 +8563,7 @@ exports.generateWithPruna = generateWithPruna;
 exports.getDimensionsForAspectRatio = getDimensionsForAspectRatio;
 exports.getProvider = getProvider;
 exports.getRecommendedQuality = getRecommendedQuality;
+exports.imageAdapterFor = imageAdapterFor;
 exports.isAuthErrorType = isAuthErrorType;
 exports.isMediaProvider = isMediaProvider;
 exports.isRetryableErrorType = isRetryableErrorType;
@@ -7660,6 +8586,9 @@ exports.normalizeSources = normalizeSources;
 exports.normalizeSseChunk = normalizeSseChunk;
 exports.oneOfCatalog = oneOfCatalog;
 exports.parseAIResponse = parseAIResponse;
+exports.parseFalAudioOutput = parseFalAudioOutput;
+exports.parseFalImageOutput = parseFalImageOutput;
+exports.parseFalVideoOutput = parseFalVideoOutput;
 exports.parseSseEvent = parseSseEvent;
 exports.planTaskFailure = planTaskFailure;
 exports.pollForResult = pollForResult;
@@ -7671,25 +8600,34 @@ exports.requestDeduplicator = requestDeduplicator;
 exports.requestQueue = requestQueue;
 exports.requestStructuredJson = requestStructuredJson;
 exports.resetProvider = resetProvider;
+exports.resolveApiKey = resolveApiKey;
 exports.resolveModel = resolveModel;
 exports.resolveUserFriendlyErrorMessage = resolveUserFriendlyErrorMessage;
 exports.resolveUserFriendlyMessage = resolveUserFriendlyMessage;
 exports.retryManager = retryManager;
+exports.runConversation = runConversation;
+exports.runWorkersAIText = runWorkersAIText;
 exports.safeJSONParse = safeJSONParse;
 exports.searchWeb = searchWeb;
 exports.selectLeastRecentlyUsedKey = selectLeastRecentlyUsedKey;
 exports.selectMemories = selectMemories;
 exports.shouldCallOnLeadingEdge = shouldCallOnLeadingEdge;
+exports.speakWithWorkersAI = speakWithWorkersAI;
+exports.speechAdapterFor = speechAdapterFor;
 exports.splitMarkdown = splitMarkdown;
 exports.splitSseLines = splitSseLines;
 exports.sseStreamResponse = sseStreamResponse;
+exports.streamWorkersAIText = streamWorkersAIText;
 exports.submitPrediction = submitPrediction;
 exports.throttle = throttle;
 exports.throttleManager = throttleManager;
 exports.toGroqMessages = toGroqMessages;
 exports.uploadImage = uploadImage;
+exports.usageTrendOf = usageTrendOf;
+exports.usageWindowTotals = usageWindowTotals;
 exports.validateApiKey = validateApiKey;
 exports.validateToolArgs = validateToolArgs;
 exports.withRetry = withRetry;
+exports.workersAIConfigured = workersAIConfigured;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map