@umituz/web-ai 1.0.0 → 1.0.1

package/dist/content/index.js

@@ -73,25 +73,49 @@ var VIDEO_DURATION_OPTIONS = VIDEO_DURATION_OPTIONS_SECONDS;
 var getDimensionsForAspectRatio = resolveDimensionsForAspectRatio;
 var getRecommendedQuality = recommendQualityForAspectRatio;
 
-// src/content/domain/errors/AIErrors.ts
-var AIError = class _AIError extends Error {
-  code;
-  cause;
-  constructor(message, code, cause) {
-    super(message);
-    this.name = "AIError";
-    this.code = code;
-    this.cause = cause;
-  }
-  static from(error, fallbackCode = "UNKNOWN") {
-    if (error instanceof _AIError) return error;
-    if (error instanceof Error) {
-      return new _AIError(error.message, mapMessageToCode(error.message, fallbackCode), error);
-    }
-    return new _AIError(String(error), fallbackCode, error);
-  }
-};
-function mapMessageToCode(message, fallback) {
+// src/core/errors/ai-error-types.ts
+var AIErrorType = /* @__PURE__ */ ((AIErrorType2) => {
+  AIErrorType2["INVALID_API_KEY"] = "INVALID_API_KEY";
+  AIErrorType2["MISSING_CONFIG"] = "MISSING_CONFIG";
+  AIErrorType2["NETWORK_ERROR"] = "NETWORK_ERROR";
+  AIErrorType2["ABORT_ERROR"] = "ABORT_ERROR";
+  AIErrorType2["RATE_LIMIT_ERROR"] = "RATE_LIMIT_ERROR";
+  AIErrorType2["SERVER_ERROR"] = "SERVER_ERROR";
+  AIErrorType2["CLIENT_ERROR"] = "CLIENT_ERROR";
+  AIErrorType2["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+  return AIErrorType2;
+})(AIErrorType || {});
+
+// src/core/errors/ai-error.ts
+var KNOWN_ERROR_TYPES = new Set(Object.values(AIErrorType));
+function mapCodeToType(code) {
+  switch (code) {
+    case "VALIDATION_ERROR":
+    case "CLIENT_ERROR":
+      return "CLIENT_ERROR" /* CLIENT_ERROR */;
+    case "INVALID_API_KEY":
+      return "INVALID_API_KEY" /* INVALID_API_KEY */;
+    case "MISSING_CONFIG":
+    case "PROVIDER_UNAVAILABLE":
+      return "MISSING_CONFIG" /* MISSING_CONFIG */;
+    case "PROVIDER_QUOTA_EXHAUSTED":
+    case "RATE_LIMIT_ERROR":
+      return "RATE_LIMIT_ERROR" /* RATE_LIMIT_ERROR */;
+    case "NETWORK_ERROR":
+    case "TIMEOUT":
+      return "NETWORK_ERROR" /* NETWORK_ERROR */;
+    case "ABORT_ERROR":
+    case "ABORTED":
+      return "ABORT_ERROR" /* ABORT_ERROR */;
+    case "SERVER_ERROR":
+    case "PROVIDER_ERROR":
+    case "NO_RESULT":
+      return "SERVER_ERROR" /* SERVER_ERROR */;
+    default:
+      return "UNKNOWN_ERROR" /* UNKNOWN_ERROR */;
+  }
+}
+function mapMessageToCode(message, fallback = "UNKNOWN") {
   const lower = message.toLowerCase();
   if (lower.includes("validation")) return "VALIDATION_ERROR";
   if (lower.includes("quota")) return "PROVIDER_QUOTA_EXHAUSTED";
@@ -104,37 +128,39 @@ function mapMessageToCode(message, fallback) {
   if (lower.includes("network") || lower.includes("fetch")) return "NETWORK_ERROR";
   return fallback;
 }
-var ValidationError = class extends AIError {
-  constructor(message) {
-    super(message, "VALIDATION_ERROR");
-    this.name = "ValidationError";
-  }
-};
-var ProviderUnavailableError = class extends AIError {
-  constructor(providerId) {
-    super(`Provider ${providerId} is not available`, "PROVIDER_UNAVAILABLE");
-    this.name = "ProviderUnavailableError";
-  }
-};
-var ProviderQuotaExhaustedError = class extends AIError {
-  constructor(providerId) {
-    super(`Provider ${providerId} quota exhausted`, "PROVIDER_QUOTA_EXHAUSTED");
-    this.name = "ProviderQuotaExhaustedError";
-  }
-};
-
-// src/core/errors/ai-error.ts
-var AIError2 = class extends Error {
+var AIError = class _AIError extends Error {
   type;
+  code;
   cause;
   metadata;
-  constructor(type, message, cause, metadata = {}) {
-    super(message);
+  constructor(typeOrMessage, messageOrCode, cause, metadata = {}) {
+    let effectiveType;
+    let effectiveMessage;
+    let effectiveCode;
+    if (KNOWN_ERROR_TYPES.has(typeOrMessage)) {
+      effectiveType = typeOrMessage;
+      effectiveMessage = messageOrCode ?? "";
+      effectiveCode = effectiveType;
+    } else {
+      effectiveMessage = typeOrMessage;
+      effectiveCode = messageOrCode ?? "UNKNOWN";
+      effectiveType = mapCodeToType(effectiveCode);
+    }
+    super(effectiveMessage);
     this.name = "AIError";
-    this.type = type;
+    this.type = effectiveType;
+    this.code = effectiveCode;
     this.cause = cause;
     this.metadata = metadata;
   }
+  static from(error, fallbackCode = "UNKNOWN") {
+    if (error instanceof _AIError) return error;
+    if (error instanceof Error) {
+      const code = mapMessageToCode(error.message, fallbackCode);
+      return new _AIError(error.message, code, error);
+    }
+    return new _AIError(String(error), fallbackCode, error);
+  }
   toString() {
     const statusPart = typeof this.metadata.status === "number" ? ` (HTTP ${this.metadata.status})` : "";
     return `${this.name} [${this.type}]: ${this.message}${statusPart}`;
@@ -143,12 +169,33 @@ var AIError2 = class extends Error {
     return {
       name: this.name,
       type: this.type,
+      code: this.code,
       message: this.message,
       metadata: this.metadata
     };
   }
 };
 
+// src/content/domain/errors/AIErrors.ts
+var ValidationError = class extends AIError {
+  constructor(message) {
+    super(message, "VALIDATION_ERROR");
+    this.name = "ValidationError";
+  }
+};
+var ProviderUnavailableError = class extends AIError {
+  constructor(providerId) {
+    super(`Provider ${providerId} is not available`, "PROVIDER_UNAVAILABLE");
+    this.name = "ProviderUnavailableError";
+  }
+};
+var ProviderQuotaExhaustedError = class extends AIError {
+  constructor(providerId) {
+    super(`Provider ${providerId} quota exhausted`, "PROVIDER_QUOTA_EXHAUSTED");
+    this.name = "ProviderQuotaExhaustedError";
+  }
+};
+
 // src/core/errors/error-classifier.ts
 var DEFAULT_RETRYABLE_TYPES = /* @__PURE__ */ new Set([
   "NETWORK_ERROR" /* NETWORK_ERROR */,
@@ -291,7 +338,7 @@ var ProviderFactory = class {
         }
       }
     }
-    const failure = new AIError2(
+    const failure = new AIError(
       "SERVER_ERROR" /* SERVER_ERROR */,
       `All providers failed for capability 'text'`,
       lastError instanceof Error ? lastError : void 0
@@ -305,12 +352,16 @@ var ProviderFactory = class {
     let wake = null;
     let finished = false;
     let failure;
+    const controller = new AbortController();
+    const onAbort = () => controller.abort();
+    request.signal?.addEventListener("abort", onAbort);
+    const effectiveRequest = { ...request, signal: controller.signal };
     const notify = () => {
       const resolve = wake;
       wake = null;
       resolve?.();
     };
-    const completion = this.chatStream(request, {
+    const completion = this.chatStream(effectiveRequest, {
       onChunk: (chunk) => {
         queue.push(chunk);
         notify();
@@ -326,18 +377,23 @@ var ProviderFactory = class {
         notify();
       }
     );
-    while (!finished || queue.length > 0) {
-      if (queue.length === 0 && !finished) {
-        await new Promise((resolve) => {
-          wake = resolve;
-        });
-      }
-      while (queue.length > 0) {
-        yield queue.shift();
+    try {
+      while (!finished || queue.length > 0) {
+        if (queue.length === 0 && !finished) {
+          await new Promise((resolve) => {
+            wake = resolve;
+          });
+        }
+        while (queue.length > 0) {
+          yield queue.shift();
+        }
+        if (failure) throw failure;
       }
-      if (failure) throw failure;
+      await completion;
+    } finally {
+      controller.abort();
+      request.signal?.removeEventListener("abort", onAbort);
     }
-    await completion;
   }
   async generateJson(request) {
     const effective = request.model || request.tier ? request : { ...request, tier: this.defaultTier };
@@ -445,7 +501,7 @@ var ProviderFactory = class {
         }
       }
     }
-    throw new AIError2(
+    throw new AIError(
       "SERVER_ERROR" /* SERVER_ERROR */,
       `All providers failed for capability '${capability}'`,
       lastError instanceof Error ? lastError : void 0
@@ -474,7 +530,7 @@ var ProviderFactory = class {
     }
   }
   noProviderError(capability) {
-    return new AIError2(
+    return new AIError(
       "MISSING_CONFIG" /* MISSING_CONFIG */,
       `No provider registered for capability '${capability}' \u2014 create one with createAI() and include its config block`
     );
@@ -484,15 +540,22 @@ var ProviderFactory = class {
 // src/core/constants/protocol.constants.ts
 var SSE_PREFIX = "data: ";
 var SSE_DONE_MARKER = "[DONE]";
-var JSON_CODE_BLOCK_PATTERN = /```json\n([\s\S]*?)\n```/;
+var JSON_CODE_BLOCK_PATTERN = /```(?:json)?\s*\n?([\s\S]*?)\n?```/;
 var JSON_OBJECT_PATTERN = /\{[\s\S]*\}/;
+var JSON_ARRAY_PATTERN = /\[[\s\S]*\]/;
 
 // src/core/parsers/sse-lines.ts
 function isSseDataLine(line) {
-  return line.startsWith(SSE_PREFIX);
+  return line.startsWith(SSE_PREFIX) || line.startsWith("data:");
 }
 function extractSseDataPayload(line) {
-  return line.slice(SSE_PREFIX.length);
+  if (line.startsWith(SSE_PREFIX)) {
+    return line.slice(SSE_PREFIX.length);
+  }
+  if (line.startsWith("data:")) {
+    return line.slice(5);
+  }
+  return line;
 }
 function isSseDoneMarker(payload) {
   return payload === SSE_DONE_MARKER;
@@ -501,7 +564,7 @@ function isSseDoneMarker(payload) {
 // src/core/parsers/json-content-extractor.ts
 function extractJsonFromCodeFence(content) {
   const match = content.match(JSON_CODE_BLOCK_PATTERN);
-  if (match && match[1]) return match[1];
+  if (match && match[1]) return match[1].trim();
   return null;
 }
 function extractJsonObject(content) {
@@ -509,8 +572,27 @@ function extractJsonObject(content) {
   if (match && match[0]) return match[0];
   return null;
 }
+function extractJsonArray(content) {
+  const match = content.match(JSON_ARRAY_PATTERN);
+  if (match && match[0]) return match[0];
+  return null;
+}
+function repairCommonJsonDefects(text) {
+  return text.replace(/(:\s*-?\d+(?:\.\d+)?)\s*"/g, "$1").replace(/(:\s*"[^"]*")"/g, "$1");
+}
 function extractJsonCandidate(content) {
-  return extractJsonFromCodeFence(content) ?? extractJsonObject(content) ?? content;
+  const fromFence = extractJsonFromCodeFence(content);
+  if (fromFence) return fromFence;
+  const objectIndex = content.indexOf("{");
+  const arrayIndex = content.indexOf("[");
+  if (objectIndex !== -1 && (arrayIndex === -1 || objectIndex < arrayIndex)) {
+    const obj = extractJsonObject(content);
+    if (obj) return obj;
+  } else if (arrayIndex !== -1) {
+    const arr = extractJsonArray(content);
+    if (arr) return arr;
+  }
+  return content.trim();
 }
 
 // src/core/parsers/json-response.parser.ts
@@ -519,12 +601,17 @@ var JsonResponseParser = class {
     const candidate = extractJsonCandidate(rawContent);
     try {
       return JSON.parse(candidate);
-    } catch (error) {
-      throw new AIError2(
-        "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
-        "Failed to parse structured response as JSON",
-        error instanceof Error ? error : void 0
-      );
+    } catch {
+      try {
+        return JSON.parse(repairCommonJsonDefects(candidate));
+      } catch (error) {
+        throw new AIError(
+          "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+          "Failed to parse structured response as JSON",
+          error instanceof Error ? error : void 0,
+          { rawContent }
+        );
+      }
     }
   }
 };
@@ -650,7 +737,7 @@ var AnthropicHttpTransport = class {
       });
       if (!response.ok) await this.throwFromErrorResponse(response);
       if (!response.body) {
-        throw new AIError2("NETWORK_ERROR" /* NETWORK_ERROR */, "Response body is null");
+        throw new AIError("NETWORK_ERROR" /* NETWORK_ERROR */, "Response body is null");
       }
       return response.body;
     } catch (error) {
@@ -683,7 +770,7 @@ var AnthropicHttpTransport = class {
       status: response.status,
       url: response.url
     };
-    throw new AIError2(
+    throw new AIError(
       classifyHttpStatus(response.status),
       errorMessage,
       void 0,
@@ -691,24 +778,24 @@ var AnthropicHttpTransport = class {
     );
   }
   normalizeError(error) {
-    if (error instanceof AIError2) return error;
+    if (error instanceof AIError) return error;
     if (error instanceof Error) {
       if (error.name === "AbortError") {
-        return new AIError2(
+        return new AIError(
           "ABORT_ERROR" /* ABORT_ERROR */,
           "Request was aborted by the client",
           error
         );
       }
       if (error.name === "TypeError" && error.message.toLowerCase().includes("network")) {
-        return new AIError2(
+        return new AIError(
           "NETWORK_ERROR" /* NETWORK_ERROR */,
           "Network error: Unable to connect to the AI service",
           error
         );
       }
     }
-    return new AIError2(
+    return new AIError(
       "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
       error instanceof Error ? error.message : "Unknown error occurred",
       error instanceof Error ? error : void 0
@@ -838,11 +925,14 @@ async function consumeAnthropicStream(stream, callbacks) {
         break;
       case "message_stop":
         break;
-      case "error":
-        throw new AIError2(
-          event.error.type === "rate_limit_error" ? "RATE_LIMIT_ERROR" /* RATE_LIMIT_ERROR */ : "SERVER_ERROR" /* SERVER_ERROR */,
+      case "error": {
+        const errType = event.error.type;
+        const mappedType = errType === "rate_limit_error" ? "RATE_LIMIT_ERROR" /* RATE_LIMIT_ERROR */ : errType === "authentication_error" ? "INVALID_API_KEY" /* INVALID_API_KEY */ : errType === "invalid_request_error" ? "CLIENT_ERROR" /* CLIENT_ERROR */ : "SERVER_ERROR" /* SERVER_ERROR */;
+        throw new AIError(
+          mappedType,
           event.error.message || "Anthropic stream failed mid-flight"
         );
+      }
     }
   };
   try {
@@ -857,8 +947,8 @@ async function consumeAnthropicStream(stream, callbacks) {
     buffer += decoder.decode();
     if (buffer.length > 0) consumeLine(buffer);
   } catch (error) {
-    if (error instanceof AIError2) throw error;
-    throw new AIError2(
+    if (error instanceof AIError) throw error;
+    throw new AIError(
       "NETWORK_ERROR" /* NETWORK_ERROR */,
       "Stream was interrupted",
       error instanceof Error ? error : void 0
@@ -920,7 +1010,7 @@ var AnthropicProvider = class {
     const messages = [...request.messages];
     const lastUserIndex = findLastIndex(messages, (m) => m.role === "user");
     if (lastUserIndex === -1) {
-      throw new AIError2(
+      throw new AIError(
         "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
         "generateStructured requires at least one user message"
       );
@@ -975,7 +1065,7 @@ var AnthropicProvider = class {
           finishReason
         };
       }
-      throw new AIError2(
+      throw new AIError(
         "SERVER_ERROR" /* SERVER_ERROR */,
         "No content generated from Anthropic API",
         void 0,
@@ -1180,7 +1270,7 @@ var RetryManager = class {
   }
   shouldRetry(error, options) {
     if (options.shouldRetry) return options.shouldRetry(error);
-    if (error instanceof AIError2) {
+    if (error instanceof AIError) {
       return isRetryableErrorType(error.type, DEFAULT_ERROR_CLASSIFICATION_RULE);
     }
     const lower = error.message.toLowerCase();
@@ -1417,7 +1507,7 @@ var GroqHttpTransport = class {
       });
       if (!response.ok) await this.throwFromErrorResponse(response);
       if (!response.body) {
-        throw new AIError2("NETWORK_ERROR" /* NETWORK_ERROR */, "Response body is null");
+        throw new AIError("NETWORK_ERROR" /* NETWORK_ERROR */, "Response body is null");
       }
       return response.body;
     } catch (error) {
@@ -1465,7 +1555,7 @@ var GroqHttpTransport = class {
       status: response.status,
       url: response.url
     };
-    throw new AIError2(
+    throw new AIError(
       classifyHttpStatus(response.status),
       errorMessage,
       void 0,
@@ -1473,24 +1563,24 @@ var GroqHttpTransport = class {
     );
   }
   normalizeError(error) {
-    if (error instanceof AIError2) return error;
+    if (error instanceof AIError) return error;
     if (error instanceof Error) {
       if (error.name === "AbortError") {
-        return new AIError2(
+        return new AIError(
           "ABORT_ERROR" /* ABORT_ERROR */,
           "Request was aborted by the client",
           error
         );
       }
       if (error.name === "TypeError" && error.message.toLowerCase().includes("network")) {
-        return new AIError2(
+        return new AIError(
           "NETWORK_ERROR" /* NETWORK_ERROR */,
           "Network error: Unable to connect to the AI service",
           error
         );
       }
     }
-    return new AIError2(
+    return new AIError(
       "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
       error instanceof Error ? error.message : "Unknown error occurred",
       error instanceof Error ? error : void 0
@@ -1632,6 +1722,13 @@ async function consumeGroqStream(stream, callbacks) {
     } catch {
       return;
     }
+    const errorBody = chunk.error;
+    if (errorBody) {
+      throw new AIError(
+        errorBody.message?.toLowerCase().includes("rate limit") ? "RATE_LIMIT_ERROR" /* RATE_LIMIT_ERROR */ : "SERVER_ERROR" /* SERVER_ERROR */,
+        errorBody.message || "Groq stream failed mid-flight"
+      );
+    }
     if (chunk.model) model = chunk.model;
     const choice = chunk.choices?.[0];
     const delta = choice?.delta?.content;
@@ -1646,13 +1743,6 @@ async function consumeGroqStream(stream, callbacks) {
     if (tailUsage) {
       usage = mapGroqUsage(tailUsage);
     }
-    const errorBody = chunk.error;
-    if (errorBody) {
-      throw new AIError2(
-        "SERVER_ERROR" /* SERVER_ERROR */,
-        errorBody.message || "Groq stream failed mid-flight"
-      );
-    }
   };
   try {
     while (true) {
@@ -1666,8 +1756,8 @@ async function consumeGroqStream(stream, callbacks) {
     buffer += decoder.decode();
     if (buffer.length > 0) consumeLine(buffer);
   } catch (error) {
-    if (error instanceof AIError2) throw error;
-    throw new AIError2(
+    if (error instanceof AIError) throw error;
+    throw new AIError(
       "NETWORK_ERROR" /* NETWORK_ERROR */,
       "Stream was interrupted",
       error instanceof Error ? error : void 0
@@ -1725,7 +1815,7 @@ var GroqProvider = class {
     const choice = response.choices?.[0];
     const text = choice?.message?.content ?? "";
     if (text.length === 0) {
-      throw new AIError2(
+      throw new AIError(
         "SERVER_ERROR" /* SERVER_ERROR */,
         "No content generated from Groq API",
         void 0,
@@ -1747,7 +1837,7 @@ var GroqProvider = class {
     const messages = toGroqMessages(request.messages, request.systemPrompt);
     const lastUserIndex = findLastIndex2(messages, (m) => m.role === "user");
     if (lastUserIndex === -1) {
-      throw new AIError2(
+      throw new AIError(
         "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
         "generateStructured requires at least one user message"
       );
@@ -1761,7 +1851,7 @@ var GroqProvider = class {
     const choice = response.choices?.[0];
     const text = choice?.message?.content ?? "";
     if (text.length === 0) {
-      throw new AIError2(
+      throw new AIError(
         "SERVER_ERROR" /* SERVER_ERROR */,
         "No content generated from Groq API",
         void 0,
@@ -1788,7 +1878,7 @@ var GroqProvider = class {
     try {
       const outcome = await consumeGroqStream(streamBody, callbacks);
       if (outcome.text.length === 0) {
-        throw new AIError2(
+        throw new AIError(
           "SERVER_ERROR" /* SERVER_ERROR */,
           "No content generated from Groq API",
           void 0,
@@ -1972,7 +2062,9 @@ var GeminiProvider = class extends BaseProvider {
           headers: this.authHeaders()
         }
       );
-      return response.ok ? "healthy" : "unavailable";
+      if (response.ok) return "healthy";
+      if (response.status === 401 || response.status === 403) return "unavailable";
+      return "degraded";
     } catch {
       return "unavailable";
     }
@@ -1983,6 +2075,8 @@ var GeminiProvider = class extends BaseProvider {
   async generate(request) {
     try {
       const model = request.model ?? this.resolveModel(request.tier ?? "balanced");
+      const systemMessages = request.messages.filter((m) => m.role === "system");
+      const systemPrompt = request.systemPrompt && request.systemPrompt.length > 0 ? request.systemPrompt : systemMessages.length > 0 ? systemMessages.map((m) => m.content).join("\n") : void 0;
       const response = await this.withRetry(async () => {
         return await this.fetchWithTimeout(
           `${this.config.baseUrl}/models/${model}:generateContent`,
@@ -1990,24 +2084,30 @@ var GeminiProvider = class extends BaseProvider {
             method: "POST",
             headers: this.authHeaders(),
             body: JSON.stringify({
-              systemInstruction: request.systemPrompt && request.systemPrompt.length > 0 ? { parts: [{ text: request.systemPrompt }] } : void 0,
+              systemInstruction: systemPrompt && systemPrompt.length > 0 ? { parts: [{ text: systemPrompt }] } : void 0,
               contents: toGeminiContents(request.messages),
               generationConfig: {
-                temperature: request.temperature || 0.7,
-                maxOutputTokens: request.maxTokens || 2048,
-                topP: request.topP || 0.9
+                temperature: request.temperature ?? 0.7,
+                maxOutputTokens: request.maxTokens ?? 2048,
+                topP: request.topP ?? 0.9
               }
             })
           }
         );
       });
       if (!response.ok) {
-        throw new Error(`Gemini API error: ${response.statusText}`);
+        const message = await extractErrorMessageFromResponse(response);
+        throw new AIError(
+          classifyHttpStatus(response.status),
+          `Gemini API error (${response.status}): ${message}`,
+          void 0,
+          { status: response.status, model }
+        );
       }
       const data = await response.json();
-      const text = data.candidates[0]?.content?.parts?.map((part) => part.text ?? "").join("") ?? "";
+      const text = data.candidates?.[0]?.content?.parts?.map((part) => part.text ?? "").join("") ?? "";
       if (text.length === 0) {
-        throw new AIError2("SERVER_ERROR" /* SERVER_ERROR */, "No content generated from Gemini API", void 0, { model });
+        throw new AIError("SERVER_ERROR" /* SERVER_ERROR */, "No content generated from Gemini API", void 0, { model });
       }
       return {
         text,
@@ -2018,11 +2118,11 @@ var GeminiProvider = class extends BaseProvider {
         } : void 0,
         model,
         providerId: this.id,
-        finishReason: mapGeminiFinishReason(data.candidates[0]?.finishReason)
+        finishReason: mapGeminiFinishReason(data.candidates?.[0]?.finishReason)
       };
     } catch (error) {
-      if (error instanceof AIError2) throw error;
-      throw new AIError2(
+      if (error instanceof AIError) throw error;
+      throw new AIError(
         "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
         `Gemini text generation failed: ${error instanceof Error ? error.message : "Unknown error"}`,
         error instanceof Error ? error : void 0
@@ -2033,7 +2133,7 @@ var GeminiProvider = class extends BaseProvider {
     const messages = [...request.messages];
     const lastUserIndex = findLastIndex3(messages, (m) => m.role === "user");
     if (lastUserIndex === -1) {
-      throw new AIError2(
+      throw new AIError(
         "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
         "generateStructured requires at least one user message"
       );
@@ -2070,12 +2170,18 @@ var GeminiProvider = class extends BaseProvider {
         );
       });
       if (!response.ok) {
-        throw new Error(`Gemini API error: ${response.statusText}`);
+        const message = await extractErrorMessageFromResponse(response);
+        throw new AIError(
+          classifyHttpStatus(response.status),
+          `Gemini image generation error (${response.status}): ${message}`,
+          void 0,
+          { status: response.status }
+        );
       }
       const data = await response.json();
-      const imageData = data.candidates[0]?.content?.parts[0]?.inlineData;
+      const imageData = data.candidates?.[0]?.content?.parts?.[0]?.inlineData;
       if (!imageData) {
-        throw new Error("No image data in response");
+        throw new AIError("SERVER_ERROR" /* SERVER_ERROR */, "No image data in Gemini response");
       }
       const url = `data:${imageData.mimeType};base64,${imageData.data}`;
       return {
@@ -2454,6 +2560,41 @@ var FalProvider = class extends BaseProvider {
   }
 };
 
+// src/providers/pruna/pruna-generate.ts
+var prunaCorePromise = null;
+async function loadPrunaCore() {
+  if (!prunaCorePromise) {
+    const specifier = "@umituz/pruna-provider/core";
+    prunaCorePromise = import(specifier);
+  }
+  return prunaCorePromise;
+}
+async function* generateWithPruna(request, apiKey, signal, onProgress) {
+  const prunaCore = await loadPrunaCore();
+  if (prunaCore.generateWithPruna) {
+    yield* prunaCore.generateWithPruna(request, apiKey, signal, onProgress);
+    return;
+  }
+  if (!prunaCore.submitPrediction || !prunaCore.pollForResult) {
+    throw new Error("@umituz/pruna-provider/core does not export required functions");
+  }
+  const modelId = request.model || (request.image ? "p-image-edit" : "p-image");
+  const prediction = await prunaCore.submitPrediction(modelId, request, apiKey, signal, onProgress);
+  if (prediction.output && typeof prediction.output === "object" && "url" in prediction.output) {
+    yield {
+      stage: "predicting",
+      result: { url: prediction.output.url, model: modelId }
+    };
+    return;
+  }
+  const pollUrl = prediction.status_url || prediction.generation_url;
+  if (!pollUrl) {
+    throw new Error("Pruna prediction response missing polling URL");
+  }
+  const resultUrl = await prunaCore.pollForResult(pollUrl, apiKey, 60, 2e3, signal, onProgress);
+  yield { stage: "polling", result: { url: resultUrl, model: modelId } };
+}
+
 // src/providers/pruna/pruna.provider.ts
 var PrunaProvider = class {
   constructor(config) {
@@ -2469,17 +2610,70 @@ var PrunaProvider = class {
   async estimateCost(_request) {
     return 1;
   }
-  async generateImage(_request) {
-    throw new AIError2("UNKNOWN_ERROR" /* UNKNOWN_ERROR */, "Use generateWithPruna instead");
+  async generateImage(request) {
+    let finalUrl;
+    const model = this.config.models?.textToImage;
+    for await (const stage of generateWithPruna(
+      { prompt: request.prompt, model, quality: request.quality },
+      this.config.apiKey
+    )) {
+      if (stage.error) throw stage.error;
+      if (stage.result?.url) finalUrl = stage.result.url;
+    }
+    if (!finalUrl) {
+      throw new AIError("SERVER_ERROR" /* SERVER_ERROR */, "No image generated by Pruna AI");
+    }
+    return {
+      id: Date.now().toString(),
+      type: "image",
+      url: finalUrl,
+      metadata: { provider: this.id, model: model ?? "p-image" },
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
   }
-  async generateVideo(_request) {
-    throw new AIError2("UNKNOWN_ERROR" /* UNKNOWN_ERROR */, "Use generateWithPruna instead");
+  async generateVideo(request) {
+    let finalUrl;
+    const model = this.config.models?.textToVideo;
+    for await (const stage of generateWithPruna(
+      { prompt: request.prompt, model, duration: request.duration, aspectRatio: request.aspectRatio },
+      this.config.apiKey
+    )) {
+      if (stage.error) throw stage.error;
+      if (stage.result?.url) finalUrl = stage.result.url;
+    }
+    if (!finalUrl) {
+      throw new AIError("SERVER_ERROR" /* SERVER_ERROR */, "No video generated by Pruna AI");
+    }
+    return {
+      id: Date.now().toString(),
+      type: "video",
+      url: finalUrl,
+      metadata: { provider: this.id, model: model ?? "p-video" },
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
   }
-  async imageToVideo(_request) {
-    throw new AIError2("UNKNOWN_ERROR" /* UNKNOWN_ERROR */, "Use generateWithPruna instead");
+  async imageToVideo(request) {
+    let finalUrl;
+    for await (const stage of generateWithPruna(
+      { image: request.imageUrl, prompt: request.prompt, duration: request.duration, motion: request.motion },
+      this.config.apiKey
+    )) {
+      if (stage.error) throw stage.error;
+      if (stage.result?.url) finalUrl = stage.result.url;
+    }
+    if (!finalUrl) {
+      throw new AIError("SERVER_ERROR" /* SERVER_ERROR */, "No video generated from image by Pruna AI");
+    }
+    return {
+      id: Date.now().toString(),
+      type: "video",
+      url: finalUrl,
+      metadata: { provider: this.id, model: "p-image-to-video" },
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
   }
   async videoToVideo(_request) {
-    throw new AIError2("UNKNOWN_ERROR" /* UNKNOWN_ERROR */, "Use generateWithPruna instead");
+    throw new AIError("CLIENT_ERROR" /* CLIENT_ERROR */, "Pruna AI provider does not support video-to-video conversion");
   }
 };
 
@@ -3086,11 +3280,12 @@ var buildScriptResult = (parsed, duration) => {
   if (!script) {
     throw new Error("AI response missing script field");
   }
+  const wordCount = script.trim().length === 0 ? 0 : script.trim().split(/\s+/).length;
   return {
     ...parsed,
     script,
     duration,
-    wordCount: script.split(" ").length
+    wordCount
   };
 };
 var VideoScriptService = class {
@@ -3285,7 +3480,6 @@ var SeoService = class {
   analyzeKeywords(content, keywords) {
     const validatedContent = validateContentBody(content);
     const validatedKeywords = validateKeywordList(keywords);
-    void countWordsInContent(validatedContent);
     return validatedKeywords.map((keyword) => {
       const count = countKeywordOccurrences(validatedContent, keyword);
       const density = calculateKeywordDensity(validatedContent, keyword);
@@ -3380,68 +3574,20 @@ var ABTestService = class {
     });
     const scoreA = predictions[0]?.predictedEngagement ?? FALLBACK_ENGAGEMENT;
     const scoreB = predictions[1]?.predictedEngagement ?? FALLBACK_ENGAGEMENT;
+    const isTie = scoreA === scoreB;
     const winner = selectHigherScoreVariantId(scoreA, scoreB, VARIANT_A_ID, VARIANT_B_ID);
     const improvement = calculateImprovementPercentage(scoreA, scoreB);
     return {
       winner,
       confidence: AB_TEST_DEFAULT_CONFIDENCE,
-      improvement: `+${improvement}% engagement`,
-      reasoning: winner === VARIANT_A_ID ? "Variant A has more engaging content" : "Variant B has more engaging content",
+      improvement: isTie ? "0%" : `+${improvement}% engagement`,
+      reasoning: isTie ? "Both variants have equal predicted engagement" : winner === VARIANT_A_ID ? "Variant A has more engaging content" : "Variant B has more engaging content",
       recommendations: [...DEFAULT_RECOMMENDATIONS]
     };
   }
 };
 
-// src/content/infrastructure/utils/jsonParser.ts
-function repairCommonJsonDefects(text) {
-  return text.replace(/(:\s*-?\d+(?:\.\d+)?)\s*"/g, "$1").replace(/(:\s*"[^"]*")"/g, "$1");
-}
-function safeJSONParse(text, fallback, onError) {
-  try {
-    return JSON.parse(text);
-  } catch (error) {
-    try {
-      return JSON.parse(repairCommonJsonDefects(text));
-    } catch {
-    }
-    if (error instanceof SyntaxError) {
-      const positionMatch = error.message.match(/position (\d+)/);
-      const position = positionMatch ? parseInt(positionMatch[1], 10) : -1;
-      if (position > 0) {
-        text.substring(Math.max(0, position - 50), position + 50);
-      }
-    }
-    return fallback;
-  }
-}
-function extractJSON(text) {
-  const codeBlockMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/);
-  if (codeBlockMatch && codeBlockMatch[1]) {
-    const candidate = codeBlockMatch[1].trim();
-    if (candidate.startsWith("{") || candidate.startsWith("[")) {
-      return candidate;
-    }
-  }
-  const objectMatch = text.match(/\{[\s\S]*\}/);
-  if (objectMatch) {
-    return objectMatch[0];
-  }
-  const arrayMatch = text.match(/\[[\s\S]*\]/);
-  if (arrayMatch) {
-    return arrayMatch[0];
-  }
-  return null;
-}
-function parseAIResponse(response, fallback, onError) {
-  const json = extractJSON(response);
-  if (!json) {
-    return fallback;
-  }
-  return safeJSONParse(json, fallback);
-}
-
 // src/content/application/services/ImagePromptService.ts
-var JSON_ARRAY_PATTERN = /\[[\s\S]*\]/;
 var ImagePromptService = class {
   constructor(executor) {
     this.executor = executor;
@@ -3455,10 +3601,11 @@ var ImagePromptService = class {
   async generateImagePromptsForBlog(blogContent) {
     const truncated = truncateForBlogPromptPreview(validateContentBody(blogContent));
     const prompt = PromptBuilder.blogImagePrompts(truncated);
-    const response = await this.executor.runText(prompt, { maxTokens: 500, temperature: 0.8 });
-    const jsonMatch = response.match(JSON_ARRAY_PATTERN);
-    if (!jsonMatch) return [];
-    return safeJSONParse(jsonMatch[0], []);
+    const prompts = await this.executor.runJson(prompt, [], {
+      maxTokens: 500,
+      temperature: 0.8
+    });
+    return Array.isArray(prompts) ? prompts : [];
   }
 };
 
@@ -3502,11 +3649,16 @@ var ContentCalendarService = class {
     const validatedNiche = validateTopicText(niche);
     const validatedDays = validateCalendarDays(days);
     const prompt = PromptBuilder.contentCalendar(validatedNiche, validatedDays);
-    const data = await this.executor.runJson(prompt, [], {
-      maxTokens: estimateTokenBudgetForCalendarDays(validatedDays),
-      temperature: 0.8
-    });
-    return data.map(toCalendarEntry);
+    const data = await this.executor.runJson(
+      prompt,
+      [],
+      {
+        maxTokens: estimateTokenBudgetForCalendarDays(validatedDays),
+        temperature: 0.8
+      }
+    );
+    const items = Array.isArray(data) ? data : Array.isArray(data?.calendar) ? data.calendar : Array.isArray(data?.entries) ? data.entries : [];
+    return items.map(toCalendarEntry);
   }
 };
 
@@ -3554,6 +3706,54 @@ var MediaGenerationService = class {
   }
 };
 
+// src/content/infrastructure/utils/jsonParser.ts
+function repairCommonJsonDefects2(text) {
+  return text.replace(/(:\s*-?\d+(?:\.\d+)?)\s*"/g, "$1").replace(/(:\s*"[^"]*")"/g, "$1");
+}
+function safeJSONParse(text, fallback, onError) {
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    try {
+      return JSON.parse(repairCommonJsonDefects2(text));
+    } catch {
+    }
+    if (error instanceof SyntaxError) {
+      const positionMatch = error.message.match(/position (\d+)/);
+      const position = positionMatch ? parseInt(positionMatch[1], 10) : -1;
+      if (position > 0) {
+        text.substring(Math.max(0, position - 50), position + 50);
+      }
+    }
+    return fallback;
+  }
+}
+function extractJSON(text) {
+  const codeBlockMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+  if (codeBlockMatch && codeBlockMatch[1]) {
+    const candidate = codeBlockMatch[1].trim();
+    if (candidate.startsWith("{") || candidate.startsWith("[")) {
+      return candidate;
+    }
+  }
+  const objectMatch = text.match(/\{[\s\S]*\}/);
+  if (objectMatch) {
+    return objectMatch[0];
+  }
+  const arrayMatch = text.match(/\[[\s\S]*\]/);
+  if (arrayMatch) {
+    return arrayMatch[0];
+  }
+  return null;
+}
+function parseAIResponse(response, fallback, onError) {
+  const json = extractJSON(response);
+  if (!json) {
+    return fallback;
+  }
+  return safeJSONParse(json, fallback);
+}
+
 // src/content/application/services/GenerationExecutor.ts
 var GenerationExecutor = class {
   constructor(generator) {
@@ -3584,6 +3784,13 @@ var isTextGenerator = (value) => typeof value === "object" && value !== null &&
 function toAIProviderConfig(config) {
   const legacy = config;
   const modern = config;
+  const anthropic = modern.anthropic ?? (legacy.anthropic?.enabled ? {
+    apiKey: legacy.anthropic.apiKey,
+    baseUrl: legacy.anthropic.baseUrl,
+    timeoutMs: legacy.anthropic.timeout,
+    models: legacy.anthropic.models,
+    effort: legacy.anthropic.effort
+  } : void 0);
   const groq = modern.groq ?? (legacy.groq?.enabled ? {
     apiKey: legacy.groq.apiKey,
     baseUrl: legacy.groq.baseUrl,
@@ -3598,7 +3805,7 @@ function toAIProviderConfig(config) {
     priority: modern.priority,
     fallbackEnabled: modern.fallbackEnabled,
     defaultTier: modern.defaultTier,
-    anthropic: modern.anthropic,
+    ...anthropic ? { anthropic } : {},
     ...groq ? { groq } : {},
     ...gemini ? { gemini } : {},
     ...fal ? { fal } : {},