@umituz/web-ai 1.0.0 → 1.0.2

package/dist/index.cjs

@@ -43,17 +43,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}`;
@@ -62,12 +125,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 */,
@@ -346,6 +418,8 @@ function calculateExponentialBackoff(params) {
 // src/core/constants/identifier.constants.ts
 var MESSAGE_ID_PREFIX = "msg-";
 var CHAT_MESSAGE_ID_SUFFIX_LENGTH = 9;
+var CACHE_KEY_TYPE_COMPLETION = "completion";
+var CACHE_KEY_TYPE_CHAT = "chat";
 var USER_ROLE = "user";
 var ASSISTANT_ROLE = "assistant";
 var QUEUE_PRIORITY_USER_REQUEST = 10;
@@ -750,15 +824,22 @@ function oneOfCatalog(catalog, value) {
 // 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;
@@ -830,7 +911,7 @@ var StreamingResponseParser = class {
 // 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) {
@@ -838,8 +919,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
@@ -848,12 +948,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 }
+        );
+      }
     }
   }
 };
@@ -979,38 +1084,6 @@ function isMediaProvider(provider) {
   return provider.capabilities.includes("image") || provider.capabilities.includes("video");
 }
 
-// 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;
-}
-
 // src/content/domain/limits/ProviderTimingConfig.ts
 var ProviderTimingConfig = {
   DEFAULT_TIMEOUT_MS: 3e4,
@@ -1075,7 +1148,7 @@ var BaseProvider = class {
     throw lastError || new Error("Retry attempts exhausted");
   }
 };
-var ProviderError = class extends AIError2 {
+var ProviderError = class extends AIError {
   constructor(message, providerId, originalError) {
     super(message, "PROVIDER_ERROR", originalError);
     this.providerId = providerId;
@@ -1169,12 +1242,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();
@@ -1190,18 +1267,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 };
@@ -1610,11 +1692,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 {
@@ -1806,12 +1891,22 @@ var DEFAULT_GENERATION_CONFIG = {
   maxTokens: 1024,
   topP: 1
 };
+var DEFAULT_MODELS = {
+  TEXT: GROQ_MODELS.LLAMA_3_1_8B_INSTANT,
+  FAST: GROQ_MODELS.LLAMA_3_1_8B_INSTANT,
+  EXPERIMENTAL: GROQ_MODELS.GPT_OSS_20B
+};
 var GROQ_BASE_URL = "https://api.groq.com/openai/v1";
+var DEFAULT_BASE_URL = GROQ_BASE_URL;
 var CHAT_COMPLETIONS_PATH = "/chat/completions";
+var API_ENDPOINTS = {
+  CHAT: CHAT_COMPLETIONS_PATH
+};
 var GROQ_TIMEOUTS = {
   DEFAULT: 3e4,
   STREAMING: 6e4
 };
+var TIMEOUTS = GROQ_TIMEOUTS;
 var HTTP_HEADERS = {
   CONTENT_TYPE: "Content-Type",
   APPLICATION_JSON: "application/json",
@@ -1870,13 +1965,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();
@@ -1891,7 +2038,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();
@@ -1918,11 +2065,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);
@@ -1945,7 +2092,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) {
@@ -1989,21 +2136,40 @@ var GroqHttpTransport = 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();
   }
@@ -2016,6 +2182,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;
@@ -2072,6 +2242,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;
@@ -2086,13 +2263,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) {
@@ -2359,7 +2529,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";
     }
@@ -2370,6 +2542,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`,
@@ -2377,22 +2551,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 });
       }
@@ -2405,7 +2585,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;
@@ -2457,12 +2637,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 {
@@ -2781,17 +2967,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");
   }
 };
 function createPrunaProvider(config) {
@@ -2823,6 +3062,278 @@ function createAI(config = {}) {
   return factory;
 }
 
+// src/providers/groq/groq-messages.ts
+var createUserMessage = (content) => ({
+  role: "user",
+  content
+});
+var createAssistantMessage = (content) => ({
+  role: "assistant",
+  content
+});
+var createSystemMessage = (content) => ({
+  role: "system",
+  content
+});
+var createMessage = (role, content) => ({
+  role,
+  content
+});
+var promptToMessages = (prompt) => [
+  createUserMessage(prompt)
+];
+var extractTextFromMessages = (messages) => messages.map((m) => m.content).join("\n\n");
+var formatMessagesForDisplay = (messages) => messages.map((m) => `[${m.role.toUpperCase()}]: ${m.content}`).join("\n\n---\n\n");
+
+// src/providers/groq/groq-structured-json.ts
+async function requestStructuredJson(client, request) {
+  const chatRequest = {
+    model: request.model,
+    messages: [createUserMessage(request.instructions)],
+    temperature: request.temperature,
+    max_tokens: request.maxTokens,
+    response_format: { type: "json_object" },
+    ...request.reasoningEffort !== void 0 ? { reasoning_effort: request.reasoningEffort } : {}
+  };
+  const response = await client.postChatCompletion(chatRequest);
+  const content = response.choices[0]?.message?.content ?? "";
+  const candidate = extractJsonCandidate(content);
+  try {
+    return JSON.parse(candidate);
+  } catch (err) {
+    throw new GroqError(
+      "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+      "model response contained no parsable json object",
+      err instanceof Error ? err : void 0
+    );
+  }
+}
+
+// src/providers/groq/text-generation.service.ts
+var STRUCTURED_OUTPUT_TEMPERATURE = 0.1;
+var TextGenerationService = class {
+  constructor(httpClient, cache = new CacheManager(), defaultModel = DEFAULT_MODELS.TEXT) {
+    this.httpClient = httpClient;
+    this.cache = cache;
+    this.defaultModel = defaultModel;
+  }
+  httpClient;
+  cache;
+  defaultModel;
+  id = "groq-text-generation";
+  name = "Groq Text Generation";
+  capabilities = ["text"];
+  jsonParser = new JsonResponseParser();
+  generateCompletion(prompt, options = {}) {
+    const model = options.model ?? this.defaultModel;
+    return this.executeWithCache(
+      {
+        type: CACHE_KEY_TYPE_COMPLETION,
+        model,
+        prompt,
+        config: options.generationConfig
+      },
+      async () => {
+        const request = GroqChatRequestBuilder.for(model).withMessages([createUserMessage(prompt)]).withConfig(options.generationConfig).build();
+        const response = await this.httpClient.postChatCompletion(request);
+        return this.extractContent(response.choices[0]?.message?.content);
+      }
+    );
+  }
+  generateChatCompletion(messages, options = {}) {
+    const model = options.model ?? this.defaultModel;
+    return this.executeWithCache(
+      {
+        type: CACHE_KEY_TYPE_CHAT,
+        model,
+        messages: [...messages],
+        config: options.generationConfig
+      },
+      async () => {
+        const request = GroqChatRequestBuilder.for(model).withMessages(messages).withConfig(options.generationConfig).build();
+        const response = await this.httpClient.postChatCompletion(request);
+        return this.extractContent(response.choices[0]?.message?.content);
+      }
+    );
+  }
+  generateStructured(promptOrRequest, options) {
+    if (typeof promptOrRequest === "string") {
+      const model2 = options?.model ?? this.defaultModel;
+      const jsonPrompt = StructuredPromptBuilder.for(promptOrRequest).withSchema(options?.schema).build();
+      const request = GroqChatRequestBuilder.for(model2).withMessages([createUserMessage(jsonPrompt)]).withConfig({
+        ...options?.generationConfig,
+        temperature: STRUCTURED_OUTPUT_TEMPERATURE
+      }).build();
+      return this.httpClient.postChatCompletion(request).then((response) => {
+        const content = this.extractContent(response.choices[0]?.message?.content);
+        return this.jsonParser.parse(content);
+      });
+    }
+    const req = promptOrRequest;
+    const model = req.model ?? (req.tier ? this.resolveModel(req.tier) : this.defaultModel);
+    const schemaObj = req.schema;
+    const messages = [];
+    if (req.systemPrompt) {
+      messages.push({ role: "system", content: req.systemPrompt });
+    }
+    for (const m of req.messages) {
+      messages.push({ role: m.role, content: m.content });
+    }
+    const lastMsg = messages[messages.length - 1];
+    if (lastMsg) {
+      const structuredPrompt = StructuredPromptBuilder.for(lastMsg.content).withSchema(schemaObj).build();
+      messages[messages.length - 1] = { ...lastMsg, content: structuredPrompt };
+    }
+    const groqReq = GroqChatRequestBuilder.for(model).withMessages(messages).withConfig({
+      temperature: req.temperature ?? STRUCTURED_OUTPUT_TEMPERATURE,
+      maxTokens: req.maxTokens
+    }).build();
+    return this.httpClient.postChatCompletion(groqReq).then((response) => {
+      const content = this.extractContent(response.choices[0]?.message?.content);
+      const parsed = this.jsonParser.parse(content);
+      const genResult = {
+        text: content,
+        model: response.model,
+        providerId: this.id,
+        finishReason: response.choices[0]?.finish_reason ?? "stop",
+        usage: response.usage ? {
+          inputTokens: response.usage.prompt_tokens,
+          outputTokens: response.usage.completion_tokens,
+          totalTokens: response.usage.total_tokens
+        } : void 0
+      };
+      return { value: parsed, result: genResult };
+    });
+  }
+  streamCompletion(prompt, callbacks, options = {}) {
+    return this.streamChatCompletion([createUserMessage(prompt)], callbacks, options);
+  }
+  async streamChatCompletion(messages, callbacks, options = {}) {
+    const model = options.model ?? this.defaultModel;
+    const request = GroqChatRequestBuilder.for(model).withMessages(messages).withConfig(options.generationConfig).withStream(true).build();
+    const parser = new StreamingResponseParser(
+      {
+        onChunk: (chunk) => callbacks.onChunk?.(chunk)
+      },
+      extractContentFromSsePayload
+    );
+    try {
+      const stream = await this.httpClient.streamChatCompletion(request, {
+        signal: options.signal
+      });
+      const fullText = await parser.parse(stream);
+      callbacks.onComplete?.(fullText);
+      return fullText;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      callbacks.onError?.(err);
+      throw err;
+    }
+  }
+  clearCache() {
+    this.cache.clear();
+  }
+  // --- ITextProvider implementation ---
+  resolveModel(tier) {
+    return GROQ_TIERS[tier] ?? this.defaultModel;
+  }
+  async generate(request) {
+    const messages = [];
+    if (request.systemPrompt) {
+      messages.push({ role: "system", content: request.systemPrompt });
+    }
+    for (const m of request.messages) {
+      messages.push({ role: m.role, content: m.content });
+    }
+    const model = request.model ?? (request.tier ? this.resolveModel(request.tier) : this.defaultModel);
+    const groqReq = GroqChatRequestBuilder.for(model).withMessages(messages).withConfig({
+      temperature: request.temperature,
+      maxTokens: request.maxTokens
+    }).build();
+    const resp = await this.httpClient.postChatCompletion(groqReq);
+    const content = resp.choices[0]?.message?.content ?? "";
+    return {
+      text: content,
+      finishReason: resp.choices[0]?.finish_reason ?? "stop",
+      model: resp.model,
+      providerId: this.id,
+      usage: resp.usage ? {
+        inputTokens: resp.usage.prompt_tokens,
+        outputTokens: resp.usage.completion_tokens,
+        totalTokens: resp.usage.total_tokens
+      } : void 0
+    };
+  }
+  async stream(request, callbacks) {
+    const messages = [];
+    if (request.systemPrompt) {
+      messages.push({ role: "system", content: request.systemPrompt });
+    }
+    for (const m of request.messages) {
+      messages.push({ role: m.role, content: m.content });
+    }
+    const model = request.model ?? (request.tier ? this.resolveModel(request.tier) : this.defaultModel);
+    const text = await this.streamChatCompletion(
+      messages,
+      {
+        onChunk: callbacks.onChunk,
+        onError: callbacks.onError
+      },
+      {
+        model,
+        signal: request.signal,
+        generationConfig: {
+          temperature: request.temperature,
+          maxTokens: request.maxTokens
+        }
+      }
+    );
+    const result = {
+      text,
+      finishReason: "stop",
+      model,
+      providerId: this.id
+    };
+    callbacks.onComplete?.(result);
+    return result;
+  }
+  async countTokens(text) {
+    return Math.max(1, Math.ceil(text.length / 4));
+  }
+  async estimateCost(_request) {
+    return 0;
+  }
+  async healthCheck() {
+    try {
+      await this.generateCompletion("ping", {
+        generationConfig: { maxTokens: 1 }
+      });
+      return "healthy";
+    } catch {
+      return "unavailable";
+    }
+  }
+  async executeWithCache(params, factory) {
+    const key = this.cache.generateKey(params);
+    const cached = this.cache.get(key);
+    if (cached !== null) {
+      return cached;
+    }
+    const result = await factory();
+    this.cache.set(key, result);
+    return result;
+  }
+  extractContent(content) {
+    if (!content) {
+      throw new GroqError(
+        "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+        "No content generated from Groq API"
+      );
+    }
+    return content;
+  }
+};
+
 // src/core/calculations/random-base36-suffix.ts
 var BASE_36_RADIX = 36;
 var DECIMAL_OFFSET = 2;
@@ -2943,9 +3454,12 @@ var ChatService = class {
     };
   }
   async getConversations() {
+    if (this.storage && "getConversations" in this.storage && typeof this.storage.getConversations === "function") {
+      return this.storage.getConversations();
+    }
     return [];
   }
-  async sendMessage(input) {
+  async sendMessage(input, signal) {
     const userMessage = {
       ...messageFormatter.toChatMessage(input.text, "user"),
       type: input.type ?? "text",
@@ -2954,13 +3468,14 @@ var ChatService = class {
     const aiResponse = await this.generateAIResponse(
       input.companionId,
       input.text,
-      []
+      [],
+      signal
     );
     return { userMessage, aiResponse };
   }
-  async generateAIResponse(companionId, userMessage, context = []) {
+  async generateAIResponse(companionId, userMessage, context = [], signal) {
     const result = await this.run({
-      ...this.buildRequest(userMessage, context)
+      ...this.buildRequest(userMessage, context, signal)
     });
     return {
       ...messageFormatter.toChatMessage(result.text, "assistant"),
@@ -2976,12 +3491,12 @@ var ChatService = class {
       }
     };
   }
-  async generateStreamingResponse(userMessage, context, onChunk) {
-    const request = this.buildRequest(userMessage, context);
+  async generateStreamingResponse(userMessage, context, onChunk, signal) {
+    const request = this.buildRequest(userMessage, context, signal);
     const result = await this.runStream(request, { onChunk });
     return result.text;
   }
-  buildRequest(userMessage, context) {
+  buildRequest(userMessage, context, signal) {
     const messages = messageFormatter.toCoreMessages(context);
     messages.push({ role: "user", content: userMessage });
     return {
@@ -2990,7 +3505,8 @@ var ChatService = class {
       model: this.config.model,
       tier: this.config.tier,
       temperature: this.config.temperature,
-      maxTokens: this.config.maxTokens
+      maxTokens: this.config.maxTokens,
+      ...signal !== void 0 ? { signal } : {}
     };
   }
   resolveSystemPrompt() {
@@ -3045,12 +3561,37 @@ function readNumber(source, keys) {
   return null;
 }
 
+// src/providers/groq/groq-container.ts
+var container = null;
+function configureProvider(config) {
+  const configStore = new GroqConfigStore();
+  const transport = new GroqHttpTransport(configStore);
+  const httpClient = new GroqHttpClient({ configStore, transport });
+  httpClient.initialize(config);
+  const textGeneration = new TextGenerationService(
+    httpClient,
+    new CacheManager(),
+    config.textModel
+  );
+  const chat = new ChatService(textGeneration);
+  container = { groqHttpClient: httpClient, textGeneration, chat };
+  return container;
+}
+function getProvider() {
+  return container;
+}
+function resetProvider() {
+  container?.groqHttpClient.reset();
+  container = null;
+}
+
 exports.AIError = AIError;
 exports.AIErrorType = AIErrorType;
 exports.ANTHROPIC_API_VERSION = ANTHROPIC_API_VERSION;
 exports.ANTHROPIC_DEFAULT_MAX_TOKENS = ANTHROPIC_DEFAULT_MAX_TOKENS;
 exports.ANTHROPIC_MODELS = ANTHROPIC_MODELS;
 exports.ANTHROPIC_TIERS = ANTHROPIC_TIERS;
+exports.API_ENDPOINTS = API_ENDPOINTS;
 exports.AnthropicHttpTransport = AnthropicHttpTransport;
 exports.AnthropicProvider = AnthropicProvider;
 exports.AnthropicRequestBuilder = AnthropicRequestBuilder;
@@ -3060,8 +3601,11 @@ exports.ChatIdGenerator = ChatIdGenerator;
 exports.ChatService = ChatService;
 exports.CompositeExecutor = CompositeExecutor;
 exports.DEFAULT_API_KEY_RULE = DEFAULT_API_KEY_RULE;
+exports.DEFAULT_BASE_URL = DEFAULT_BASE_URL;
 exports.DEFAULT_ERROR_CLASSIFICATION_RULE = DEFAULT_ERROR_CLASSIFICATION_RULE;
+exports.DEFAULT_GENERATION_CONFIG = DEFAULT_GENERATION_CONFIG;
 exports.DEFAULT_HTTP_STATUS_RULE = DEFAULT_HTTP_STATUS_RULE;
+exports.DEFAULT_MODELS = DEFAULT_MODELS;
 exports.DEFAULT_PROMPT_STRATEGY = DEFAULT_PROMPT_STRATEGY;
 exports.DEFAULT_RETRY_BACKOFF_MULTIPLIER = DEFAULT_RETRY_BACKOFF_MULTIPLIER;
 exports.DEFAULT_RETRY_INITIAL_DELAY_MS = DEFAULT_RETRY_INITIAL_DELAY_MS;
@@ -3076,6 +3620,9 @@ exports.GROQ_MODELS = GROQ_MODELS;
 exports.GROQ_TIERS = GROQ_TIERS;
 exports.GeminiProvider = GeminiProvider;
 exports.GroqChatRequestBuilder = GroqChatRequestBuilder;
+exports.GroqConfigStore = GroqConfigStore;
+exports.GroqError = GroqError;
+exports.GroqErrorType = AIErrorType;
 exports.GroqHttpClient = GroqHttpClient;
 exports.GroqHttpTransport = GroqHttpTransport;
 exports.GroqProvider = GroqProvider;
@@ -3096,6 +3643,8 @@ exports.SSE_PREFIX = SSE_PREFIX;
 exports.StreamingResponseParser = StreamingResponseParser;
 exports.StructuredPromptBuilder = StructuredPromptBuilder;
 exports.TEXT_TIERS = TEXT_TIERS;
+exports.TIMEOUTS = TIMEOUTS;
+exports.TextGenerationService = TextGenerationService;
 exports.ThrottleManager = ThrottleManager;
 exports.USER_FRIENDLY_ERROR_MESSAGES = USER_FRIENDLY_ERROR_MESSAGES;
 exports.asObjectArray = asObjectArray;
@@ -3108,13 +3657,18 @@ exports.cacheManager = cacheManager;
 exports.chatIdGenerator = chatIdGenerator;
 exports.clampScore = clampScore;
 exports.classifyHttpStatus = classifyHttpStatus;
+exports.configureProvider = configureProvider;
 exports.consumeAnthropicStream = consumeAnthropicStream;
 exports.consumeGroqStream = consumeGroqStream;
 exports.createAI = createAI;
+exports.createAssistantMessage = createAssistantMessage;
 exports.createFalProvider = createFalProvider;
 exports.createGeminiProvider = createGeminiProvider;
+exports.createMessage = createMessage;
 exports.createPrunaProvider = createPrunaProvider;
 exports.createSseResponse = createSseResponse;
+exports.createSystemMessage = createSystemMessage;
+exports.createUserMessage = createUserMessage;
 exports.debounce = debounce;
 exports.debounceManager = debounceManager;
 exports.defaultEffortForModel = defaultEffortForModel;
@@ -3122,13 +3676,17 @@ exports.describeAIErrorType = describeAIErrorType;
 exports.extractContentFromSsePayload = extractContentFromSsePayload;
 exports.extractErrorMessageFromJsonBody = extractErrorMessageFromJsonBody;
 exports.extractErrorMessageFromResponse = extractErrorMessageFromResponse;
+exports.extractJsonArray = extractJsonArray;
 exports.extractJsonCandidate = extractJsonCandidate;
 exports.extractJsonFromCodeFence = extractJsonFromCodeFence;
 exports.extractJsonObject = extractJsonObject;
 exports.extractSseDataPayload = extractSseDataPayload;
+exports.extractTextFromMessages = extractTextFromMessages;
 exports.extractTokenUsage = extractTokenUsage;
 exports.formatErrorForLogging = formatErrorForLogging;
+exports.formatMessagesForDisplay = formatMessagesForDisplay;
 exports.generateWithPruna = generateWithPruna;
+exports.getProvider = getProvider;
 exports.isAuthErrorType = isAuthErrorType;
 exports.isMediaProvider = isMediaProvider;
 exports.isRetryableErrorType = isRetryableErrorType;
@@ -3142,8 +3700,12 @@ exports.mergeTierOverrides = mergeTierOverrides;
 exports.messageFormatter = messageFormatter;
 exports.normalizeSseChunk = normalizeSseChunk;
 exports.oneOfCatalog = oneOfCatalog;
+exports.promptToMessages = promptToMessages;
+exports.repairCommonJsonDefects = repairCommonJsonDefects;
 exports.requestDeduplicator = requestDeduplicator;
 exports.requestQueue = requestQueue;
+exports.requestStructuredJson = requestStructuredJson;
+exports.resetProvider = resetProvider;
 exports.resolveModel = resolveModel;
 exports.resolveUserFriendlyErrorMessage = resolveUserFriendlyErrorMessage;
 exports.resolveUserFriendlyMessage = resolveUserFriendlyMessage;