@umituz/web-ai 1.1.0 → 1.2.0

package/dist/content/index.cjs

@@ -698,6 +698,68 @@ async function extractErrorMessageFromResponse(response) {
   return buildHttpStatusFallback(response.status, response.statusText);
 }
 
+// src/core/errors/unified-ai-error.ts
+var STATUS_TO_CODE = {
+  400: "invalid_request",
+  401: "invalid_key",
+  403: "invalid_key",
+  404: "model_unavailable",
+  413: "invalid_request",
+  422: "invalid_request",
+  429: "rate_limited",
+  500: "upstream_error",
+  502: "upstream_error",
+  503: "capacity",
+  504: "timeout"
+};
+var CODE_MESSAGES = {
+  invalid_key: "The provider rejected the configured API key.",
+  missing_key: "The provider is not configured with an API key.",
+  rate_limited: "The provider rate limit was reached. Try again shortly.",
+  capacity: "The provider is temporarily at capacity. Try again shortly.",
+  timeout: "The model took too long to respond.",
+  invalid_request: "The request was rejected by the provider.",
+  model_unavailable: "The requested model is not available.",
+  upstream_error: "The provider returned an unexpected error.",
+  network: "Could not reach the provider.",
+  cancelled: "Generation was cancelled."
+};
+var AiError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message ?? CODE_MESSAGES[code]);
+    this.name = "AiError";
+    this.code = code;
+  }
+  get userMessage() {
+    return this.message;
+  }
+};
+function isApiKeyRejection(provider) {
+  if (provider.code === "invalid_api_key") return true;
+  return provider.type === void 0;
+}
+function errorFromStatus(status, detail, provider) {
+  let code = STATUS_TO_CODE[status] ?? "upstream_error";
+  if (status === 403 && provider && !isApiKeyRejection(provider)) {
+    code = "model_unavailable";
+  }
+  return new AiError(code, detail ? `${CODE_MESSAGES[code]} (${detail})` : void 0);
+}
+function errorFromUnknown(err) {
+  if (err instanceof AiError) return err;
+  if (err instanceof Error) {
+    if (err.name === "TimeoutError" || err.name === "AbortError") {
+      return new AiError("timeout");
+    }
+    if (err.name === "TypeError") {
+      return new AiError("network");
+    }
+    return new AiError("upstream_error", err.message);
+  }
+  return new AiError("upstream_error");
+}
+
 // src/providers/base/provider.types.ts
 function isTextProvider(provider) {
   return provider.capabilities.includes("text");
@@ -1452,7 +1514,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();
@@ -1532,7 +1594,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;
 }
@@ -2377,7 +2440,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();
@@ -2471,7 +2534,8 @@ function toGroqMessages(messages, systemPrompt) {
 }
 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;
 }
@@ -2649,7 +2713,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 };
@@ -2755,7 +2819,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;
 }
@@ -3817,6 +3882,546 @@ var PrunaProvider = class {
   }
 };
 
+// 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 || 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) {
+  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 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 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;
+}
+
 // src/providers/factory/create-ai.ts
 function createAI(config = {}) {
   const factory = new ProviderFactory({
@@ -3839,6 +4444,15 @@ function createAI(config = {}) {
   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;
 }
 
@@ -4351,7 +4965,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}`
           );
         }
       }
@@ -4813,7 +5427,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}"`);