@umituz/web-ai 1.0.11 → 1.2.0

package/dist/providers/index.cjs

@@ -1110,7 +1110,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();
@@ -1190,7 +1190,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;
 }
@@ -1513,6 +1514,26 @@ function validateApiKey(apiKey, rule = DEFAULT_API_KEY_RULE) {
   return { valid: true };
 }
 
+// src/core/utils/failover.ts
+var TRANSIENT_ERROR_CODES = /* @__PURE__ */ new Set([
+  "capacity",
+  "rate_limited",
+  "timeout",
+  "network"
+]);
+function isTransientError(err) {
+  if (!err || typeof err !== "object") return false;
+  const candidate = err;
+  if (candidate.code && TRANSIENT_ERROR_CODES.has(candidate.code)) return true;
+  if (candidate.type && TRANSIENT_ERROR_CODES.has(candidate.type)) return true;
+  if (candidate.status === 429 || candidate.status === 503 || candidate.status === 504) return true;
+  return false;
+}
+function canFailover(err, streamedChars) {
+  if (!isTransientError(err)) return false;
+  return streamedChars === 0;
+}
+
 // src/providers/groq/groq.constants.ts
 var GROQ_MODELS = {
   LLAMA_3_1_8B_INSTANT: "llama-3.1-8b-instant",
@@ -2066,7 +2087,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();
@@ -2163,7 +2184,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;
 }
@@ -2313,7 +2335,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 };
@@ -2419,7 +2441,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;
 }
@@ -3515,190 +3538,748 @@ 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/core/sse/tool-call-accumulator.ts
+var ToolCallAccumulator = class {
+  slots = /* @__PURE__ */ new Map();
+  push(delta) {
+    const index = delta.index ?? 0;
+    const slot = this.slots.get(index) ?? { id: "", name: "", args: "" };
+    if (delta.id) slot.id = delta.id;
+    if (delta.function?.name) slot.name = delta.function.name;
+    if (delta.function?.arguments) slot.args += delta.function.arguments;
+    this.slots.set(index, slot);
   }
-  if (config.groq?.apiKey) {
-    factory.register(new GroqProvider(config.groq));
+  finish() {
+    return Array.from(this.slots.entries()).sort(([a], [b]) => a - b).map(([, slot]) => ({
+      id: slot.id,
+      name: slot.name,
+      arguments: slot.args
+    })).filter((call) => call.id.length > 0 || call.name.length > 0);
   }
-  if (config.gemini?.apiKey) {
-    factory.register(new GeminiProvider({ ...config.gemini, enabled: true }));
+};
+
+// 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.fal?.apiKey) {
-    factory.register(new FalProvider({ ...config.fal, enabled: true }));
+  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.pruna?.apiKey) {
-    factory.register(new PrunaProvider({ ...config.pruna, 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)
+    ];
   }
-  return factory;
+  return [...messages, { role: "user", content: [...parts] }];
 }
-
-// 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 extractErrorDetail(response) {
   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
-    );
+    const body = await response.json();
+    return body.error;
+  } catch {
+    return 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
-      },
-      async () => {
-        const request = GroqChatRequestBuilder.for(model).withMessages([createUserMessage(prompt)]).withConfig(options.generationConfig).build();
-        const response = await this.httpClient.postChatCompletion(request);
-        return this.extractContent(response.choices[0]?.message?.content);
-      }
-    );
-  }
-  generateChatCompletion(messages, options = {}) {
-    const model = options.model ?? this.defaultModel;
-    return this.executeWithCache(
-      {
-        type: CACHE_KEY_TYPE_CHAT,
-        model,
-        messages: [...messages],
-        config: options.generationConfig
-      },
-      async () => {
-        const request = GroqChatRequestBuilder.for(model).withMessages(messages).withConfig(options.generationConfig).build();
-        const response = await this.httpClient.postChatCompletion(request);
-        return this.extractContent(response.choices[0]?.message?.content);
-      }
-    );
-  }
-  generateStructured(promptOrRequest, options) {
-    if (typeof promptOrRequest === "string") {
-      const model2 = options?.model ?? this.defaultModel;
-      const jsonPrompt = StructuredPromptBuilder.for(promptOrRequest).withSchema(options?.schema).build();
-      const request = GroqChatRequestBuilder.for(model2).withMessages([createUserMessage(jsonPrompt)]).withConfig({
-        ...options?.generationConfig,
-        temperature: STRUCTURED_OUTPUT_TEMPERATURE
-      }).build();
-      return this.httpClient.postChatCompletion(request).then((response) => {
-        const content = this.extractContent(response.choices[0]?.message?.content);
-        return this.jsonParser.parse(content);
-      });
+async function* parseSseEvent(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 req = promptOrRequest;
-    const model = req.model ?? (req.tier ? this.resolveModel(req.tier) : this.defaultModel);
-    const schemaObj = req.schema;
-    const messages = [];
-    if (req.systemPrompt) {
-      messages.push({ role: "system", content: req.systemPrompt });
+    const delta = chunk.choices?.[0]?.delta;
+    if (delta?.reasoning) {
+      yield { type: "delta", channel: "reasoning", text: delta.reasoning };
     }
-    for (const m of req.messages) {
-      messages.push({ role: m.role, content: m.content });
+    if (delta?.content) {
+      yield { type: "delta", channel: "answer", text: delta.content };
     }
-    const lastMsg = messages[messages.length - 1];
-    if (lastMsg) {
-      const structuredPrompt = StructuredPromptBuilder.for(lastMsg.content).withSchema(schemaObj).build();
-      messages[messages.length - 1] = { ...lastMsg, content: structuredPrompt };
+    if (delta?.tool_calls) {
+      for (const toolCallDelta of delta.tool_calls) toolCallAccumulator.push(toolCallDelta);
     }
-    const groqReq = GroqChatRequestBuilder.for(model).withMessages(messages).withConfig({
-      temperature: req.temperature ?? STRUCTURED_OUTPUT_TEMPERATURE,
-      maxTokens: req.maxTokens
-    }).build();
-    return this.httpClient.postChatCompletion(groqReq).then((response) => {
-      const content = this.extractContent(response.choices[0]?.message?.content);
-      const parsed = this.jsonParser.parse(content);
-      const genResult = {
-        text: content,
-        model: response.model,
-        providerId: this.id,
-        finishReason: response.choices[0]?.finish_reason ?? "stop",
-        usage: response.usage ? {
-          inputTokens: response.usage.prompt_tokens,
-          outputTokens: response.usage.completion_tokens,
-          totalTokens: response.usage.total_tokens
-        } : void 0
+    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 { value: parsed, result: genResult };
-    });
-  }
-  streamCompletion(prompt, callbacks, options = {}) {
-    return this.streamChatCompletion([createUserMessage(prompt)], callbacks, options);
+    }
   }
-  async streamChatCompletion(messages, callbacks, options = {}) {
-    const model = options.model ?? this.defaultModel;
-    const request = GroqChatRequestBuilder.for(model).withMessages(messages).withConfig(options.generationConfig).withStream(true).build();
-    const parser = new StreamingResponseParser(
-      {
-        onChunk: (chunk) => callbacks.onChunk?.(chunk)
-      },
-      extractContentFromSsePayload
-    );
-    try {
-      const stream = await this.httpClient.streamChatCompletion(request, {
-        signal: options.signal
-      });
+}
+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* parseSseEvent(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) {
+  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/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
+    );
+  }
+  config;
+  id = "openai-compatible";
+  name = "OpenAI-compatible";
+  capabilities = ["text"];
+  adapter;
+  tiers;
+  jsonParser = new JsonResponseParser();
+  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
+      },
+      async () => {
+        const request = GroqChatRequestBuilder.for(model).withMessages([createUserMessage(prompt)]).withConfig(options.generationConfig).build();
+        const response = await this.httpClient.postChatCompletion(request);
+        return this.extractContent(response.choices[0]?.message?.content);
+      }
+    );
+  }
+  generateChatCompletion(messages, options = {}) {
+    const model = options.model ?? this.defaultModel;
+    return this.executeWithCache(
+      {
+        type: CACHE_KEY_TYPE_CHAT,
+        model,
+        messages: [...messages],
+        config: options.generationConfig
+      },
+      async () => {
+        const request = GroqChatRequestBuilder.for(model).withMessages(messages).withConfig(options.generationConfig).build();
+        const response = await this.httpClient.postChatCompletion(request);
+        return this.extractContent(response.choices[0]?.message?.content);
+      }
+    );
+  }
+  generateStructured(promptOrRequest, options) {
+    if (typeof promptOrRequest === "string") {
+      const model2 = options?.model ?? this.defaultModel;
+      const jsonPrompt = StructuredPromptBuilder.for(promptOrRequest).withSchema(options?.schema).build();
+      const request = GroqChatRequestBuilder.for(model2).withMessages([createUserMessage(jsonPrompt)]).withConfig({
+        ...options?.generationConfig,
+        temperature: STRUCTURED_OUTPUT_TEMPERATURE
+      }).build();
+      return this.httpClient.postChatCompletion(request).then((response) => {
+        const content = this.extractContent(response.choices[0]?.message?.content);
+        return this.jsonParser.parse(content);
+      });
+    }
+    const req = promptOrRequest;
+    const model = req.model ?? (req.tier ? this.resolveModel(req.tier) : this.defaultModel);
+    const schemaObj = req.schema;
+    const messages = [];
+    if (req.systemPrompt) {
+      messages.push({ role: "system", content: req.systemPrompt });
+    }
+    for (const m of req.messages) {
+      messages.push({ role: m.role, content: m.content });
+    }
+    const lastMsg = messages[messages.length - 1];
+    if (lastMsg) {
+      const structuredPrompt = StructuredPromptBuilder.for(lastMsg.content).withSchema(schemaObj).build();
+      messages[messages.length - 1] = { ...lastMsg, content: structuredPrompt };
+    }
+    const groqReq = GroqChatRequestBuilder.for(model).withMessages(messages).withConfig({
+      temperature: req.temperature ?? STRUCTURED_OUTPUT_TEMPERATURE,
+      maxTokens: req.maxTokens
+    }).build();
+    return this.httpClient.postChatCompletion(groqReq).then((response) => {
+      const content = this.extractContent(response.choices[0]?.message?.content);
+      const parsed = this.jsonParser.parse(content);
+      const genResult = {
+        text: content,
+        model: response.model,
+        providerId: this.id,
+        finishReason: response.choices[0]?.finish_reason ?? "stop",
+        usage: response.usage ? {
+          inputTokens: response.usage.prompt_tokens,
+          outputTokens: response.usage.completion_tokens,
+          totalTokens: response.usage.total_tokens
+        } : void 0
+      };
+      return { value: parsed, result: genResult };
+    });
+  }
+  streamCompletion(prompt, callbacks, options = {}) {
+    return this.streamChatCompletion([createUserMessage(prompt)], callbacks, options);
+  }
+  async streamChatCompletion(messages, callbacks, options = {}) {
+    const model = options.model ?? this.defaultModel;
+    const request = GroqChatRequestBuilder.for(model).withMessages(messages).withConfig(options.generationConfig).withStream(true).build();
+    const parser = new StreamingResponseParser(
+      {
+        onChunk: (chunk) => callbacks.onChunk?.(chunk)
+      },
+      extractContentFromSsePayload
+    );
+    try {
+      const stream = await this.httpClient.streamChatCompletion(request, {
+        signal: options.signal
+      });
       const fullText = await parser.parse(stream);
       callbacks.onComplete?.(fullText);
       return fullText;
@@ -3920,6 +4501,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 {
@@ -4012,30 +4594,235 @@ var ChatService = class {
     }
     return this.storage;
   }
-};
+};
+
+// src/providers/groq/groq-container.ts
+var container = null;
+function configureProvider(config) {
+  const configStore = new GroqConfigStore();
+  const transport = new GroqHttpTransport(configStore);
+  const httpClient = new GroqHttpClient({ configStore, transport });
+  httpClient.initialize(config);
+  const textGeneration = new TextGenerationService(
+    httpClient,
+    new CacheManager(),
+    config.textModel
+  );
+  const chat = new ChatService(textGeneration);
+  container = { groqHttpClient: httpClient, textGeneration, chat };
+  return container;
+}
+function getProvider() {
+  return container;
+}
+function resetProvider() {
+  container?.groqHttpClient.reset();
+  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/groq/groq-container.ts
-var container = null;
-function configureProvider(config) {
-  const configStore = new GroqConfigStore();
-  const transport = new GroqHttpTransport(configStore);
-  const httpClient = new GroqHttpClient({ configStore, transport });
-  httpClient.initialize(config);
-  const textGeneration = new TextGenerationService(
-    httpClient,
-    new CacheManager(),
-    config.textModel
-  );
-  const chat = new ChatService(textGeneration);
-  container = { groqHttpClient: httpClient, textGeneration, chat };
-  return container;
+// 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 getProvider() {
-  return container;
+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 resetProvider() {
-  container?.groqHttpClient.reset();
-  container = null;
+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
@@ -4225,170 +5012,6 @@ function createOpenAiImageAdapter(config) {
   };
 }
 
-// src/core/sse/tool-call-accumulator.ts
-var ToolCallAccumulator = class {
-  slots = /* @__PURE__ */ new Map();
-  push(delta) {
-    const index = delta.index ?? 0;
-    const slot = this.slots.get(index) ?? { id: "", name: "", args: "" };
-    if (delta.id) slot.id = delta.id;
-    if (delta.function?.name) slot.name = delta.function.name;
-    if (delta.function?.arguments) slot.args += delta.function.arguments;
-    this.slots.set(index, slot);
-  }
-  finish() {
-    return Array.from(this.slots.entries()).sort(([a], [b]) => a - b).map(([, slot]) => ({
-      id: slot.id,
-      name: slot.name,
-      arguments: slot.args
-    })).filter((call) => call.id.length > 0 || call.name.length > 0);
-  }
-};
-
-// 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* parseSseEvent(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* parseSseEvent(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 = {
@@ -4409,7 +5032,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),
@@ -4525,7 +5148,7 @@ function createAnthropicAdapter(config) {
             model: req.externalModelId,
             messages,
             ...system.length > 0 ? { system } : {},
-            max_tokens: req.maxOutputTokens,
+            max_tokens: req.maxOutputTokens ?? 4096,
             stream: true
           }),
           signal
@@ -4542,6 +5165,201 @@ 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/core/context/context-manager.ts
+var CHARS_PER_TOKEN = 4;
+var SAFETY_MARGIN_TOKENS = 256;
+function estimateTokens(text) {
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+function estimateMessageTokens(message) {
+  const toolStructure = message.toolCalls && message.toolCalls.length > 0 ? estimateTokens(JSON.stringify(message.toolCalls)) : 0;
+  return estimateTokens(message.content) + toolStructure + 8;
+}
+function buildContext(history, systemPrompt, budget) {
+  const available = budget.contextWindow - budget.maxOutputTokens - SAFETY_MARGIN_TOKENS;
+  let used = estimateTokens(systemPrompt);
+  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")) {
+    selected.shift();
+  }
+  return [{ role: "system", content: systemPrompt }, ...selected];
+}
+
+// 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;
+  }
+}
+
+exports.ADAPTER_MEDIA_TIMEOUT_MS = ADAPTER_MEDIA_TIMEOUT_MS;
+exports.ADAPTER_TIMEOUT_MS = ADAPTER_TIMEOUT_MS;
 exports.ANTHROPIC_API_VERSION = ANTHROPIC_API_VERSION;
 exports.ANTHROPIC_DEFAULT_MAX_TOKENS = ANTHROPIC_DEFAULT_MAX_TOKENS;
 exports.ANTHROPIC_MODELS = ANTHROPIC_MODELS;
@@ -4557,7 +5375,9 @@ exports.CancellationError = CancellationError;
 exports.DEFAULT_BASE_URL = DEFAULT_BASE_URL;
 exports.DEFAULT_GENERATION_CONFIG = DEFAULT_GENERATION_CONFIG;
 exports.DEFAULT_MODELS = DEFAULT_MODELS;
+exports.FAL_ASPECT_IMAGE_SIZES = FAL_ASPECT_IMAGE_SIZES;
 exports.FalProvider = FalProvider;
+exports.FalQueueError = FalQueueError;
 exports.GEMINI_TIERS = GEMINI_TIERS;
 exports.GROQ_MODELS = GROQ_MODELS;
 exports.GROQ_TIERS = GROQ_TIERS;
@@ -4571,6 +5391,7 @@ exports.GroqProvider = GroqProvider;
 exports.IMAGE_B64_LIMIT = IMAGE_B64_LIMIT;
 exports.IMAGE_QUALITIES = IMAGE_QUALITIES;
 exports.IMAGE_SIZES = IMAGE_SIZES;
+exports.OpenAiCompatibleProvider = OpenAiCompatibleProvider;
 exports.ProviderError = ProviderError;
 exports.ProviderFactory = ProviderFactory;
 exports.PrunaProvider = PrunaProvider;
@@ -4580,18 +5401,33 @@ exports.TIMEOUTS = TIMEOUTS;
 exports.TextGenerationService = TextGenerationService;
 exports.TimeoutError = TimeoutError;
 exports.ValidationError = ValidationError;
+exports.WORKERS_AI_LLM_MODEL = WORKERS_AI_LLM_MODEL;
+exports.WORKERS_AI_TIERS = WORKERS_AI_TIERS;
+exports.WorkersAIError = WorkersAIError;
+exports.WorkersAIProvider = WorkersAIProvider;
+exports.apiKeyAvailable = apiKeyAvailable;
+exports.audioTranscriptionAdapterFor = audioTranscriptionAdapterFor;
+exports.buildFalAudioInput = buildFalAudioInput;
+exports.buildFalAudioLyrics = buildFalAudioLyrics;
+exports.buildFalImageInput = buildFalImageInput;
+exports.buildFalTagPrompt = buildFalTagPrompt;
+exports.buildFalVideoInput = buildFalVideoInput;
+exports.chatAdapterFor = chatAdapterFor;
 exports.configureProvider = configureProvider;
 exports.consumeAnthropicStream = consumeAnthropicStream;
 exports.consumeGroqStream = consumeGroqStream;
 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;
@@ -4599,23 +5435,37 @@ exports.createProviderFactory = createProviderFactory;
 exports.createPrunaProvider = createPrunaProvider;
 exports.createSystemMessage = createSystemMessage;
 exports.createUserMessage = createUserMessage;
+exports.createWorkersAIProvider = createWorkersAIProvider;
 exports.defaultEffortForModel = defaultEffortForModel;
+exports.embeddingsAdapterFor = embeddingsAdapterFor;
 exports.extractContentFromSsePayload = extractContentFromSsePayload;
 exports.extractTextFromMessages = extractTextFromMessages;
+exports.falQueueConfigured = falQueueConfigured;
 exports.formatMessagesForDisplay = formatMessagesForDisplay;
 exports.generateImageThenVideo = generateImageThenVideo;
 exports.generatePruna = generate;
 exports.generateWithPruna = generateWithPruna;
 exports.getProvider = getProvider;
+exports.imageAdapterFor = imageAdapterFor;
 exports.isMediaProvider = isMediaProvider;
 exports.isTextProvider = isTextProvider;
 exports.mapAnthropicStopReason = mapAnthropicStopReason;
+exports.parseFalAudioOutput = parseFalAudioOutput;
+exports.parseFalImageOutput = parseFalImageOutput;
+exports.parseFalVideoOutput = parseFalVideoOutput;
 exports.pollForResult = pollForResult;
 exports.promptToMessages = promptToMessages;
 exports.requestStructuredJson = requestStructuredJson;
 exports.resetProvider = resetProvider;
+exports.resolveApiKey = resolveApiKey;
+exports.runConversation = runConversation;
+exports.runWorkersAIText = runWorkersAIText;
+exports.speakWithWorkersAI = speakWithWorkersAI;
+exports.speechAdapterFor = speechAdapterFor;
+exports.streamWorkersAIText = streamWorkersAIText;
 exports.submitPrediction = submitPrediction;
 exports.toGroqMessages = toGroqMessages;
 exports.uploadImage = uploadImage;
+exports.workersAIConfigured = workersAIConfigured;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map