@umituz/web-ai 1.0.0 → 1.0.2

package/dist/hooks/index.cjs

@@ -5,6 +5,17 @@ var react = require('react');
 // src/hooks/useAIContent.ts
 
 // 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 || {});
 var USER_FRIENDLY_ERROR_MESSAGES = {
   ["INVALID_API_KEY" /* INVALID_API_KEY */]: "Please check your API key and try again.",
   ["MISSING_CONFIG" /* MISSING_CONFIG */]: "The provider is not configured. Please create a provider with createAI first.",
@@ -17,17 +28,80 @@ var USER_FRIENDLY_ERROR_MESSAGES = {
 };
 
 // src/core/errors/ai-error.ts
-var AIError = class extends Error {
+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";
+  if (lower.includes("unavailable")) return "PROVIDER_UNAVAILABLE";
+  if (lower.includes("timeout") || lower.includes("aborted")) {
+    return lower.includes("aborted") ? "ABORTED" : "TIMEOUT";
+  }
+  if (lower.includes("parse") || lower.includes("json")) return "PARSE_ERROR";
+  if (lower.includes("no result")) return "NO_RESULT";
+  if (lower.includes("network") || lower.includes("fetch")) return "NETWORK_ERROR";
+  return fallback;
+}
+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}`;
@@ -36,12 +110,21 @@ var AIError = class extends Error {
     return {
       name: this.name,
       type: this.type,
+      code: this.code,
       message: this.message,
       metadata: this.metadata
     };
   }
 };
 
+// src/core/errors/groq-error.ts
+var GroqError = class extends AIError {
+  constructor(type, message, cause, metadata = {}) {
+    super(type, message, cause, metadata);
+    this.name = "GroqError";
+  }
+};
+
 // src/core/errors/error-classifier.ts
 var DEFAULT_RETRYABLE_TYPES = /* @__PURE__ */ new Set([
   "NETWORK_ERROR" /* NETWORK_ERROR */,
@@ -224,12 +307,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();
@@ -245,18 +332,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 };
@@ -403,15 +495,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;
@@ -420,7 +519,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) {
@@ -428,8 +527,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
@@ -438,12 +556,17 @@ var JsonResponseParser = class {
     const candidate = extractJsonCandidate(rawContent);
     try {
       return JSON.parse(candidate);
-    } catch (error) {
-      throw new AIError(
-        "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 }
+        );
+      }
     }
   }
 };
@@ -757,11 +880,14 @@ async function consumeAnthropicStream(stream, callbacks) {
         break;
       case "message_stop":
         break;
-      case "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(
-          event.error.type === "rate_limit_error" ? "RATE_LIMIT_ERROR" /* RATE_LIMIT_ERROR */ : "SERVER_ERROR" /* SERVER_ERROR */,
+          mappedType,
           event.error.message || "Anthropic stream failed mid-flight"
         );
+      }
     }
   };
   try {
@@ -1223,6 +1349,27 @@ var RequestDeduplicator = class {
   }
 };
 
+// src/core/utils/api-key-validator.ts
+var DEFAULT_API_KEY_RULE = {
+  minLength: 10
+};
+function validateApiKey(apiKey, rule = DEFAULT_API_KEY_RULE) {
+  if (!apiKey) {
+    return { valid: false, reason: "API key is required" };
+  }
+  const trimmed = apiKey.trim();
+  if (trimmed.length === 0) {
+    return { valid: false, reason: "API key cannot be empty" };
+  }
+  if (trimmed.length < rule.minLength) {
+    return {
+      valid: false,
+      reason: `API key must be at least ${rule.minLength} characters`
+    };
+  }
+  return { valid: true };
+}
+
 // src/providers/groq/groq.constants.ts
 var GROQ_MODELS = {
   LLAMA_3_1_8B_INSTANT: "llama-3.1-8b-instant",
@@ -1239,11 +1386,13 @@ var DEFAULT_GENERATION_CONFIG = {
   topP: 1
 };
 var GROQ_BASE_URL = "https://api.groq.com/openai/v1";
+var DEFAULT_BASE_URL = GROQ_BASE_URL;
 var CHAT_COMPLETIONS_PATH = "/chat/completions";
 var GROQ_TIMEOUTS = {
   DEFAULT: 3e4,
   STREAMING: 6e4
 };
+var TIMEOUTS = GROQ_TIMEOUTS;
 var HTTP_HEADERS = {
   CONTENT_TYPE: "Content-Type",
   APPLICATION_JSON: "application/json",
@@ -1302,13 +1451,65 @@ var GroqChatRequestBuilder = class _GroqChatRequestBuilder {
   }
 };
 
+// src/providers/groq/groq-config-store.ts
+var GroqConfigStore = class {
+  config = null;
+  initialize(config) {
+    const validation = validateApiKey(config.apiKey, { minLength: 1 });
+    if (!validation.valid) {
+      throw new GroqError("INVALID_API_KEY" /* INVALID_API_KEY */, validation.reason ?? "Invalid API key");
+    }
+    const normalized = {
+      apiKey: config.apiKey.trim(),
+      baseUrl: config.baseUrl ?? DEFAULT_BASE_URL,
+      timeoutMs: config.timeoutMs ?? TIMEOUTS.DEFAULT,
+      ...config.models !== void 0 ? { models: config.models } : {},
+      ...config.textModel !== void 0 ? { textModel: config.textModel } : {}
+    };
+    this.config = normalized;
+    return normalized;
+  }
+  get() {
+    if (!this.config) {
+      throw new GroqError(
+        "MISSING_CONFIG" /* MISSING_CONFIG */,
+        "Client not initialized. Call configureProvider first."
+      );
+    }
+    return this.config;
+  }
+  getOrNull() {
+    return this.config;
+  }
+  isInitialized() {
+    return this.config !== null;
+  }
+  setApiKey(apiKey) {
+    const current = this.get();
+    const validation = validateApiKey(apiKey, { minLength: 1 });
+    if (!validation.valid) {
+      throw new GroqError("INVALID_API_KEY" /* INVALID_API_KEY */, validation.reason ?? "Invalid API key");
+    }
+    this.config = { ...current, apiKey: apiKey.trim() };
+  }
+  reset() {
+    this.config = null;
+  }
+};
+
 // src/providers/groq/groq-http-transport.ts
 var GroqHttpTransport = class {
-  constructor(config) {
-    this.config = config;
+  constructor(configSource) {
+    this.configSource = configSource;
   }
-  config;
+  configSource;
   pendingAbortControllers = /* @__PURE__ */ new Set();
+  getConfig() {
+    if ("get" in this.configSource && typeof this.configSource.get === "function") {
+      return this.configSource.get();
+    }
+    return this.configSource;
+  }
   cancelPendingRequests() {
     for (const controller of this.pendingAbortControllers) {
       controller.abort();
@@ -1323,7 +1524,7 @@ var GroqHttpTransport = class {
   }
   async streamChatCompletion(request, options = {}) {
     const url = `${this.baseUrl()}${CHAT_COMPLETIONS_PATH}`;
-    const timeout = this.config.timeoutMs ?? GROQ_TIMEOUTS.STREAMING;
+    const timeout = this.getConfig().timeoutMs ?? GROQ_TIMEOUTS.STREAMING;
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), timeout);
     const onExternalAbort = () => controller.abort();
@@ -1350,11 +1551,11 @@ var GroqHttpTransport = class {
     }
   }
   baseUrl() {
-    return this.config.baseUrl ?? GROQ_BASE_URL;
+    return this.getConfig().baseUrl ?? GROQ_BASE_URL;
   }
   async request(endpoint, body) {
     const url = `${this.baseUrl()}${endpoint}`;
-    const timeout = this.config.timeoutMs ?? GROQ_TIMEOUTS.DEFAULT;
+    const timeout = this.getConfig().timeoutMs ?? GROQ_TIMEOUTS.DEFAULT;
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), timeout);
     this.pendingAbortControllers.add(controller);
@@ -1377,7 +1578,7 @@ var GroqHttpTransport = class {
   buildHeaders() {
     return {
       [HTTP_HEADERS.CONTENT_TYPE]: HTTP_HEADERS.APPLICATION_JSON,
-      [HTTP_HEADERS.AUTHORIZATION]: `${HTTP_HEADERS.BEARER_PREFIX}${this.config.apiKey}`
+      [HTTP_HEADERS.AUTHORIZATION]: `${HTTP_HEADERS.BEARER_PREFIX}${this.getConfig().apiKey}`
     };
   }
   async throwFromErrorResponse(response) {
@@ -1479,21 +1680,40 @@ var CompositeExecutor = class {
 
 // src/providers/groq/groq-http-client.ts
 var GroqHttpClient = class {
+  configStore;
   transport;
   executor;
-  constructor(config, deps = {}) {
-    this.transport = deps.transport ?? new GroqHttpTransport(config);
+  constructor(configOrDeps, maybeDeps = {}) {
+    const isConfig = typeof configOrDeps === "object" && configOrDeps !== null && "apiKey" in configOrDeps && typeof configOrDeps.apiKey === "string";
+    const deps = isConfig ? maybeDeps : configOrDeps ?? {};
+    this.configStore = deps.configStore ?? new GroqConfigStore();
+    if (isConfig) {
+      this.configStore.initialize(configOrDeps);
+    }
+    this.transport = deps.transport ?? new GroqHttpTransport(this.configStore);
     const retryManager2 = deps.retryManager ?? new RetryManager();
     const queue = deps.queue ?? new RequestQueue();
     const deduplicator = deps.deduplicator ?? new RequestDeduplicator();
     this.executor = new CompositeExecutor([
       new DedupeExecutor(deduplicator, {
-        generateKey: (request) => deduplicatorKey(request, config.apiKey)
+        generateKey: (request) => deduplicatorKey(request, this.configStore.isInitialized() ? this.configStore.get().apiKey : "")
       }),
       new RetryExecutor(retryManager2),
       new QueueExecutor(queue, QUEUE_PRIORITY_USER_REQUEST)
     ]);
   }
+  initialize(config) {
+    this.configStore.initialize(config);
+  }
+  isInitialized() {
+    return this.configStore.isInitialized();
+  }
+  getApiKey() {
+    return this.configStore.get().apiKey;
+  }
+  setApiKey(apiKey) {
+    this.configStore.setApiKey(apiKey);
+  }
   cancelPendingRequests() {
     this.transport.cancelPendingRequests();
   }
@@ -1506,6 +1726,10 @@ var GroqHttpClient = class {
   streamChatCompletion(request, options) {
     return this.transport.streamChatCompletion(request, options);
   }
+  reset() {
+    this.transport.cancelPendingRequests();
+    this.configStore.reset();
+  }
 };
 function deduplicatorKey(request, apiKey) {
   const { model, messages, stream: _stream, ...rest } = request;
@@ -1553,6 +1777,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;
@@ -1567,13 +1798,6 @@ async function consumeGroqStream(stream, callbacks) {
     if (tailUsage) {
       usage = mapGroqUsage(tailUsage);
     }
-    const errorBody = chunk.error;
-    if (errorBody) {
-      throw new AIError(
-        "SERVER_ERROR" /* SERVER_ERROR */,
-        errorBody.message || "Groq stream failed mid-flight"
-      );
-    }
   };
   try {
     while (true) {
@@ -1774,37 +1998,7 @@ function findLastIndex2(items, predicate) {
 }
 
 // src/content/domain/errors/AIErrors.ts
-var AIError2 = 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) {
-  const lower = message.toLowerCase();
-  if (lower.includes("validation")) return "VALIDATION_ERROR";
-  if (lower.includes("quota")) return "PROVIDER_QUOTA_EXHAUSTED";
-  if (lower.includes("unavailable")) return "PROVIDER_UNAVAILABLE";
-  if (lower.includes("timeout") || lower.includes("aborted")) {
-    return lower.includes("aborted") ? "ABORTED" : "TIMEOUT";
-  }
-  if (lower.includes("parse") || lower.includes("json")) return "PARSE_ERROR";
-  if (lower.includes("no result")) return "NO_RESULT";
-  if (lower.includes("network") || lower.includes("fetch")) return "NETWORK_ERROR";
-  return fallback;
-}
-var ValidationError = class extends AIError2 {
+var ValidationError = class extends AIError {
   constructor(message) {
     super(message, "VALIDATION_ERROR");
     this.name = "ValidationError";
@@ -1935,7 +2129,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";
     }
@@ -1946,6 +2142,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`,
@@ -1953,22 +2151,28 @@ 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 AIError("SERVER_ERROR" /* SERVER_ERROR */, "No content generated from Gemini API", void 0, { model });
       }
@@ -1981,7 +2185,7 @@ 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 AIError) throw error;
@@ -2033,12 +2237,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 {
@@ -2467,17 +2677,70 @@ var PrunaProvider = class {
   async estimateCost(_request) {
     return 1;
   }
-  async generateImage(_request) {
-    throw new AIError("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 AIError("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 AIError("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 AIError("UNKNOWN_ERROR" /* UNKNOWN_ERROR */, "Use generateWithPruna instead");
+    throw new AIError("CLIENT_ERROR" /* CLIENT_ERROR */, "Pruna AI provider does not support video-to-video conversion");
   }
 };
 
@@ -3084,11 +3347,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 {
@@ -3283,7 +3547,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);
@@ -3378,68 +3641,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;
@@ -3453,10 +3668,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 : [];
   }
 };
 
@@ -3500,22 +3716,27 @@ 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);
   }
 };
 
 // src/content/application/services/ProviderServices.ts
 var wrapProviderError = (operation, error) => {
   const message = error instanceof Error ? error.message : "Unknown error";
-  return new AIError2(`${operation} failed: ${message}`, "PROVIDER_ERROR", error);
+  return new AIError(`${operation} failed: ${message}`, "PROVIDER_ERROR", error);
 };
 var ensureFactory = (factory, operation) => {
   if (factory.getAllProviders().length === 0) {
-    throw new AIError2(
+    throw new AIError(
       `${operation} failed: No providers are registered. Provide a ProviderConfig with at least one enabled provider when constructing AIContentService.`,
       "PROVIDER_UNAVAILABLE"
     );
@@ -3552,6 +3773,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) {
@@ -3568,7 +3837,7 @@ var GenerationExecutor = class {
   /** Usage-complete pass-through; requires a ProviderFactory engine. */
   runChat(request) {
     if (!(this.generator instanceof ProviderFactory)) {
-      throw new AIError2(
+      throw new AIError(
         "runChat requires a ProviderFactory engine \u2014 construct AIContentService with a provider config, not a custom ITextGenerator",
         "PROVIDER_UNAVAILABLE"
       );
@@ -3582,6 +3851,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,
@@ -3596,7 +3872,7 @@ function toAIProviderConfig(config) {
     priority: modern.priority,
     fallbackEnabled: modern.fallbackEnabled,
     defaultTier: modern.defaultTier,
-    anthropic: modern.anthropic,
+    ...anthropic ? { anthropic } : {},
     ...groq ? { groq } : {},
     ...gemini ? { gemini } : {},
     ...fal ? { fal } : {},
@@ -3762,8 +4038,8 @@ function useAIContentContext(options) {
     callbacksRef.current?.onProgress?.(value);
   }, []);
   const reportError = react.useCallback((err, fallbackMessage) => {
-    const aiError = AIError2.from(err, "UNKNOWN");
-    const finalError = aiError.message ? aiError : new AIError2(fallbackMessage, "UNKNOWN", err);
+    const aiError = AIError.from(err, "UNKNOWN");
+    const finalError = aiError.message ? aiError : new AIError(fallbackMessage, "UNKNOWN", err);
     if (mountedRef.current) {
       setError(finalError.message);
       setErrorCode(finalError.code);
@@ -3789,7 +4065,7 @@ function useAIContentContext(options) {
         }
         return result;
       } catch (err) {
-        const aiError = AIError2.from(err, "UNKNOWN");
+        const aiError = AIError.from(err, "UNKNOWN");
         if (aiError.message) {
           reportError(aiError, fallbackMessage);
         } else {
@@ -4353,10 +4629,13 @@ function useWizardFlow(options) {
     if (steps.length <= 1) return 0;
     return Math.round(currentIndex / (steps.length - 1) * 100);
   }, [currentIndex, steps.length]);
+  const completedRef = react.useRef(false);
   const navigateTo = react.useCallback((to) => {
     setCurrentStep((prev) => {
       if (prev === to) return prev;
-      optionsRef.current.onStepChange?.(prev, to);
+      queueMicrotask(() => {
+        optionsRef.current.onStepChange?.(prev, to);
+      });
       return to;
     });
   }, []);
@@ -4397,13 +4676,17 @@ function useWizardFlow(options) {
     [currentIndex, steps.length]
   );
   const reset = react.useCallback(() => {
+    completedRef.current = false;
     setCurrentStep(optionsRef.current.initialStep);
     setWizardData({});
     setIsProcessing(false);
   }, []);
   react.useEffect(() => {
-    if (currentIndex === steps.length - 1 && steps.length > 0) {
+    if (currentIndex === steps.length - 1 && steps.length > 0 && !completedRef.current) {
+      completedRef.current = true;
       optionsRef.current.onComplete?.(wizardData);
+    } else if (currentIndex < steps.length - 1) {
+      completedRef.current = false;
     }
   }, [currentIndex, steps.length, wizardData]);
   return {
@@ -4632,21 +4915,17 @@ function useText(options = {}, deps) {
     ]
   );
   react.useEffect(() => {
-    const controller = new AbortController();
-    abortControllerRef.current = controller;
     return () => {
-      controller.abort();
+      abortControllerRef.current?.abort();
       abortControllerRef.current = null;
     };
   }, []);
   const runWithState = react.useCallback(
     async (task) => {
-      const controller = abortControllerRef.current;
-      if (!controller) {
-        return null;
-      }
+      abortControllerRef.current?.abort();
+      const controller = new AbortController();
+      abortControllerRef.current = controller;
       const { signal } = controller;
-      if (signal.aborted) return null;
       setIsLoading(true);
       setError(null);
       setResult(null);
@@ -4667,6 +4946,9 @@ function useText(options = {}, deps) {
         if (!signal.aborted) {
           setIsLoading(false);
         }
+        if (abortControllerRef.current === controller) {
+          abortControllerRef.current = null;
+        }
       }
     },
     []
@@ -4731,6 +5013,7 @@ function useText(options = {}, deps) {
   );
   const cancel = react.useCallback(() => {
     abortControllerRef.current?.abort();
+    abortControllerRef.current = null;
     setIsLoading(false);
   }, []);
   const reset = react.useCallback(() => {
@@ -4873,10 +5156,8 @@ function useChat(options, deps) {
     };
   }, [conversationId, surfaceError]);
   react.useEffect(() => {
-    const controller = new AbortController();
-    abortControllerRef.current = controller;
     return () => {
-      controller.abort();
+      abortControllerRef.current?.abort();
       abortControllerRef.current = null;
     };
   }, []);
@@ -4917,9 +5198,11 @@ function useChat(options, deps) {
       });
       void persist(userMessage);
       callbacksRef.current.onMessageSent?.(userMessage);
+      let streamingPlaceholderId = null;
       try {
         if (streamEnabled) {
           const placeholderId = chatIdGenerator.next("assistant");
+          streamingPlaceholderId = placeholderId;
           const placeholder = {
             id: placeholderId,
             sender: "assistant",
@@ -4938,7 +5221,8 @@ function useChat(options, deps) {
                   (m) => m.id === placeholderId ? { ...m, content: m.content + chunk } : m
                 )
               );
-            }
+            },
+            controller.signal
           );
           const finalMessage = {
             ...placeholder,
@@ -4955,13 +5239,18 @@ function useChat(options, deps) {
         const aiResponse = await chatService.generateAIResponse(
           conversationId,
           trimmed,
-          contextForAI
+          contextForAI,
+          controller.signal
         );
         setMessages((prev) => [...prev, aiResponse]);
         void persist(aiResponse);
         callbacksRef.current.onAIResponse?.(aiResponse);
         return aiResponse;
       } catch (err) {
+        if (streamingPlaceholderId) {
+          const failedId = streamingPlaceholderId;
+          setMessages((prev) => prev.filter((m) => m.id !== failedId));
+        }
         surfaceError(err);
         return null;
       } finally {
@@ -4987,6 +5276,9 @@ function useChat(options, deps) {
     const lastUserMessage = [...currentMessages].reverse().find((m) => m.sender === "user");
     if (!lastUserMessage) return null;
     const trimmed = currentMessages.length > 0 && currentMessages[currentMessages.length - 1].sender === "assistant" ? currentMessages.slice(0, -1) : currentMessages;
+    const controller = new AbortController();
+    abortControllerRef.current?.abort();
+    abortControllerRef.current = controller;
     setIsLoading(true);
     setError(null);
     setIsTyping(true);
@@ -4994,7 +5286,8 @@ function useChat(options, deps) {
       const aiResponse = await chatService.generateAIResponse(
         conversationId,
         lastUserMessage.content,
-        trimmed
+        trimmed,
+        controller.signal
       );
       setMessages((prev) => {
         const lastIsAI = prev.length > 0 && prev[prev.length - 1].sender === "assistant";
@@ -5010,6 +5303,9 @@ function useChat(options, deps) {
     } finally {
       setIsLoading(false);
       setIsTyping(false);
+      if (abortControllerRef.current === controller) {
+        abortControllerRef.current = null;
+      }
     }
   }, [chatService, conversationId, isLoading, messages, persist, surfaceError]);
   const clearMessages = react.useCallback(() => {
@@ -5042,12 +5338,168 @@ function useChat(options, deps) {
   };
 }
 
+// src/providers/groq/groq-container.ts
+var container = null;
+function getProvider() {
+  return container;
+}
+
+// src/hooks/use-groq.hook.ts
+function useGroq(options = {}, deps) {
+  const textGeneration = deps?.textGeneration ?? getProvider()?.textGeneration;
+  if (!textGeneration) {
+    throw new Error(
+      "useGroq requires a TextGenerationService dependency. Provide it via the second argument or wire it through configureProvider()."
+    );
+  }
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [result, setResult] = react.useState(null);
+  const optionsRef = react.useRef(options);
+  optionsRef.current = options;
+  const abortControllerRef = react.useRef(null);
+  const getOrCreateAbortController = react.useCallback(() => {
+    if (!abortControllerRef.current || abortControllerRef.current.signal.aborted) {
+      abortControllerRef.current = new AbortController();
+    }
+    return abortControllerRef.current;
+  }, []);
+  const stableConfig = react.useMemo(
+    () => ({
+      model: options.model,
+      generationConfig: options.generationConfig
+    }),
+    [
+      options.model,
+      options.generationConfig?.temperature,
+      options.generationConfig?.maxTokens,
+      options.generationConfig?.topP
+    ]
+  );
+  react.useEffect(() => {
+    abortControllerRef.current = new AbortController();
+    return () => {
+      abortControllerRef.current?.abort();
+      abortControllerRef.current = null;
+    };
+  }, []);
+  const runWithState = react.useCallback(
+    async (task) => {
+      const controller = getOrCreateAbortController();
+      const { signal } = controller;
+      if (signal.aborted) return null;
+      setIsLoading(true);
+      setError(null);
+      setResult(null);
+      const currentOptions = optionsRef.current;
+      currentOptions.onStart?.();
+      try {
+        const value = await task(signal);
+        return value;
+      } catch (err) {
+        if (signal.aborted) {
+          return null;
+        }
+        const message = resolveUserFriendlyMessage(err);
+        setError(message);
+        currentOptions.onError?.(message);
+        throw err;
+      } finally {
+        if (!signal.aborted) {
+          setIsLoading(false);
+        }
+      }
+    },
+    [getOrCreateAbortController]
+  );
+  const generate = react.useCallback(
+    (prompt, config) => runWithState(async () => {
+      const response = await textGeneration.generateCompletion(prompt, {
+        model: stableConfig.model,
+        generationConfig: {
+          ...stableConfig.generationConfig,
+          ...config
+        }
+      });
+      setResult(response);
+      optionsRef.current.onSuccess?.(response);
+      return response;
+    }),
+    [runWithState, textGeneration, stableConfig]
+  );
+  const generateJSON = react.useCallback(
+    (prompt, config) => runWithState(async () => {
+      const response = await textGeneration.generateStructured(prompt, {
+        model: stableConfig.model,
+        generationConfig: {
+          ...stableConfig.generationConfig,
+          ...config
+        },
+        ...config?.schema !== void 0 ? { schema: config.schema } : {}
+      });
+      const json = JSON.stringify(response, null, 2);
+      setResult(json);
+      optionsRef.current.onSuccess?.(json);
+      return response;
+    }),
+    [runWithState, textGeneration, stableConfig]
+  );
+  const stream = react.useCallback(
+    (prompt, onChunk, config) => runWithState(async () => {
+      const callbacks = {
+        onChunk,
+        onComplete: (text) => {
+          setResult(text);
+          optionsRef.current.onSuccess?.(text);
+        }
+      };
+      return textGeneration.streamCompletion(
+        prompt,
+        callbacks,
+        {
+          model: stableConfig.model,
+          generationConfig: {
+            ...stableConfig.generationConfig,
+            ...config
+          }
+        }
+      );
+    }),
+    [runWithState, textGeneration, stableConfig]
+  );
+  const cancel = react.useCallback(() => {
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+      abortControllerRef.current = new AbortController();
+    }
+    setIsLoading(false);
+  }, []);
+  const reset = react.useCallback(() => {
+    cancel();
+    setError(null);
+    setResult(null);
+  }, [cancel]);
+  const clearError = react.useCallback(() => setError(null), []);
+  return {
+    isLoading,
+    error,
+    result,
+    generate,
+    generateJSON,
+    stream,
+    cancel,
+    reset,
+    clearError
+  };
+}
+
 exports.useAIContent = useAIContent;
 exports.useAIGeneration = useAIGeneration;
 exports.useBlogGenerator = useBlogGenerator;
 exports.useCacheStats = useCacheStats;
 exports.useChat = useChat;
 exports.useContentWizard = useContentWizard;
+exports.useGroq = useGroq;
 exports.useImageWizard = useImageWizard;
 exports.useSocialContentGenerator = useSocialContentGenerator;
 exports.useText = useText;