@umituz/web-ai 1.0.1 → 1.0.3

package/dist/providers/index.cjs

@@ -184,6 +184,14 @@ var ProviderError = class extends AIError {
   providerId;
 };
 
+// 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 */,
@@ -532,6 +540,56 @@ function isSseDoneMarker(payload) {
   return payload === SSE_DONE_MARKER;
 }
 
+// src/core/parsers/streaming-response.parser.ts
+var StreamingResponseParser = class {
+  constructor(callbacks, extractDelta) {
+    this.callbacks = callbacks;
+    this.extractDelta = extractDelta;
+  }
+  callbacks;
+  extractDelta;
+  decoder = new TextDecoder();
+  async parse(stream) {
+    const reader = stream.getReader();
+    const contentChunks = [];
+    let buffer = "";
+    const consumeLine = (rawLine) => {
+      const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+      const trimmed = line.trim();
+      if (trimmed.length === 0 || !isSseDataLine(trimmed)) return;
+      const payload = extractSseDataPayload(trimmed);
+      if (isSseDoneMarker(payload)) return;
+      const content = this.extractDelta(payload);
+      if (content !== null) {
+        contentChunks.push(content);
+        this.callbacks.onChunk(content);
+      }
+    };
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += this.decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) consumeLine(line);
+      }
+      buffer += this.decoder.decode();
+      if (buffer.length > 0) consumeLine(buffer);
+    } catch (error) {
+      if (error instanceof AIError) throw error;
+      throw new AIError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Stream was interrupted",
+        error instanceof Error ? error : void 0
+      );
+    } finally {
+      reader.releaseLock();
+    }
+    return contentChunks.join("");
+  }
+};
+
 // src/core/parsers/json-content-extractor.ts
 function extractJsonFromCodeFence(content) {
   const match = content.match(JSON_CODE_BLOCK_PATTERN);
@@ -1190,6 +1248,12 @@ 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;
 var DEFAULT_RETRY_MAX_ATTEMPTS = 3;
 var DEFAULT_RETRY_INITIAL_DELAY_MS = 1e3;
@@ -1363,6 +1427,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",
@@ -1386,12 +1471,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",
@@ -1450,13 +1545,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();
@@ -1471,7 +1618,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();
@@ -1498,11 +1645,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);
@@ -1525,7 +1672,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) {
@@ -1627,21 +1774,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();
   }
@@ -1654,6 +1820,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;
@@ -2385,39 +2555,811 @@ function createFalProvider(config) {
   return new FalProvider(config);
 }
 
-// src/providers/pruna/pruna-generate.ts
-var prunaCorePromise = null;
-async function loadPrunaCore() {
-  if (!prunaCorePromise) {
-    const specifier = "@umituz/pruna-provider/core";
-    prunaCorePromise = import(specifier);
+// src/providers/pruna/client/core/constants/limits.ts
+var DEFAULT_ASPECT_RATIO = "16:9";
+var P_VIDEO_DEFAULTS = {
+  duration: 5,
+  resolution: "720p",
+  fps: 24,
+  draft: false,
+  promptUpsampling: true
+};
+var POLL_DEFAULTS = {
+  intervalMs: 3e3,
+  maxAttempts: 120,
+  maxIntervalMs: 1e4,
+  backoffBase: 1.5,
+  jitterPercent: 0.1
+};
+var DEFAULT_DEDUPLICATOR_TTL_MS = 3e4;
+var DEDUPLICATOR_CLEANUP_GRACE_MS = 100;
+
+// src/providers/pruna/client/core/constants/network.ts
+var HTTPS_PREFIX = "https://";
+var HTTP_PREFIX = "http://";
+var BASE64_MARKER = "base64,";
+var PRUNA_BASE_URL = "https://api.pruna.ai";
+var PRUNA_PREDICTIONS_URL = `${PRUNA_BASE_URL}/v1/predictions`;
+var PRUNA_FILES_URL = `${PRUNA_BASE_URL}/v1/files`;
+var AUTH_FAILURE_STATUSES = [401, 403];
+var MIN_API_KEY_LENGTH = 1;
+var MAX_API_KEY_LENGTH = 256;
+
+// src/providers/pruna/client/core/constants/mime-types.ts
+var MIME_PNG = "image/png";
+var MIME_JPEG = "image/jpeg";
+var MIME_WEBP = "image/webp";
+var DEFAULT_IMAGE_MIME = MIME_PNG;
+var MIME_FILE_EXTENSION = {
+  [MIME_PNG]: "png",
+  [MIME_JPEG]: "jpg",
+  [MIME_WEBP]: "webp"
+};
+var IMAGE_SIGNATURES = {
+  PNG: [137, 80],
+  JPEG: [255, 216],
+  WEBP_RIFF: [82, 73]
+};
+
+// src/providers/pruna/client/core/errors/cancellation-error.ts
+var CANCELLATION_MESSAGE = "Request cancelled by user";
+var CancellationError = class extends Error {
+  constructor(message = CANCELLATION_MESSAGE) {
+    super(message);
+    this.name = "CancellationError";
+  }
+};
+
+// src/providers/pruna/client/core/errors/authentication-error.ts
+var AUTHENTICATION_MESSAGE = "Authentication failed. Please check your API key.";
+var AuthenticationError = class extends Error {
+  constructor(message = AUTHENTICATION_MESSAGE) {
+    super(message);
+    this.name = "AuthenticationError";
+  }
+};
+
+// src/providers/pruna/client/core/errors/timeout-error.ts
+var TIMEOUT_MESSAGE = "Generation timed out. Maximum polling attempts reached.";
+var TimeoutError = class extends Error {
+  constructor(message = TIMEOUT_MESSAGE) {
+    super(message);
+    this.name = "TimeoutError";
   }
-  return prunaCorePromise;
+};
+
+// src/providers/pruna/client/core/errors/validation-error.ts
+var ValidationError = class extends Error {
+  field;
+  reason;
+  receivedValue;
+  constructor(context) {
+    super(`Invalid ${context.field}: ${context.reason}`);
+    this.name = "ValidationError";
+    this.field = context.field;
+    this.reason = context.reason;
+    this.receivedValue = context.receivedValue;
+  }
+};
+
+// src/providers/pruna/client/core/utils/base64.ts
+var globalScope = globalThis;
+var hasBuffer = typeof globalScope.Buffer?.from === "function";
+function base64ToBytes(raw) {
+  if (hasBuffer) {
+    const bufferFactory = globalScope.Buffer;
+    if (!bufferFactory) {
+      throw new Error("Buffer unavailable despite detection flag");
+    }
+    const buf = bufferFactory.from(raw, "base64");
+    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+  }
+  const decoded = atob(raw);
+  return Uint8Array.from(decoded, (char) => char.charCodeAt(0));
 }
-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 }
+
+// src/providers/pruna/client/core/utils/mime-detector.ts
+var MIN_SIGNATURE_BYTES = 2;
+function matchesSignature(bytes, signature) {
+  if (bytes.length < signature.length) return false;
+  return signature.every((value, index) => bytes[index] === value);
+}
+function detectImageMime(bytes) {
+  if (bytes.length < MIN_SIGNATURE_BYTES) return DEFAULT_IMAGE_MIME;
+  if (matchesSignature(bytes, IMAGE_SIGNATURES.PNG)) return MIME_PNG;
+  if (matchesSignature(bytes, IMAGE_SIGNATURES.JPEG)) return MIME_JPEG;
+  if (matchesSignature(bytes, IMAGE_SIGNATURES.WEBP_RIFF)) return MIME_WEBP;
+  return DEFAULT_IMAGE_MIME;
+}
+
+// src/providers/pruna/client/core/utils/api-error-parser.ts
+async function parseApiError(response, fallback) {
+  const payload = await response.json().catch(() => ({ message: response.statusText }));
+  const message = payload.message ?? `${fallback}: ${response.status}`;
+  const error = new Error(message);
+  error.statusCode = response.status;
+  return error;
+}
+
+// src/providers/pruna/client/core/protocol/http-status.ts
+function isAuthFailureStatus(status) {
+  return AUTH_FAILURE_STATUSES.includes(status);
+}
+
+// src/providers/pruna/client/core/protocol/job-status.ts
+var TERMINAL_SUCCESS_STATUSES = ["succeeded", "completed"];
+var TERMINAL_FAILURE_STATUSES = ["failed"];
+function isTerminalSuccessStatus(status) {
+  if (!status) return false;
+  return TERMINAL_SUCCESS_STATUSES.includes(status);
+}
+function isTerminalFailureStatus(status) {
+  if (!status) return false;
+  return TERMINAL_FAILURE_STATUSES.includes(status);
+}
+
+// src/providers/pruna/client/core/protocol/abort-signal-classifier.ts
+function isAbortError(err) {
+  if (err instanceof DOMException && err.code === DOMException.ABORT_ERR) return true;
+  if (err instanceof Error && err.name === "AbortError") return true;
+  return false;
+}
+
+// src/providers/pruna/client/core/protocol/pruna-url-builder.ts
+function isAbsoluteHttpUrl(value) {
+  return value.startsWith(HTTPS_PREFIX) || value.startsWith(HTTP_PREFIX);
+}
+function isHttpsUrl(value) {
+  return value.startsWith(HTTPS_PREFIX);
+}
+function buildPrunaApiUrl(pathOrUrl) {
+  if (isAbsoluteHttpUrl(pathOrUrl)) return pathOrUrl;
+  return `${PRUNA_BASE_URL}${pathOrUrl}`;
+}
+function buildFileUrlById(fileId) {
+  return `${PRUNA_FILES_URL}/${fileId}`;
+}
+
+// src/providers/pruna/client/core/math/exponential-backoff.ts
+function calculateExponentialBackoff2(inputs) {
+  const {
+    attempt,
+    baseIntervalMs,
+    maxIntervalMs = POLL_DEFAULTS.maxIntervalMs,
+    jitterPercent = POLL_DEFAULTS.jitterPercent,
+    growthBase = POLL_DEFAULTS.backoffBase
+  } = inputs;
+  const safeAttempt = Math.max(0, attempt);
+  const safeBase = Math.max(0, baseIntervalMs);
+  const exponentialDelay = Math.min(safeBase * Math.pow(growthBase, safeAttempt), maxIntervalMs);
+  const jitter = exponentialDelay * jitterPercent * Math.random();
+  return exponentialDelay + jitter;
+}
+
+// src/providers/pruna/client/core/utils/uri-resolver.ts
+var uriCache = /* @__PURE__ */ new WeakMap();
+function stripBase64Prefix(image) {
+  if (isHttpsUrl(image)) return image;
+  const base64Index = image.indexOf(BASE64_MARKER);
+  return base64Index !== -1 ? image.slice(base64Index + BASE64_MARKER.length) : image;
+}
+function readOutput(output) {
+  if (typeof output === "string") return output;
+  if (Array.isArray(output) && output.length > 0) return output[0] ?? null;
+  if (output !== null && typeof output === "object" && "url" in output) {
+    return output.url;
+  }
+  return null;
+}
+function extractUri(data) {
+  const cached = uriCache.get(data);
+  if (cached !== void 0) return cached;
+  if (!isTerminalSuccessStatus(data.status)) {
+    uriCache.set(data, null);
+    return null;
+  }
+  const result = data.generation_url ?? readOutput(data.output) ?? data.video_url ?? data.data ?? null;
+  uriCache.set(data, result);
+  return result;
+}
+function resolveUri(uri) {
+  return uri.startsWith("/") ? `${PRUNA_BASE_URL}${uri}` : uri;
+}
+
+// src/providers/pruna/client/core/services/pruna-client.service.ts
+function buildFileExtension(mime) {
+  return MIME_FILE_EXTENSION[mime] ?? "bin";
+}
+async function uploadImage(base64OrUrl, apiKey, onProgress) {
+  if (isHttpsUrl(base64OrUrl)) return base64OrUrl;
+  if (base64OrUrl.startsWith(HTTP_PREFIX)) {
+    throw new Error("Only HTTPS URLs are supported for security.");
+  }
+  onProgress?.("uploading");
+  const raw = stripBase64Prefix(base64OrUrl);
+  let bytes;
+  try {
+    bytes = base64ToBytes(raw);
+  } catch {
+    throw new Error("Invalid image format. Provide base64 or a valid HTTPS URL.");
+  }
+  const mime = detectImageMime(bytes);
+  const buffer = bytes.buffer.slice(
+    bytes.byteOffset,
+    bytes.byteOffset + bytes.byteLength
+  );
+  const blob = new Blob([buffer], { type: mime });
+  const formData = new FormData();
+  formData.append("content", blob, `upload.${buildFileExtension(mime)}`);
+  const res = await fetch(PRUNA_FILES_URL, {
+    method: "POST",
+    headers: { apikey: apiKey },
+    body: formData
+  });
+  if (!res.ok) {
+    throw await parseApiError(res, "File upload error");
+  }
+  const data = await res.json();
+  return data.urls?.get ?? buildFileUrlById(data.id ?? "");
+}
+async function submitPrediction(model, input, apiKey, signal, onProgress) {
+  onProgress?.("predicting");
+  const res = await fetch(PRUNA_PREDICTIONS_URL, {
+    method: "POST",
+    headers: {
+      apikey: apiKey,
+      Model: model,
+      "Try-Sync": "true",
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ input }),
+    signal
+  });
+  if (!res.ok) {
+    throw await parseApiError(res, "API error");
+  }
+  return res.json();
+}
+var GenerationFailedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "GenerationFailedError";
+  }
+};
+async function attemptPoll(fullUrl, apiKey, signal) {
+  let res;
+  try {
+    res = await fetch(fullUrl, { headers: { apikey: apiKey }, signal });
+  } catch (err) {
+    if (isAbortError(err)) throw new CancellationError();
+    return { outcome: "transient-failure" };
+  }
+  if (!res.ok) {
+    if (isAuthFailureStatus(res.status)) throw new AuthenticationError();
+    return { outcome: "transient-failure" };
+  }
+  let data;
+  try {
+    data = await res.json();
+  } catch {
+    return { outcome: "transient-failure" };
+  }
+  if (isTerminalSuccessStatus(data.status)) {
+    const uri = extractUri(data);
+    if (uri) return { outcome: "succeeded", uri: resolveUri(uri) };
+    return { outcome: "transient-failure" };
+  }
+  if (isTerminalFailureStatus(data.status)) {
+    throw new GenerationFailedError(data.error ?? "Generation failed during processing.");
+  }
+  return { outcome: "continue" };
+}
+async function pollForResult(pollUrl, apiKey, maxAttempts = POLL_DEFAULTS.maxAttempts, intervalMs = POLL_DEFAULTS.intervalMs, signal, onProgress) {
+  const fullUrl = isAbsoluteHttpUrl(pollUrl) ? pollUrl : buildPrunaApiUrl(pollUrl);
+  const controller = new AbortController();
+  const onExternalAbort = () => controller.abort();
+  signal?.addEventListener("abort", onExternalAbort);
+  try {
+    for (let i = 0; i < maxAttempts; i++) {
+      if (signal?.aborted) throw new CancellationError();
+      const delay = calculateExponentialBackoff2({ attempt: i, baseIntervalMs: intervalMs });
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      if (signal?.aborted) throw new CancellationError();
+      onProgress?.("polling", i + 1);
+      const result = await attemptPoll(fullUrl, apiKey, controller.signal);
+      if (result.outcome === "succeeded" && result.uri) {
+        return result.uri;
+      }
+    }
+    throw new TimeoutError();
+  } finally {
+    signal?.removeEventListener("abort", onExternalAbort);
+    controller.abort();
+  }
+}
+
+// src/providers/pruna/client/core/math/comparison-hash.ts
+function sortKeysDeep(value) {
+  if (Array.isArray(value)) {
+    return value.map(sortKeysDeep);
+  }
+  if (value !== null && typeof value === "object") {
+    const record = value;
+    return Object.keys(record).sort().reduce((acc, key) => {
+      acc[key] = sortKeysDeep(record[key]);
+      return acc;
+    }, {});
+  }
+  return value;
+}
+function hashValue(value) {
+  if (value === null || typeof value !== "object") {
+    return String(value);
+  }
+  try {
+    return JSON.stringify(sortKeysDeep(value));
+  } catch {
+    return String(value);
+  }
+}
+function compositeHash(...values) {
+  return values.map(hashValue).join("|");
+}
+
+// src/providers/pruna/client/core/math/cache-key-derivation.ts
+function deriveGenerationCacheKey(apiKey, input) {
+  return `${apiKey}:${compositeHash(input)}`;
+}
+
+// src/providers/pruna/client/core/validation/api-key-validator.ts
+function assertValidApiKey(apiKey) {
+  if (typeof apiKey !== "string") {
+    throw new ValidationError({
+      field: "apiKey",
+      reason: "must be a string",
+      receivedValue: typeof apiKey
+    });
+  }
+  if (apiKey.length < MIN_API_KEY_LENGTH) {
+    throw new ValidationError({
+      field: "apiKey",
+      reason: "must not be empty",
+      receivedValue: apiKey
+    });
+  }
+  if (apiKey.length > MAX_API_KEY_LENGTH) {
+    throw new ValidationError({
+      field: "apiKey",
+      reason: `exceeds maximum length of ${MAX_API_KEY_LENGTH}`,
+      receivedValue: apiKey.length
+    });
+  }
+}
+
+// src/providers/pruna/client/core/validation/image-source-validator.ts
+function classifyImageSource(source) {
+  if (source.startsWith(HTTPS_PREFIX)) return "https-url";
+  if (source.startsWith(HTTP_PREFIX)) return "http-url";
+  if (source.includes(BASE64_MARKER) || /^[A-Za-z0-9+/=]+$/.test(source)) return "base64";
+  return "unknown";
+}
+function assertSecureImageSource(image, fieldName = "image") {
+  if (typeof image !== "string") {
+    throw new ValidationError({
+      field: fieldName,
+      reason: "must be a string",
+      receivedValue: typeof image
+    });
+  }
+  const kind = classifyImageSource(image);
+  if (kind === "http-url") {
+    throw new ValidationError({
+      field: fieldName,
+      reason: "HTTP URLs are not supported; use HTTPS or a base64 data URI",
+      receivedValue: image
+    });
+  }
+  if (kind === "unknown") {
+    throw new ValidationError({
+      field: fieldName,
+      reason: "must be an HTTPS URL or a base64 data URI",
+      receivedValue: typeof image
+    });
+  }
+}
+
+// src/providers/pruna/client/core/validation/aspect-ratio-validator.ts
+var SUPPORTED_ASPECT_RATIOS = [
+  "16:9",
+  "9:16",
+  "1:1",
+  "4:3",
+  "3:4",
+  "3:2",
+  "2:3"
+];
+function isSupportedAspectRatio(value) {
+  return typeof value === "string" && SUPPORTED_ASPECT_RATIOS.includes(value);
+}
+function assertValidAspectRatio(value, fieldName = "aspect_ratio") {
+  if (value === void 0 || value === null) return;
+  if (!isSupportedAspectRatio(value)) {
+    throw new ValidationError({
+      field: fieldName,
+      reason: `must be one of ${SUPPORTED_ASPECT_RATIOS.join(", ")}`,
+      receivedValue: value
+    });
+  }
+}
+
+// src/providers/pruna/client/core/validation/resolution-validator.ts
+var SUPPORTED_RESOLUTIONS = ["720p", "1080p"];
+function isSupportedResolution(value) {
+  return typeof value === "string" && SUPPORTED_RESOLUTIONS.includes(value);
+}
+function assertValidResolution(value, fieldName = "resolution") {
+  if (value === void 0 || value === null) return;
+  if (!isSupportedResolution(value)) {
+    throw new ValidationError({
+      field: fieldName,
+      reason: `must be one of ${SUPPORTED_RESOLUTIONS.join(", ")}`,
+      receivedValue: value
+    });
+  }
+}
+
+// src/providers/pruna/client/core/validation/duration-validator.ts
+var MIN_VIDEO_DURATION_SECONDS = 1;
+var MAX_VIDEO_DURATION_SECONDS = 30;
+function isValidDuration(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= MIN_VIDEO_DURATION_SECONDS && value <= MAX_VIDEO_DURATION_SECONDS && Number.isInteger(value);
+}
+function assertValidDuration(value, fieldName = "duration") {
+  if (value === void 0 || value === null) return;
+  if (!isValidDuration(value)) {
+    throw new ValidationError({
+      field: fieldName,
+      reason: `must be an integer between ${MIN_VIDEO_DURATION_SECONDS} and ${MAX_VIDEO_DURATION_SECONDS} seconds`,
+      receivedValue: value
+    });
+  }
+}
+
+// src/providers/pruna/client/core/validation/prompt-validator.ts
+var MIN_PROMPT_LENGTH = 1;
+var MAX_PROMPT_LENGTH = 4e3;
+function assertValidPrompt(value, fieldName = "prompt") {
+  if (typeof value !== "string") {
+    throw new ValidationError({
+      field: fieldName,
+      reason: "must be a string",
+      receivedValue: typeof value
+    });
+  }
+  if (value.trim().length < MIN_PROMPT_LENGTH) {
+    throw new ValidationError({
+      field: fieldName,
+      reason: "must not be empty or whitespace-only",
+      receivedValue: value
+    });
+  }
+  if (value.length > MAX_PROMPT_LENGTH) {
+    throw new ValidationError({
+      field: fieldName,
+      reason: `exceeds maximum length of ${MAX_PROMPT_LENGTH} characters`,
+      receivedValue: value.length
+    });
+  }
+}
+
+// src/providers/pruna/client/core/validation/seed-validator.ts
+var MIN_SEED = -2147483648;
+var MAX_SEED = 2147483647;
+function isValidSeed(value) {
+  return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value >= MIN_SEED && value <= MAX_SEED;
+}
+function assertValidSeed(value, fieldName = "seed") {
+  if (value === void 0 || value === null) return;
+  if (!isValidSeed(value)) {
+    throw new ValidationError({
+      field: fieldName,
+      reason: `must be an integer in [${MIN_SEED}, ${MAX_SEED}]`,
+      receivedValue: value
+    });
+  }
+}
+
+// src/providers/pruna/client/core/protocol/input-type-guard.ts
+function isTextToImageInput(input) {
+  return input.model === "p-image";
+}
+function isImageToImageInput(input) {
+  return input.model === "p-image-edit";
+}
+function isImageToVideoInput(input) {
+  return input.model === "p-video";
+}
+
+// src/providers/pruna/client/core/utils/request-deduplicator.ts
+var RequestDeduplicator2 = class {
+  pendingRequests = /* @__PURE__ */ new Map();
+  ttl;
+  constructor(ttl = DEFAULT_DEDUPLICATOR_TTL_MS) {
+    this.ttl = ttl;
+  }
+  execute(key, fn) {
+    const existing = this.pendingRequests.get(key);
+    if (existing) {
+      if (Date.now() - existing.timestamp < this.ttl) {
+        return existing.promise;
+      }
+      this.pendingRequests.delete(key);
+    }
+    const promise = fn().finally(() => {
+      setTimeout(() => {
+        this.pendingRequests.delete(key);
+      }, DEDUPLICATOR_CLEANUP_GRACE_MS);
+    });
+    this.pendingRequests.set(key, { promise, timestamp: Date.now() });
+    return promise;
+  }
+  clear() {
+    this.pendingRequests.clear();
+  }
+  size() {
+    this.purgeExpired();
+    return this.pendingRequests.size;
+  }
+  purgeExpired() {
+    const now = Date.now();
+    for (const [key, value] of this.pendingRequests) {
+      if (now - value.timestamp >= this.ttl) {
+        this.pendingRequests.delete(key);
+      }
+    }
+  }
+};
+var globalDeduplicator = new RequestDeduplicator2();
+
+// src/providers/pruna/client/generation/builders/text-to-image.builder.ts
+var TextToImageInputBuilder = class {
+  model = "p-image";
+  build(input, _context) {
+    const payload = {
+      prompt: input.prompt,
+      aspect_ratio: input.aspect_ratio ?? DEFAULT_ASPECT_RATIO
+    };
+    if (input.seed !== void 0) {
+      payload.seed = input.seed;
+    }
+    return Promise.resolve(payload);
+  }
+};
+
+// src/providers/pruna/client/generation/builders/image-to-image.builder.ts
+var ImageToImageInputBuilder = class {
+  model = "p-image-edit";
+  build(input, _context) {
+    const payload = {
+      images: [stripBase64Prefix(input.image)],
+      prompt: input.prompt,
+      aspect_ratio: input.aspect_ratio ?? DEFAULT_ASPECT_RATIO
+    };
+    if (input.seed !== void 0) {
+      payload.seed = input.seed;
+    }
+    return Promise.resolve(payload);
+  }
+};
+
+// src/providers/pruna/client/generation/builders/image-to-video.builder.ts
+var ImageToVideoInputBuilder = class {
+  model = "p-video";
+  async build(input, context) {
+    if (context.signal?.aborted) {
+      throw new CancellationError();
+    }
+    const fileUrl = await uploadImage(
+      input.image,
+      context.apiKey,
+      context.onProgress
+    );
+    return {
+      image: fileUrl,
+      prompt: input.prompt,
+      duration: input.duration ?? P_VIDEO_DEFAULTS.duration,
+      resolution: input.resolution ?? P_VIDEO_DEFAULTS.resolution,
+      fps: P_VIDEO_DEFAULTS.fps,
+      draft: input.draft ?? P_VIDEO_DEFAULTS.draft,
+      aspect_ratio: input.aspect_ratio ?? DEFAULT_ASPECT_RATIO,
+      prompt_upsampling: P_VIDEO_DEFAULTS.promptUpsampling
     };
-    return;
   }
-  const pollUrl = prediction.status_url || prediction.generation_url;
+};
+
+// src/providers/pruna/client/generation/builders/model-input-builder.ts
+var ModelInputBuilderRegistry = class {
+  builders = /* @__PURE__ */ new Map();
+  register(builder) {
+    this.builders.set(builder.model, builder);
+    return this;
+  }
+  resolve(model) {
+    const builder = this.builders.get(model);
+    if (!builder) {
+      throw new Error(`No input builder registered for model: ${model}`);
+    }
+    return builder;
+  }
+};
+
+// src/providers/pruna/client/generation/builders/builder-factory.ts
+function createDefaultBuilderRegistry() {
+  return new ModelInputBuilderRegistry().register(new TextToImageInputBuilder()).register(new ImageToImageInputBuilder()).register(new ImageToVideoInputBuilder());
+}
+
+// src/providers/pruna/client/generation/services/generation.service.ts
+var builderRegistry = createDefaultBuilderRegistry();
+function validateGenerateInput(input) {
+  assertValidPrompt(input.prompt, `${input.model}.prompt`);
+  assertValidAspectRatio(input.aspect_ratio, `${input.model}.aspect_ratio`);
+  if (isTextToImageInput(input)) {
+    assertValidSeed(input.seed, `${input.model}.seed`);
+  } else if (isImageToImageInput(input)) {
+    assertSecureImageSource(input.image, `${input.model}.image`);
+    assertValidSeed(input.seed, `${input.model}.seed`);
+  } else if (isImageToVideoInput(input)) {
+    assertSecureImageSource(input.image, `${input.model}.image`);
+    assertValidDuration(input.duration, `${input.model}.duration`);
+    assertValidResolution(input.resolution, `${input.model}.resolution`);
+  }
+}
+async function generate(apiKey, input, options = {}) {
+  assertValidApiKey(apiKey);
+  validateGenerateInput(input);
+  const { signal, onProgress, useCache = true } = options;
+  if (useCache) {
+    const cacheKey = deriveGenerationCacheKey(apiKey, input);
+    return globalDeduplicator.execute(
+      cacheKey,
+      () => generateInternal(apiKey, input, { signal, onProgress })
+    );
+  }
+  return generateInternal(apiKey, input, { signal, onProgress });
+}
+async function generateInternal(apiKey, input, options) {
+  const { signal, onProgress } = options;
+  const builder = builderRegistry.resolve(input.model);
+  const modelInput = await builder.build(input, { apiKey, signal, onProgress });
+  const response = await submitPrediction(input.model, modelInput, apiKey, signal, onProgress);
+  const syncUri = extractUri(response);
+  if (syncUri) {
+    return { url: resolveUri(syncUri), model: input.model };
+  }
+  const pollUrl = response.get_url ?? response.status_url;
   if (!pollUrl) {
-    throw new Error("Pruna prediction response missing polling URL");
+    throw new Error("Pruna API returned no result and no polling URL.");
   }
-  const resultUrl = await prunaCore.pollForResult(pollUrl, apiKey, 60, 2e3, signal, onProgress);
-  yield { stage: "polling", result: { url: resultUrl, model: modelId } };
+  const url = await pollForResult(
+    pollUrl,
+    apiKey,
+    POLL_DEFAULTS.maxAttempts,
+    POLL_DEFAULTS.intervalMs,
+    signal,
+    onProgress
+  );
+  return { url, model: input.model };
+}
+async function generateImageThenVideo(apiKey, input, options = {}) {
+  assertValidApiKey(apiKey);
+  assertValidPrompt(input.prompt, "text-to-video.prompt");
+  assertValidAspectRatio(input.aspect_ratio, "text-to-video.aspect_ratio");
+  assertValidDuration(input.duration, "text-to-video.duration");
+  assertValidResolution(input.resolution, "text-to-video.resolution");
+  const { signal, onProgress } = options;
+  const aspectRatio = input.aspect_ratio ?? DEFAULT_ASPECT_RATIO;
+  onProgress?.("predicting", 1);
+  const imageResult = await generate(
+    apiKey,
+    { model: "p-image", prompt: input.prompt, aspect_ratio: aspectRatio },
+    { signal }
+  );
+  onProgress?.("predicting", 2);
+  return generate(
+    apiKey,
+    {
+      model: "p-video",
+      prompt: input.prompt,
+      image: imageResult.url,
+      duration: input.duration ?? P_VIDEO_DEFAULTS.duration,
+      resolution: input.resolution ?? P_VIDEO_DEFAULTS.resolution,
+      aspect_ratio: aspectRatio,
+      draft: input.draft ?? P_VIDEO_DEFAULTS.draft
+    },
+    { signal, onProgress }
+  );
+}
+
+// src/providers/pruna/pruna-generate.ts
+async function* generateWithPruna(request, apiKey, signal, onProgress) {
+  const stages = [];
+  let notify = null;
+  let done = false;
+  const wake = () => {
+    const fn = notify;
+    if (fn) {
+      notify = null;
+      fn();
+    }
+  };
+  const handleProgress = (stage) => {
+    stages.push({ stage });
+    onProgress?.(stage);
+    wake();
+  };
+  const promise = (async () => {
+    try {
+      const model = request.model ?? (request.image ? "p-image-edit" : "p-image");
+      if (model === "p-video" && !request.image && request.prompt) {
+        const videoRes = await generateImageThenVideo(
+          apiKey,
+          {
+            prompt: request.prompt,
+            duration: request.duration ?? 5,
+            aspect_ratio: request.aspectRatio ?? request.aspect_ratio ?? "16:9"
+          },
+          { signal, onProgress: handleProgress }
+        );
+        stages.push({
+          stage: "polling",
+          result: { url: videoRes.url, model: "p-video" }
+        });
+        return;
+      }
+      const input = {
+        model,
+        prompt: request.prompt ?? "",
+        aspect_ratio: request.aspectRatio ?? request.aspect_ratio ?? "1:1",
+        ...request.image ? { image: request.image } : {},
+        ...request.duration ? { duration: request.duration } : {},
+        ...request.resolution ? { resolution: request.resolution } : {},
+        ...request.seed !== void 0 ? { seed: request.seed } : {}
+      };
+      const res = await generate(apiKey, input, {
+        signal,
+        onProgress: handleProgress
+      });
+      stages.push({
+        stage: "polling",
+        result: { url: res.url, model: res.model }
+      });
+    } catch (err) {
+      stages.push({
+        stage: "processing",
+        error: err instanceof Error ? err : new Error(String(err))
+      });
+    } finally {
+      done = true;
+      wake();
+    }
+  })();
+  while (!done || stages.length > 0) {
+    if (stages.length === 0 && !done) {
+      await new Promise((resolve) => {
+        notify = resolve;
+      });
+      notify = null;
+    }
+    while (stages.length > 0) {
+      const nextStage = stages.shift();
+      if (!nextStage) continue;
+      yield nextStage;
+      if (nextStage.error) {
+        throw nextStage.error;
+      }
+    }
+  }
+  await promise;
 }
 
 // src/providers/pruna/pruna.provider.ts
@@ -2530,38 +3472,564 @@ 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;
+function generateRandomBase36Suffix(length, random = Math.random) {
+  if (length <= 0) return "";
+  const raw = random().toString(BASE_36_RADIX).slice(DECIMAL_OFFSET);
+  if (raw.length >= length) return raw.slice(0, length);
+  let result = raw;
+  while (result.length < length) {
+    result += random().toString(BASE_36_RADIX).slice(DECIMAL_OFFSET);
+  }
+  return result.slice(0, length);
+}
+
+// src/chat/utils/chat-id-generator.ts
+var ID_PART_DELIMITER = "-";
+var ChatIdGenerator = class {
+  counter = 0;
+  randomLength;
+  constructor(randomLength = CHAT_MESSAGE_ID_SUFFIX_LENGTH) {
+    this.randomLength = randomLength;
+  }
+  next(sender) {
+    this.counter += 1;
+    const random = generateRandomBase36Suffix(this.randomLength);
+    return [
+      MESSAGE_ID_PREFIX,
+      Date.now(),
+      sender,
+      this.counter,
+      random
+    ].join(ID_PART_DELIMITER);
+  }
+};
+var chatIdGenerator = new ChatIdGenerator();
+
+// src/chat/utils/message-formatter.ts
+var MessageFormatter = class {
+  constructor(idGenerator = chatIdGenerator) {
+    this.idGenerator = idGenerator;
+  }
+  idGenerator;
+  /** Maps chat-domain history to neutral core messages; system senders are
+   *  dropped — the system prompt travels on the request's own slot. */
+  toCoreMessages(messages) {
+    const coreMessages = [];
+    for (const message of messages) {
+      if (message.sender === "system") continue;
+      coreMessages.push({
+        role: message.sender === "user" ? USER_ROLE : ASSISTANT_ROLE,
+        content: message.content
+      });
+    }
+    return coreMessages;
+  }
+  toChatMessage(content, sender) {
+    return {
+      id: this.idGenerator.next(sender),
+      sender,
+      content: content.trim(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      type: "text"
+    };
+  }
+};
+var messageFormatter = new MessageFormatter();
+
+// src/chat/utils/prompt-strategy.ts
+var DEFAULT_PROMPT_STRATEGY = {
+  resolve: (config) => {
+    if (config.systemPrompt && config.systemPrompt.length > 0) {
+      return config.systemPrompt;
+    }
+    return void 0;
+  }
+};
+
+// src/chat/services/chat.service.ts
+var DEFAULT_CONFIG = {
+  temperature: 0.8,
+  maxTokens: 500
+};
+var ChatService = class {
+  constructor(engine) {
+    this.engine = engine;
+  }
+  engine;
+  config = DEFAULT_CONFIG;
+  promptStrategy = DEFAULT_PROMPT_STRATEGY;
+  storage = null;
+  initialize(config) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  setPromptStrategy(strategy) {
+    this.promptStrategy = strategy;
+  }
+  setStorage(storage) {
+    this.storage = storage;
+  }
+  async getConversation(conversationId) {
+    const storage = this.requireStorage();
+    const messages = await storage.getMessages(conversationId);
+    if (messages.length === 0) return null;
+    const last = messages[messages.length - 1];
+    const first = messages[0];
+    const companionId = String(first.metadata?.["companionId"] ?? "unknown");
+    const companionName = String(first.metadata?.["companionName"] ?? "Unknown");
+    return {
+      id: conversationId,
+      companionId,
+      companionName,
+      lastMessage: last,
+      messageCount: messages.length,
+      updatedAt: last.timestamp
+    };
+  }
+  async getConversations() {
+    if (this.storage && "getConversations" in this.storage && typeof this.storage.getConversations === "function") {
+      return this.storage.getConversations();
+    }
+    return [];
+  }
+  async sendMessage(input, signal) {
+    const userMessage = {
+      ...messageFormatter.toChatMessage(input.text, "user"),
+      type: input.type ?? "text",
+      ...input.imageUrl !== void 0 ? { imageUrl: input.imageUrl } : {}
+    };
+    const aiResponse = await this.generateAIResponse(
+      input.companionId,
+      input.text,
+      [],
+      signal
+    );
+    return { userMessage, aiResponse };
+  }
+  async generateAIResponse(companionId, userMessage, context = [], signal) {
+    const result = await this.run({
+      ...this.buildRequest(userMessage, context, signal)
+    });
+    return {
+      ...messageFormatter.toChatMessage(result.text, "assistant"),
+      metadata: {
+        companionId,
+        model: result.model,
+        usage: {
+          input_tokens: result.usage?.inputTokens,
+          output_tokens: result.usage?.outputTokens,
+          total_tokens: result.usage?.totalTokens
+        },
+        finishReason: result.finishReason
+      }
+    };
+  }
+  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, signal) {
+    const messages = messageFormatter.toCoreMessages(context);
+    messages.push({ role: "user", content: userMessage });
+    return {
+      messages,
+      systemPrompt: this.resolveSystemPrompt(),
+      model: this.config.model,
+      tier: this.config.tier,
+      temperature: this.config.temperature,
+      maxTokens: this.config.maxTokens,
+      ...signal !== void 0 ? { signal } : {}
+    };
+  }
+  resolveSystemPrompt() {
+    const prompt = this.promptStrategy.resolve(this.config);
+    return prompt && prompt.length > 0 ? prompt : void 0;
+  }
+  async run(request) {
+    if (this.engine instanceof ProviderFactory) {
+      return this.engine.chat(request);
+    }
+    return this.engine.generate(request);
+  }
+  async runStream(request, callbacks) {
+    if (this.engine instanceof ProviderFactory) {
+      return this.engine.chatStream(request, callbacks);
+    }
+    return this.engine.stream(request, callbacks);
+  }
+  requireStorage() {
+    if (!this.storage) {
+      throw new AIError(
+        "MISSING_CONFIG" /* MISSING_CONFIG */,
+        "ChatService.getConversation requires setStorage() to be called first."
+      );
+    }
+    return this.storage;
+  }
+};
+
+// src/providers/groq/groq-container.ts
+var container = null;
+function configureProvider(config) {
+  const configStore = new GroqConfigStore();
+  const transport = new GroqHttpTransport(configStore);
+  const httpClient = new GroqHttpClient({ configStore, transport });
+  httpClient.initialize(config);
+  const textGeneration = new TextGenerationService(
+    httpClient,
+    new CacheManager(),
+    config.textModel
+  );
+  const chat = new ChatService(textGeneration);
+  container = { groqHttpClient: httpClient, textGeneration, chat };
+  return container;
+}
+function getProvider() {
+  return container;
+}
+function resetProvider() {
+  container?.groqHttpClient.reset();
+  container = null;
+}
+
 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;
+exports.AuthenticationError = AuthenticationError;
 exports.BaseProvider = BaseProvider;
+exports.CancellationError = CancellationError;
+exports.DEFAULT_BASE_URL = DEFAULT_BASE_URL;
+exports.DEFAULT_GENERATION_CONFIG = DEFAULT_GENERATION_CONFIG;
+exports.DEFAULT_MODELS = DEFAULT_MODELS;
 exports.FalProvider = FalProvider;
 exports.GEMINI_TIERS = GEMINI_TIERS;
 exports.GROQ_MODELS = GROQ_MODELS;
 exports.GROQ_TIERS = GROQ_TIERS;
 exports.GeminiProvider = GeminiProvider;
+exports.GenerationFailedError = GenerationFailedError;
 exports.GroqChatRequestBuilder = GroqChatRequestBuilder;
+exports.GroqConfigStore = GroqConfigStore;
 exports.GroqHttpClient = GroqHttpClient;
 exports.GroqHttpTransport = GroqHttpTransport;
 exports.GroqProvider = GroqProvider;
 exports.ProviderError = ProviderError;
 exports.ProviderFactory = ProviderFactory;
 exports.PrunaProvider = PrunaProvider;
+exports.TIMEOUTS = TIMEOUTS;
+exports.TextGenerationService = TextGenerationService;
+exports.TimeoutError = TimeoutError;
+exports.ValidationError = ValidationError;
+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.createSystemMessage = createSystemMessage;
+exports.createUserMessage = createUserMessage;
 exports.defaultEffortForModel = defaultEffortForModel;
 exports.extractContentFromSsePayload = extractContentFromSsePayload;
+exports.extractTextFromMessages = extractTextFromMessages;
+exports.formatMessagesForDisplay = formatMessagesForDisplay;
+exports.generateImageThenVideo = generateImageThenVideo;
+exports.generatePruna = generate;
 exports.generateWithPruna = generateWithPruna;
+exports.getProvider = getProvider;
 exports.isMediaProvider = isMediaProvider;
 exports.isTextProvider = isTextProvider;
 exports.mapAnthropicStopReason = mapAnthropicStopReason;
+exports.pollForResult = pollForResult;
+exports.promptToMessages = promptToMessages;
+exports.requestStructuredJson = requestStructuredJson;
+exports.resetProvider = resetProvider;
+exports.submitPrediction = submitPrediction;
 exports.toGroqMessages = toGroqMessages;
+exports.uploadImage = uploadImage;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map