@umituz/web-ai 1.0.2 → 1.0.4

package/dist/index.cjs

@@ -1084,6 +1084,26 @@ function isMediaProvider(provider) {
   return provider.capabilities.includes("image") || provider.capabilities.includes("video");
 }
 
+// src/content/domain/errors/AIErrors.ts
+var ValidationError = class extends AIError {
+  constructor(message) {
+    super(message, "VALIDATION_ERROR");
+    this.name = "ValidationError";
+  }
+};
+var ProviderUnavailableError = class extends AIError {
+  constructor(providerId) {
+    super(`Provider ${providerId} is not available`, "PROVIDER_UNAVAILABLE");
+    this.name = "ProviderUnavailableError";
+  }
+};
+var ProviderQuotaExhaustedError = class extends AIError {
+  constructor(providerId) {
+    super(`Provider ${providerId} quota exhausted`, "PROVIDER_QUOTA_EXHAUSTED");
+    this.name = "ProviderQuotaExhaustedError";
+  }
+};
+
 // src/content/domain/limits/ProviderTimingConfig.ts
 var ProviderTimingConfig = {
   DEFAULT_TIMEOUT_MS: 3e4,
@@ -1426,6 +1446,9 @@ var ProviderFactory = class {
     );
   }
 };
+function createProviderFactory(config) {
+  return new ProviderFactory(config);
+}
 
 // src/providers/anthropic/anthropic.constants.ts
 var ANTHROPIC_MODELS = {
@@ -2455,6 +2478,9 @@ function toGroqMessages(messages, systemPrompt) {
   }
   return wire;
 }
+function createGroqProvider(config) {
+  return new GroqProvider(config);
+}
 function findLastIndex2(items, predicate) {
   for (let i = items.length - 1; i >= 0; i--) {
     if (predicate(items[i])) return i;
@@ -2721,6 +2747,128 @@ function createGeminiProvider(config) {
   return new GeminiProvider(config);
 }
 
+// src/content/domain/predicates/KeywordProminenceClassifier.ts
+var HIGH_DENSITY_THRESHOLD = 2;
+var MEDIUM_DENSITY_THRESHOLD = 1;
+function classifyKeywordProminence(densityPercent) {
+  if (densityPercent > HIGH_DENSITY_THRESHOLD) return "high";
+  if (densityPercent > MEDIUM_DENSITY_THRESHOLD) return "medium";
+  return "low";
+}
+function isUnderutilizedKeyword(densityPercent) {
+  return densityPercent < 1;
+}
+
+// src/content/domain/types/index.ts
+var PLATFORM_SPECS = {
+  twitter: {
+    maxLength: 280,
+    style: "concise, engaging, thread-friendly",
+    emojiSupport: true,
+    hashtagSupport: true,
+    imageSupport: true,
+    videoSupport: true,
+    maxHashtags: 5
+  },
+  linkedin: {
+    maxLength: 3e3,
+    style: "professional, insightful, industry-focused",
+    emojiSupport: true,
+    hashtagSupport: true,
+    imageSupport: true,
+    videoSupport: true,
+    maxHashtags: 5
+  },
+  instagram: {
+    maxLength: 2200,
+    style: "visual, engaging, emoji-rich",
+    emojiSupport: true,
+    hashtagSupport: true,
+    imageSupport: true,
+    videoSupport: true,
+    maxHashtags: 30
+  },
+  threads: {
+    maxLength: 500,
+    style: "conversational, community-driven",
+    emojiSupport: true,
+    hashtagSupport: true,
+    imageSupport: true,
+    videoSupport: true,
+    maxHashtags: 5
+  },
+  tiktok: {
+    maxLength: 150,
+    style: "catchy, trending, short-form",
+    emojiSupport: true,
+    hashtagSupport: true,
+    imageSupport: false,
+    videoSupport: true,
+    maxHashtags: 5
+  },
+  facebook: {
+    maxLength: 63206,
+    style: "conversational, engaging, shareable",
+    emojiSupport: true,
+    hashtagSupport: true,
+    imageSupport: true,
+    videoSupport: true,
+    maxHashtags: 5
+  }
+};
+
+// src/content/domain/predicates/HashtagPriorityRanker.ts
+var DEFAULT_HASHTAG_BUDGET = Number.MAX_SAFE_INTEGER;
+function resolveHashtagBudget(platform) {
+  return PLATFORM_SPECS[platform]?.maxHashtags ?? DEFAULT_HASHTAG_BUDGET;
+}
+function rankAndTrimHashtags(hashtags, budget) {
+  if (hashtags.length <= budget) return [...hashtags];
+  return [...hashtags].sort((a, b) => b.length - a.length).slice(0, budget);
+}
+
+// src/content/domain/predicates/QualityRecommenderByRatio.ts
+var WIDE_RATIOS = /* @__PURE__ */ new Set(["16:9", "4:3"]);
+function recommendQualityForAspectRatio(ratio) {
+  return WIDE_RATIOS.has(ratio) ? "hd" : "standard";
+}
+
+// src/content/domain/predicates/PlatformSpecResolver.ts
+var FALLBACK_SPEC = {
+  maxLength: 280,
+  style: "concise, engaging, audience-friendly",
+  emojiSupport: true,
+  hashtagSupport: true,
+  imageSupport: true,
+  videoSupport: true,
+  maxHashtags: 5
+};
+function resolvePlatformSpec(platform) {
+  return PLATFORM_SPECS[platform] ?? FALLBACK_SPEC;
+}
+function resolveMaxContentLength(platform, override) {
+  return override ?? resolvePlatformSpec(platform).maxLength;
+}
+
+// src/content/domain/predicates/ScoreRangeGuard.ts
+var SCORE_MIN = 0;
+var SCORE_MAX = 100;
+var SCORE_FALLBACK = 50;
+var CONFIDENCE_MIN = 0;
+var CONFIDENCE_MAX = 1;
+var CONFIDENCE_FALLBACK = 0.5;
+function clampScoreToValidRange(score, fallback = SCORE_FALLBACK) {
+  if (!Number.isFinite(score)) return fallback;
+  return Math.max(SCORE_MIN, Math.min(SCORE_MAX, score));
+}
+function clampConfidenceToValidRange(confidence, fallback = CONFIDENCE_FALLBACK) {
+  if (!Number.isFinite(confidence)) return fallback;
+  return Math.max(CONFIDENCE_MIN, Math.min(CONFIDENCE_MAX, confidence));
+}
+
+// src/content/domain/predicates/AbTestConfidence.ts
+var AB_TEST_DEFAULT_CONFIDENCE = 0.7;
+
 // src/content/domain/predicates/FalImageRenderingOptions.ts
 var FAL_FORMAT_TO_IMAGE_SIZE = {
   square: "square_hd",
@@ -2917,674 +3065,2975 @@ 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";
+  }
+};
+
+// src/providers/pruna/client/core/errors/validation-error.ts
+var ValidationError2 = 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);
   }
-  return prunaCorePromise;
+  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 }
-    };
-    return;
+
+// 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;
   }
-  const pollUrl = prediction.status_url || prediction.generation_url;
-  if (!pollUrl) {
-    throw new Error("Pruna prediction response missing polling 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 resultUrl = await prunaCore.pollForResult(pollUrl, apiKey, 60, 2e3, signal, onProgress);
-  yield { stage: "polling", result: { url: resultUrl, model: modelId } };
+  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/pruna.provider.ts
-var PrunaProvider = class {
-  constructor(config) {
-    this.config = config;
+// 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.");
   }
-  config;
-  id = "pruna";
-  name = "Pruna AI";
-  capabilities = ["image", "video"];
-  async healthCheck() {
-    return this.config.apiKey ? "healthy" : "unavailable";
+  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");
   }
-  async estimateCost(_request) {
-    return 1;
+  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");
   }
-  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()
-    };
+  return res.json();
+}
+var GenerationFailedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "GenerationFailedError";
   }
-  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 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" };
   }
-  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");
+  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;
+      }
     }
-    return {
-      id: Date.now().toString(),
-      type: "video",
-      url: finalUrl,
-      metadata: { provider: this.id, model: "p-image-to-video" },
-      createdAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
+    throw new TimeoutError();
+  } finally {
+    signal?.removeEventListener("abort", onExternalAbort);
+    controller.abort();
   }
-  async videoToVideo(_request) {
-    throw new AIError("CLIENT_ERROR" /* CLIENT_ERROR */, "Pruna AI provider does not support video-to-video conversion");
+}
+
+// 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;
+    }, {});
   }
-};
-function createPrunaProvider(config) {
-  return new PrunaProvider(config);
+  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/factory/create-ai.ts
-function createAI(config = {}) {
-  const factory = new ProviderFactory({
-    priority: config.priority,
-    fallbackEnabled: config.fallbackEnabled,
-    defaultTier: config.defaultTier
-  });
-  if (config.anthropic?.apiKey) {
-    factory.register(new AnthropicProvider(config.anthropic));
+// 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 ValidationError2({
+      field: "apiKey",
+      reason: "must be a string",
+      receivedValue: typeof apiKey
+    });
   }
-  if (config.groq?.apiKey) {
-    factory.register(new GroqProvider(config.groq));
+  if (apiKey.length < MIN_API_KEY_LENGTH) {
+    throw new ValidationError2({
+      field: "apiKey",
+      reason: "must not be empty",
+      receivedValue: apiKey
+    });
   }
-  if (config.gemini?.apiKey) {
-    factory.register(new GeminiProvider({ ...config.gemini, enabled: true }));
+  if (apiKey.length > MAX_API_KEY_LENGTH) {
+    throw new ValidationError2({
+      field: "apiKey",
+      reason: `exceeds maximum length of ${MAX_API_KEY_LENGTH}`,
+      receivedValue: apiKey.length
+    });
   }
-  if (config.fal?.apiKey) {
-    factory.register(new FalProvider({ ...config.fal, enabled: true }));
+}
+
+// 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 ValidationError2({
+      field: fieldName,
+      reason: "must be a string",
+      receivedValue: typeof image
+    });
   }
-  if (config.pruna?.apiKey) {
-    factory.register(new PrunaProvider({ ...config.pruna, enabled: true }));
+  const kind = classifyImageSource(image);
+  if (kind === "http-url") {
+    throw new ValidationError2({
+      field: fieldName,
+      reason: "HTTP URLs are not supported; use HTTPS or a base64 data URI",
+      receivedValue: image
+    });
+  }
+  if (kind === "unknown") {
+    throw new ValidationError2({
+      field: fieldName,
+      reason: "must be an HTTPS URL or a base64 data URI",
+      receivedValue: typeof image
+    });
   }
-  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)
+// 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"
 ];
-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");
+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 ValidationError2({
+      field: fieldName,
+      reason: `must be one of ${SUPPORTED_ASPECT_RATIOS.join(", ")}`,
+      receivedValue: value
+    });
+  }
+}
 
-// 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/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 ValidationError2({
+      field: fieldName,
+      reason: `must be one of ${SUPPORTED_RESOLUTIONS.join(", ")}`,
+      receivedValue: value
+    });
   }
 }
 
-// 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;
+// 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 ValidationError2({
+      field: fieldName,
+      reason: `must be an integer between ${MIN_VIDEO_DURATION_SECONDS} and ${MAX_VIDEO_DURATION_SECONDS} seconds`,
+      receivedValue: value
+    });
   }
-  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);
+}
+
+// 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 ValidationError2({
+      field: fieldName,
+      reason: "must be a string",
+      receivedValue: typeof value
+    });
+  }
+  if (value.trim().length < MIN_PROMPT_LENGTH) {
+    throw new ValidationError2({
+      field: fieldName,
+      reason: "must not be empty or whitespace-only",
+      receivedValue: value
+    });
+  }
+  if (value.length > MAX_PROMPT_LENGTH) {
+    throw new ValidationError2({
+      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 ValidationError2({
+      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;
   }
-  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);
+  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
+    };
   }
-  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);
+};
+
+// 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 API returned no result and no polling URL.");
+  }
+  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();
     }
-    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 });
+  })();
+  while (!done || stages.length > 0) {
+    if (stages.length === 0 && !done) {
+      await new Promise((resolve) => {
+        notify = resolve;
+      });
+      notify = null;
     }
-    for (const m of req.messages) {
-      messages.push({ role: m.role, content: m.content });
+    while (stages.length > 0) {
+      const nextStage = stages.shift();
+      if (!nextStage) continue;
+      yield nextStage;
+      if (nextStage.error) {
+        throw nextStage.error;
+      }
     }
-    const lastMsg = messages[messages.length - 1];
-    if (lastMsg) {
-      const structuredPrompt = StructuredPromptBuilder.for(lastMsg.content).withSchema(schemaObj).build();
-      messages[messages.length - 1] = { ...lastMsg, content: structuredPrompt };
+  }
+  await promise;
+}
+
+// src/providers/pruna/pruna.provider.ts
+var PrunaProvider = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  id = "pruna";
+  name = "Pruna AI";
+  capabilities = ["image", "video"];
+  async healthCheck() {
+    return this.config.apiKey ? "healthy" : "unavailable";
+  }
+  async estimateCost(_request) {
+    return 1;
+  }
+  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;
     }
-    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 };
+    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) {
+    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) {
+    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("CLIENT_ERROR" /* CLIENT_ERROR */, "Pruna AI provider does not support video-to-video conversion");
+  }
+};
+function createPrunaProvider(config) {
+  return new PrunaProvider(config);
+}
+
+// src/providers/factory/create-ai.ts
+function createAI(config = {}) {
+  const factory = new ProviderFactory({
+    priority: config.priority,
+    fallbackEnabled: config.fallbackEnabled,
+    defaultTier: config.defaultTier
+  });
+  if (config.anthropic?.apiKey) {
+    factory.register(new AnthropicProvider(config.anthropic));
+  }
+  if (config.groq?.apiKey) {
+    factory.register(new GroqProvider(config.groq));
+  }
+  if (config.gemini?.apiKey) {
+    factory.register(new GeminiProvider({ ...config.gemini, enabled: true }));
+  }
+  if (config.fal?.apiKey) {
+    factory.register(new FalProvider({ ...config.fal, enabled: true }));
+  }
+  if (config.pruna?.apiKey) {
+    factory.register(new PrunaProvider({ ...config.pruna, enabled: true }));
+  }
+  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;
+  }
+};
+function extractTokenUsage(message) {
+  const meta = message.metadata;
+  if (!meta) return null;
+  const usage = meta["usage"];
+  if (!usage || typeof usage !== "object") return null;
+  const u = usage;
+  const inputTokens = readNumber(u, ["input_tokens", "prompt_tokens"]);
+  const outputTokens = readNumber(u, ["output_tokens", "completion_tokens"]);
+  const totalTokens = readNumber(u, ["total_tokens"]);
+  if (inputTokens === null || outputTokens === null || totalTokens === null) {
+    return null;
+  }
+  return {
+    promptTokens: inputTokens,
+    completionTokens: outputTokens,
+    totalTokens
+  };
+}
+function readNumber(source, keys) {
+  for (const key of keys) {
+    const value = source[key];
+    if (typeof value === "number") return value;
+  }
+  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;
+}
+
+// src/content/domain/calculations/ContentCreditCost.ts
+var CREDIT_COSTS = {
+  "text-to-image": { standard: 1, hd: 2, "4k": 4 },
+  "image-to-image": { standard: 1, hd: 2, "4k": 4 },
+  "image-to-video": { standard: 3, hd: 5, "4k": 8 },
+  "text-to-video": { standard: 5, hd: 8, "4k": 12 }
+};
+var DEFAULT_CREDIT_COST = 0;
+function toQualityTier(quality) {
+  if (quality === "4k") return "4k";
+  if (quality === "hd" || quality === "1080p") return "hd";
+  return "standard";
+}
+function calculateContentCreditCost(type, quality = "standard") {
+  const tierCosts = CREDIT_COSTS[type];
+  if (!tierCosts) return DEFAULT_CREDIT_COST;
+  return tierCosts[toQualityTier(quality)] ?? tierCosts.standard;
+}
+
+// src/content/domain/limits/ImageFormatOptions.ts
+var ASPECT_RATIO_OPTIONS = [
+  { value: "1:1", label: "Square", width: 1024, height: 1024 },
+  { value: "16:9", label: "Landscape", width: 1920, height: 1080 },
+  { value: "9:16", label: "Portrait", width: 1080, height: 1920 },
+  { value: "4:3", label: "Standard", width: 1440, height: 1080 },
+  { value: "3:4", label: "Tall", width: 1080, height: 1440 }
+];
+var IMAGE_QUALITY_OPTIONS = [
+  { value: "standard", label: "Standard", description: "1024x1024, good quality", resolution: "1024x1024" },
+  { value: "hd", label: "HD", description: "1920x1080, high quality", resolution: "1920x1080" },
+  { value: "4k", label: "4K", description: "3840x2160, ultra quality", resolution: "3840x2160" }
+];
+var VIDEO_QUALITY_OPTIONS = [
+  { value: "720p", label: "720p HD", resolution: "1280x720" },
+  { value: "1080p", label: "1080p Full HD", resolution: "1920x1080" },
+  { value: "4k", label: "4K Ultra HD", resolution: "3840x2160" }
+];
+var VIDEO_DURATION_OPTIONS_SECONDS = [2, 3, 4, 5, 6, 7, 8, 9, 10];
+var MOTION_OPTIONS = [
+  { value: "slow", label: "Slow", description: "Gentle movement" },
+  { value: "medium", label: "Medium", description: "Balanced motion" },
+  { value: "fast", label: "Fast", description: "Dynamic movement" }
+];
+var STYLE_PRESETS = [
+  { value: "realistic", label: "Realistic", promptFragment: "realistic, photograph, detailed" },
+  { value: "artistic", label: "Artistic", promptFragment: "artistic, painting, creative" },
+  { value: "anime", label: "Anime", promptFragment: "anime style, manga, vibrant colors" },
+  { value: "cinematic", label: "Cinematic", promptFragment: "cinematic, movie scene, dramatic lighting" },
+  { value: "vintage", label: "Vintage", promptFragment: "vintage, retro, film grain" },
+  { value: "fantasy", label: "Fantasy", promptFragment: "fantasy, magical, ethereal" },
+  { value: "minimalist", label: "Minimalist", promptFragment: "minimalist, clean, simple" },
+  { value: "abstract", label: "Abstract", promptFragment: "abstract, geometric, artistic" }
+];
+
+// src/content/domain/calculations/AspectRatioDimensions.ts
+var FALLBACK_DIMENSIONS = { width: 1024, height: 1024 };
+function resolveDimensionsForAspectRatio(ratio) {
+  const match = ASPECT_RATIO_OPTIONS.find((option) => option.value === ratio);
+  return match ? { width: match.width, height: match.height } : FALLBACK_DIMENSIONS;
+}
+
+// src/content/domain/constants/GenerationConstants.ts
+var ASPECT_RATIO_VALUES = ASPECT_RATIO_OPTIONS.map((o) => o.value);
+var IMAGE_QUALITY_VALUES = IMAGE_QUALITY_OPTIONS.map((o) => o.value);
+var VIDEO_QUALITY_VALUES = VIDEO_QUALITY_OPTIONS.map((o) => o.value);
+var VIDEO_DURATION_OPTIONS = VIDEO_DURATION_OPTIONS_SECONDS;
+var getDimensionsForAspectRatio = resolveDimensionsForAspectRatio;
+var getRecommendedQuality = recommendQualityForAspectRatio;
+
+// src/content/domain/limits/ValidationLimits.ts
+var ValidationLimits = {
+  TOPIC: {
+    MIN: 1,
+    MAX: 500
+  },
+  CONTENT: {
+    MIN: 1,
+    MAX: 1e4
+  },
+  KEYWORD: {
+    MAX_COUNT: 20,
+    MAX_LENGTH: 50
+  },
+  DURATION_SECONDS: {
+    MIN: 10,
+    MAX: 600
+  },
+  CALENDAR_DAYS: {
+    MIN: 1,
+    MAX: 90
+  },
+  HASHTAG_COUNT: {
+    MIN: 1,
+    MAX: 50
+  },
+  SEO_CONTENT_PREVIEW: 500,
+  BLOG_PROMPT_PREVIEW: 1e3,
+  AB_VARIANT_CONTENT_PREVIEW: 200
+};
+
+// src/content/domain/limits/SpeechPaceConfig.ts
+var SpeechPaceConfig = {
+  WORDS_PER_SECOND: 2.5,
+  TOKENS_PER_SECOND: 10,
+  JSON_TOKEN_OVERHEAD: 500,
+  TOKENS_PER_CALENDAR_DAY: 150
+};
+
+// src/content/domain/calculations/SpeechPaceEstimate.ts
+function estimateWordCountForDuration(durationSeconds) {
+  return Math.floor(durationSeconds * SpeechPaceConfig.WORDS_PER_SECOND);
+}
+function estimateTokenBudgetForDuration(durationSeconds) {
+  return durationSeconds * SpeechPaceConfig.TOKENS_PER_SECOND + SpeechPaceConfig.JSON_TOKEN_OVERHEAD;
+}
+function estimateTokenBudgetForCalendarDays(days) {
+  return days * SpeechPaceConfig.TOKENS_PER_CALENDAR_DAY + SpeechPaceConfig.JSON_TOKEN_OVERHEAD;
+}
+
+// src/content/domain/calculations/SeoKeywordDensity.ts
+function countKeywordOccurrences(content, keyword) {
+  if (!keyword) return 0;
+  const escaped = keyword.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const matches = content.match(new RegExp(escaped, "gi"));
+  return matches ? matches.length : 0;
+}
+function countWordsInContent(content) {
+  const tokens = content.split(/\s+/).filter(Boolean);
+  return tokens.length || 1;
+}
+function calculateKeywordDensity(content, keyword) {
+  const totalWords = countWordsInContent(content);
+  const occurrences = countKeywordOccurrences(content, keyword);
+  return occurrences / totalWords * 100;
+}
+
+// src/content/domain/calculations/AbTestImprovementRatio.ts
+function calculateImprovementPercentage(scoreA, scoreB) {
+  const higher = Math.max(scoreA, scoreB);
+  const lower = Math.min(scoreA, scoreB);
+  if (lower <= 0) {
+    return "100";
+  }
+  const delta = (higher / lower - 1) * 100;
+  return Math.abs(delta).toFixed(0);
+}
+function selectHigherScoreVariantId(scoreA, scoreB, idA = "A", idB = "B") {
+  return scoreA > scoreB ? idA : idB;
+}
+
+// src/content/domain/calculations/ContentCalendarDateOffset.ts
+var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
+function resolveCalendarEntryDate(dayIndex, baseTimestamp = Date.now()) {
+  return new Date(baseTimestamp + (dayIndex - 1) * ONE_DAY_MS);
+}
+
+// src/content/domain/validation/TopicTextValidator.ts
+function validateTopicText(topic) {
+  if (typeof topic !== "string" || topic.trim().length < ValidationLimits.TOPIC.MIN) {
+    throw new ValidationError("Topic cannot be empty");
+  }
+  const trimmed = topic.trim();
+  if (trimmed.length > ValidationLimits.TOPIC.MAX) {
+    throw new ValidationError(`Topic exceeds maximum length of ${ValidationLimits.TOPIC.MAX} characters`);
+  }
+  return trimmed;
+}
+
+// src/content/domain/validation/ContentBodyValidator.ts
+function validateContentBody(content) {
+  if (typeof content !== "string" || content.trim().length < ValidationLimits.CONTENT.MIN) {
+    throw new ValidationError("Content cannot be empty");
+  }
+  const trimmed = content.trim();
+  if (trimmed.length > ValidationLimits.CONTENT.MAX) {
+    throw new ValidationError(`Content exceeds maximum length of ${ValidationLimits.CONTENT.MAX} characters`);
+  }
+  return trimmed;
+}
+function truncateForSeoPreview(content) {
+  return content.substring(0, ValidationLimits.SEO_CONTENT_PREVIEW);
+}
+function truncateForBlogPromptPreview(content) {
+  return content.substring(0, ValidationLimits.BLOG_PROMPT_PREVIEW);
+}
+function truncateForAbVariantPreview(content) {
+  return content.substring(0, ValidationLimits.AB_VARIANT_CONTENT_PREVIEW);
+}
+
+// src/content/domain/validation/KeywordListValidator.ts
+function validateKeywordList(keywords) {
+  if (!Array.isArray(keywords)) {
+    throw new ValidationError("Keywords must be an array");
+  }
+  if (keywords.length > ValidationLimits.KEYWORD.MAX_COUNT) {
+    throw new ValidationError(`Cannot process more than ${ValidationLimits.KEYWORD.MAX_COUNT} keywords`);
+  }
+  return keywords.filter((k) => typeof k === "string" && k.trim().length > 0).map((keyword) => {
+    const trimmed = keyword.trim();
+    if (trimmed.length > ValidationLimits.KEYWORD.MAX_LENGTH) {
+      const preview = trimmed.substring(0, 20);
+      throw new ValidationError(
+        `Keyword "${preview}..." exceeds maximum length of ${ValidationLimits.KEYWORD.MAX_LENGTH} characters`
+      );
+    }
+    return trimmed;
+  });
+}
+
+// src/content/domain/validation/DurationSecondsValidator.ts
+function validateDurationSeconds(duration) {
+  if (!Number.isFinite(duration)) {
+    throw new ValidationError(
+      `Duration must be between ${ValidationLimits.DURATION_SECONDS.MIN} and ${ValidationLimits.DURATION_SECONDS.MAX} seconds`
+    );
+  }
+  if (duration < ValidationLimits.DURATION_SECONDS.MIN || duration > ValidationLimits.DURATION_SECONDS.MAX) {
+    throw new ValidationError(
+      `Duration must be between ${ValidationLimits.DURATION_SECONDS.MIN} and ${ValidationLimits.DURATION_SECONDS.MAX} seconds`
+    );
+  }
+  return duration;
+}
+
+// src/content/domain/validation/CalendarDaysValidator.ts
+function validateCalendarDays(days) {
+  if (!Number.isFinite(days)) {
+    throw new ValidationError(
+      `Days must be between ${ValidationLimits.CALENDAR_DAYS.MIN} and ${ValidationLimits.CALENDAR_DAYS.MAX}`
+    );
+  }
+  if (days < ValidationLimits.CALENDAR_DAYS.MIN || days > ValidationLimits.CALENDAR_DAYS.MAX) {
+    throw new ValidationError(
+      `Days must be between ${ValidationLimits.CALENDAR_DAYS.MIN} and ${ValidationLimits.CALENDAR_DAYS.MAX}`
+    );
+  }
+  return days;
+}
+
+// src/content/domain/validation/HashtagCountValidator.ts
+function validateHashtagCount(count) {
+  if (!Number.isFinite(count)) {
+    throw new ValidationError(
+      `Hashtag count must be between ${ValidationLimits.HASHTAG_COUNT.MIN} and ${ValidationLimits.HASHTAG_COUNT.MAX}`
+    );
+  }
+  if (count < ValidationLimits.HASHTAG_COUNT.MIN || count > ValidationLimits.HASHTAG_COUNT.MAX) {
+    throw new ValidationError(
+      `Hashtag count must be between ${ValidationLimits.HASHTAG_COUNT.MIN} and ${ValidationLimits.HASHTAG_COUNT.MAX}`
+    );
+  }
+  return Math.floor(count);
+}
+
+// src/content/domain/utils/IdGenerator.ts
+function generateId(prefix) {
+  const id = typeof crypto !== "undefined" && typeof crypto.randomUUID === "function" ? crypto.randomUUID() : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 11)}`;
+  return prefix ? `${prefix}-${id}` : id;
+}
+
+// src/content/application/prompts/PromptBuilder.ts
+var PromptBuilder = class {
+  static blogPost(input) {
+    return `
+As an expert SEO Content Strategist and Copywriter, generate a high-quality, comprehensive blog post.
+
+TOPIC: ${input.topic}
+TYPE: ${input.blogType}
+KEYWORDS: ${input.keywords.join(", ")}
+TONE: ${input.tone}
+TARGET AUDIENCE: ${input.targetAudience}
+WORD COUNT: ${input.wordCount}
+LANGUAGE: ${input.language || "English"}
+
+OPTIMIZATION REQUIREMENTS:
+- SEO Optimization: ${input.seoOptimization ? "ON (Include semantic keywords, LSI, and proper H1-H3 structure)" : "OFF"}
+- Include Schema Markup: ${input.includeSchema ? "ON (Generate JSON-LD for this blog type)" : "OFF"}
+- Image Suggestions: ${input.includeImages ? "ON (Provide DALL-E/Midjourney style prompts for contextually relevant images)" : "OFF"}
+
+RESPONSE FORMAT (STRICT JSON ONLY):
+{
+  "title": "Compelling, Click-worthy Title",
+  "content": "Full markdown-formatted blog content with headers",
+  "metaDescription": "SEO-optimized description (150-160 chars)",
+  "seoScore": 0-100,
+  "readabilityScore": 0-100,
+  "keywords": ["list", "of", "optimized", "keywords"],
+  "performance": {
+    "readingTime": minutes (number),
+    "shareability": 0-10 (number),
+    "seoRank": 0-10 (number)
+  },
+  "schemaMarkup": "JSON-LD string (if requested)",
+  "imagePrompts": ["Prompt 1", "Prompt 2"] (if requested)
+}
+`;
+  }
+  static socialPost(input) {
+    return `
+Write a ${input.tone} social media post about: ${input.topic}
+
+Platform: ${input.platform}
+Style: ${input.style}
+Maximum length: ${input.maxLength} characters
+${input.includeHashtags ? "Include relevant hashtags" : "No hashtags"}
+${input.includeCallToAction ? "Include a call-to-action" : ""}
+
+Requirements:
+- Platform-optimized formatting
+- Engaging hook in first sentence
+- Natural, conversational tone
+- Platform-appropriate emoji usage
+
+Generate the post in JSON format:
+{
+  "content": "The post content",
+  "hashtags": ["hashtag1", "hashtag2"],
+  "emojis": ["emoji1", "emoji2"],
+  "estimatedEngagement": 0-100
+}
+`;
+  }
+  static videoScript(input) {
+    return `
+Create a ${input.tone} video script about: ${input.topic}
+
+Duration: ${input.duration} seconds
+Target Audience: ${input.targetAudience}
+Include Visual Cues: ${input.includeVisuals ? "Yes" : "No"}
+Include CTA: ${input.includeCallToAction ? "Yes" : "No"}
+
+Approximate word count: ${estimateWordCountForDuration(input.duration)} words
+
+Generate in JSON format:
+{
+  "script": "Full script with dialogue and narration",
+  "visualCues": ["Visual cue 1", "Visual cue 2"],
+  "callToAction": "Call to action text (if requested)",
+  "estimatedEngagement": 0-100
+}
+`;
+  }
+  static voiceScript(input) {
+    return `
+Create a ${input.emotion} voice script about: ${input.topic}
+
+Duration: ${input.duration} seconds
+Emotion: ${input.emotion}
+
+The script should:
+- Evoke the specified emotion
+- Be suitable for voice recording with emotion control
+- Include natural speech patterns
+- Have appropriate pacing for the emotion
+- Include emotional cues in brackets where needed
+
+Approximate word count: ${estimateWordCountForDuration(input.duration)} words
+
+Generate in JSON format:
+{
+  "script": "Full script with emotional cues",
+  "visualCues": ["Visual cue 1", "Visual cue 2"],
+  "estimatedEngagement": 0-100
+}
+`;
+  }
+  static contentCalendar(niche, days) {
+    return `
+Generate a ${days}-day content calendar for: ${niche}
+
+For each day, provide:
+- Topic
+- Content type (blog, video, social, email, caption, script)
+- Best platform for this content
+- Brief description
+- Estimated engagement (0-100)
+- Priority level (high, medium, low)
+
+Format as JSON array:
+[
+  {
+    "day": 1,
+    "topic": "...",
+    "contentType": "blog|video|social|email|caption|script",
+    "platform": "twitter|linkedin|instagram|threads|tiktok|facebook",
+    "description": "...",
+    "estimatedEngagement": 0-100,
+    "priority": "high|medium|low"
+  }
+]
+
+Requirements:
+- Mix of content types across platforms
+- Platform-appropriate suggestions
+- Engaging, varied topics
+- Realistic posting schedule
+`;
+  }
+  static sentiment(content) {
+    return `
+Analyze the sentiment of this social media post:
+
+"${content}"
+
+Provide analysis in JSON format:
+{
+  "sentiment": "positive|neutral|negative",
+  "confidence": 0-1,
+  "emotions": [
+    {"emotion": "happy|excited|calm|sad|angry|surprised|fearful|disgusted|neutral", "score": 0-1}
+  ]
+}
+
+Return only the JSON:
+`;
+  }
+  static contentAnalysis(content) {
+    return `
+Analyze this content:
+
+"${content}"
+
+Provide analysis in JSON format:
+{
+  "keywords": ["keyword1", "keyword2", ...],
+  "entities": ["entity1", "entity2", ...],
+  "suggestedImprovements": ["suggestion1", ...],
+  "readabilityScore": 0-100,
+  "estimatedEngagement": 0-100
+}
+
+Return only the JSON:
+`;
+  }
+  static seoOptimization(content, keywords) {
+    return `
+Optimize this content for SEO:
+
+Content: "${content}"
+Keywords: ${keywords.join(", ")}
+
+Tasks:
+1. Incorporate keywords naturally
+2. Improve engagement potential
+3. Add relevant call-to-action if appropriate
+4. Optimize for readability
+5. Enhance heading structure
+
+Return JSON:
+{
+  "optimized": "...",
+  "score": 0-100,
+  "suggestions": ["suggestion1", ...],
+  "addedKeywords": ["keyword1", ...],
+  "removedFillerWords": number,
+  "readabilityImprovements": ["improvement1", ...],
+  "metaDescription": "SEO-optimized meta description",
+  "titleSuggestions": ["title1", ...]
+}
+
+Return only the JSON:
+`;
+  }
+  static seoScore(content, keywords) {
+    return `
+Calculate SEO score for this content:
+
+Content: "${content}"
+Keywords: ${keywords.join(", ")}
+
+Provide breakdown in JSON:
+{
+  "keywordDensity": 0-100,
+  "readabilityScore": 0-100,
+  "titleOptimization": 0-100,
+  "metaDescription": 0-100,
+  "headingStructure": 0-100,
+  "internalLinking": 0-100,
+  "overall": 0-100
+}
+
+Return only the JSON:
+`;
+  }
+  static abTestVariant(input) {
+    return `
+Predict performance for this content variant:
+
+Content: "${input.content}"
+Content Type: ${input.contentType}
+Tone: ${input.tone}
+Target Audience: ${input.targetAudience}
+Platform: ${input.platform}
+Goals: ${input.goals.join(", ")}
+
+Provide prediction in JSON:
+{
+  "predictedEngagement": 0-100,
+  "predictedCTR": 0-100,
+  "predictedConversions": 0-100,
+  "confidence": 0-1,
+  "reasoning": "...",
+  "strengths": ["strength1", ...],
+  "weaknesses": ["weakness1", ...],
+  "suggestions": ["suggestion1", ...]
+}
+
+Return only the JSON:
+`;
+  }
+  static hashtags(content, count) {
+    return `
+Generate ${count} relevant hashtags for this content:
+
+"${content}"
+
+Requirements:
+- Mix of popular and niche hashtags
+- Industry-specific when possible
+- Trending if relevant
+- No duplicated words
+- Format: #hashtag (one per line)
+
+Return only the hashtags:
+`;
+  }
+  static imagePrompt(description, style) {
+    return `
+Generate a detailed AI image generation prompt for:
+
+Description: ${description}
+Style: ${style || "realistic"}
+
+Create a detailed, descriptive prompt that includes:
+- Subject details
+- Mood and atmosphere
+- Lighting
+- Composition
+- Art style reference
+- Technical specifications (aspect ratio, quality)
+
+The prompt should be optimized for models like Midjourney, DALL-E, or Stable Diffusion.
+
+Generate the prompt:
+`;
+  }
+  static blogImagePrompts(blogContent) {
+    return `
+Analyze this blog content and generate 3-5 detailed image prompts for illustrative images:
+
+Blog Content: "${blogContent}"
+
+For each image prompt, provide:
+- Subject description
+- Mood and atmosphere
+- Style reference
+- Composition details
+- Technical specs
+
+Return as JSON array:
+["prompt1", "prompt2", "prompt3", ...]
+
+Return only the JSON:
+`;
+  }
+  static maxTokensForDuration(durationSeconds) {
+    return estimateTokenBudgetForDuration(durationSeconds);
+  }
+};
+
+// src/content/application/services/BlogService.ts
+var BlogService = class {
+  constructor(executor) {
+    this.executor = executor;
+  }
+  executor;
+  async generateBlogPost(request) {
+    const topic = validateTopicText(request.topic);
+    const keywords = validateKeywordList(request.targetKeywords);
+    const prompt = PromptBuilder.blogPost({
+      topic,
+      blogType: request.blogType,
+      keywords,
+      tone: request.tone,
+      targetAudience: request.targetAudience,
+      wordCount: request.wordCount,
+      language: request.language,
+      seoOptimization: request.seoOptimization,
+      includeSchema: request.includeSchema,
+      includeImages: request.includeImages
     });
+    const parsed = await this.executor.runJson(
+      prompt,
+      {},
+      { maxTokens: request.wordCount * 2, temperature: 0.7 }
+    );
+    return {
+      id: generateId("blog"),
+      ...parsed,
+      blogType: request.blogType,
+      tone: request.tone,
+      wordCount: request.wordCount,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
   }
-  streamCompletion(prompt, callbacks, options = {}) {
-    return this.streamChatCompletion([createUserMessage(prompt)], callbacks, options);
+};
+async function batchRequest(requests, options = {}) {
+  const {
+    concurrency = 3,
+    stopOnError = false
+  } = options;
+  const results = [];
+  const errors = [];
+  for (let i = 0; i < requests.length; i += concurrency) {
+    const batch = requests.slice(i, i + concurrency);
+    const batchResults = await Promise.allSettled(
+      batch.map((fn) => fn())
+    );
+    for (const result of batchResults) {
+      if (result.status === "fulfilled") {
+        results.push(result.value);
+      } else {
+        errors.push(result.reason);
+        if (stopOnError) {
+          throw new Error(
+            `Batch request failed: ${errors[0].message}`
+          );
+        }
+      }
+    }
   }
-  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
+  if (errors.length > 0 && !stopOnError) {
+    console.warn(`${errors.length} requests failed in batch`);
+  }
+  return results;
+}
+
+// src/content/application/services/SocialService.ts
+var MULTI_PLATFORMS = [
+  "twitter",
+  "linkedin",
+  "instagram",
+  "threads",
+  "tiktok"
+];
+var DEFAULT_SOCIAL_RESULT = {
+  content: "",
+  platform: "twitter",
+  hashtags: [],
+  emojis: [],
+  characterCount: 0,
+  estimatedEngagement: 0
+};
+var SocialService = class {
+  constructor(executor) {
+    this.executor = executor;
+  }
+  executor;
+  async generateSocialContent(request) {
+    const topic = validateTopicText(request.topic);
+    const spec = resolvePlatformSpec(request.platform);
+    const maxLength = resolveMaxContentLength(request.platform, request.maxLength);
+    const prompt = PromptBuilder.socialPost({
+      topic,
+      platform: request.platform,
+      tone: request.tone,
+      style: spec.style,
+      maxLength,
+      includeHashtags: request.hashtags !== false,
+      includeCallToAction: Boolean(request.includeCallToAction)
+    });
+    const parsed = await this.executor.runJson(
+      prompt,
+      { ...DEFAULT_SOCIAL_RESULT, platform: request.platform },
+      { maxTokens: 500, temperature: 0.8 }
+    );
+    return {
+      ...parsed,
+      platform: request.platform,
+      characterCount: parsed.content?.length ?? 0
+    };
+  }
+  async generateForAllPlatforms(topic, tone) {
+    const requests = MULTI_PLATFORMS.map(
+      (platform) => () => this.generateSocialContent({ topic, platform, tone })
     );
     try {
-      const stream = await this.httpClient.streamChatCompletion(request, {
-        signal: options.signal
-      });
-      const fullText = await parser.parse(stream);
-      callbacks.onComplete?.(fullText);
-      return fullText;
+      return await batchRequest(requests, { concurrency: 2, stopOnError: false });
     } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      callbacks.onError?.(err);
-      throw err;
+      console.warn("Batch execution failed, falling back to sequential:", error);
+      const results = [];
+      for (const platform of MULTI_PLATFORMS) {
+        try {
+          results.push(await this.generateSocialContent({ topic, platform, tone }));
+        } catch (err) {
+          console.error(`Failed to generate for ${platform}:`, err);
+        }
+      }
+      return results;
     }
   }
-  clearCache() {
-    this.cache.clear();
+  async generateHashtags(content, count) {
+    const validated = validateHashtagCount(count);
+    const prompt = PromptBuilder.hashtags(content, validated);
+    const response = await this.executor.runText(prompt, { maxTokens: 200, temperature: 0.7 });
+    const hashtags = response.match(/#[\w-]+/g) || [];
+    return hashtags.slice(0, validated);
   }
-  // --- ITextProvider implementation ---
-  resolveModel(tier) {
-    return GROQ_TIERS[tier] ?? this.defaultModel;
+  optimizeHashtags(hashtags, platform) {
+    const budget = resolveHashtagBudget(platform);
+    return rankAndTrimHashtags(hashtags, budget);
   }
-  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 ?? "";
+};
+
+// src/content/application/services/VideoScriptService.ts
+var buildScriptResult = (parsed, duration) => {
+  const script = parsed.script ?? "";
+  if (!script) {
+    throw new Error("AI response missing script field");
+  }
+  const wordCount = script.trim().length === 0 ? 0 : script.trim().split(/\s+/).length;
+  return {
+    ...parsed,
+    script,
+    duration,
+    wordCount
+  };
+};
+var VideoScriptService = class {
+  constructor(executor) {
+    this.executor = executor;
+  }
+  executor;
+  async generateVideoScript(request) {
+    const topic = validateTopicText(request.topic);
+    const duration = validateDurationSeconds(request.duration);
+    const prompt = PromptBuilder.videoScript({
+      topic,
+      tone: request.tone,
+      duration,
+      targetAudience: request.targetAudience,
+      includeVisuals: request.includeVisuals,
+      includeCallToAction: request.includeCallToAction
+    });
+    const parsed = await this.executor.runJson(
+      prompt,
+      { script: "", visualCues: [], duration, wordCount: 0, estimatedEngagement: 0 },
+      { maxTokens: estimateTokenBudgetForDuration(duration), temperature: 0.8 }
+    );
+    return buildScriptResult(parsed, duration);
+  }
+  async generateVoiceScript(topic, emotion, duration) {
+    const validatedTopic = validateTopicText(topic);
+    const validatedDuration = validateDurationSeconds(duration);
+    const prompt = PromptBuilder.voiceScript({
+      topic: validatedTopic,
+      emotion,
+      duration: validatedDuration
+    });
+    const parsed = await this.executor.runJson(
+      prompt,
+      { script: "", visualCues: [], duration: validatedDuration, wordCount: 0, estimatedEngagement: 0 },
+      { maxTokens: estimateTokenBudgetForDuration(validatedDuration), temperature: 0.8 }
+    );
+    return buildScriptResult(parsed, validatedDuration);
+  }
+};
+
+// src/content/application/services/AnalysisService.ts
+var DEFAULT_SENTIMENT = {
+  sentiment: "neutral",
+  confidence: 0.5,
+  emotions: []
+};
+var DEFAULT_ANALYSIS = {
+  sentiment: DEFAULT_SENTIMENT,
+  keywords: [],
+  entities: [],
+  suggestedImprovements: [],
+  readabilityScore: 50,
+  estimatedEngagement: 50
+};
+var AnalysisService = class {
+  constructor(executor) {
+    this.executor = executor;
+  }
+  executor;
+  async analyzeSentiment(content) {
+    const validated = validateContentBody(content);
+    const prompt = PromptBuilder.sentiment(validated);
+    const result = await this.executor.runJson(
+      prompt,
+      DEFAULT_SENTIMENT,
+      { maxTokens: 200, temperature: 0.3 }
+    );
     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
+      ...result,
+      confidence: clampConfidenceToValidRange(result.confidence)
     };
   }
-  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,
+  async analyzeContent(request) {
+    const validated = validateContentBody(request.content);
+    const sentimentResult = await this.analyzeSentiment(validated);
+    const prompt = PromptBuilder.contentAnalysis(validated);
+    const parsed = await this.executor.runJson(
+      prompt,
+      { ...DEFAULT_ANALYSIS, sentiment: sentimentResult },
+      { maxTokens: 300, temperature: 0.5 }
+    );
+    return {
+      sentiment: sentimentResult,
+      keywords: parsed.keywords ?? [],
+      entities: parsed.entities ?? [],
+      suggestedImprovements: parsed.suggestedImprovements ?? [],
+      readabilityScore: clampScoreToValidRange(parsed.readabilityScore),
+      estimatedEngagement: clampScoreToValidRange(parsed.estimatedEngagement)
+    };
+  }
+};
+
+// src/content/application/services/SeoService.ts
+var DEFAULT_SEO_SCORE = {
+  keywordDensity: 50,
+  readabilityScore: 50,
+  titleOptimization: 50,
+  metaDescription: 50,
+  headingStructure: 50,
+  internalLinking: 50,
+  overall: 50
+};
+var UNDERUTILIZED_SUGGESTION = "Consider using this keyword more frequently";
+var SeoService = class {
+  constructor(executor) {
+    this.executor = executor;
+  }
+  executor;
+  async optimizeSEO(request) {
+    const content = validateContentBody(request.content);
+    const keywords = validateKeywordList(request.keywords);
+    const prompt = PromptBuilder.seoOptimization(content, keywords);
+    const result = await this.executor.runJson(
+      prompt,
       {
-        onChunk: callbacks.onChunk,
-        onError: callbacks.onError
+        optimized: content,
+        score: 50,
+        suggestions: [],
+        addedKeywords: [],
+        removedFillerWords: 0,
+        readabilityImprovements: []
       },
-      {
-        model,
-        signal: request.signal,
-        generationConfig: {
-          temperature: request.temperature,
-          maxTokens: request.maxTokens
-        }
-      }
+      { maxTokens: 1e3, temperature: 0.7 }
     );
-    const result = {
-      text,
-      finishReason: "stop",
-      model,
-      providerId: this.id
+    return {
+      ...result,
+      score: clampScoreToValidRange(result.score)
     };
-    callbacks.onComplete?.(result);
-    return result;
   }
-  async countTokens(text) {
-    return Math.max(1, Math.ceil(text.length / 4));
+  async calculateSEOScore(content, keywords) {
+    const validatedContent = validateContentBody(content);
+    const validatedKeywords = validateKeywordList(keywords);
+    const prompt = PromptBuilder.seoOptimization(
+      truncateForSeoPreview(validatedContent),
+      validatedKeywords
+    );
+    const result = await this.executor.runJson(
+      prompt,
+      DEFAULT_SEO_SCORE,
+      { maxTokens: 200, temperature: 0.3 }
+    );
+    return {
+      keywordDensity: clampScoreToValidRange(result.keywordDensity),
+      readabilityScore: clampScoreToValidRange(result.readabilityScore),
+      titleOptimization: clampScoreToValidRange(result.titleOptimization),
+      metaDescription: clampScoreToValidRange(result.metaDescription),
+      headingStructure: clampScoreToValidRange(result.headingStructure),
+      internalLinking: clampScoreToValidRange(result.internalLinking),
+      overall: clampScoreToValidRange(result.overall)
+    };
   }
-  async estimateCost(_request) {
-    return 0;
+  analyzeKeywords(content, keywords) {
+    const validatedContent = validateContentBody(content);
+    const validatedKeywords = validateKeywordList(keywords);
+    return validatedKeywords.map((keyword) => {
+      const count = countKeywordOccurrences(validatedContent, keyword);
+      const density = calculateKeywordDensity(validatedContent, keyword);
+      return {
+        keyword,
+        count,
+        density,
+        prominence: classifyKeywordProminence(density),
+        suggestions: isUnderutilizedKeyword(density) ? [UNDERUTILIZED_SUGGESTION] : []
+      };
+    });
   }
-  async healthCheck() {
-    try {
-      await this.generateCompletion("ping", {
-        generationConfig: { maxTokens: 1 }
+};
+
+// src/content/application/services/ABTestService.ts
+var DEFAULT_PREDICTION = {
+  variantId: "",
+  predictedEngagement: 0,
+  predictedCTR: 0,
+  predictedConversions: 0,
+  confidence: 0,
+  reasoning: "",
+  strengths: [],
+  weaknesses: [],
+  suggestions: []
+};
+var VARIANT_A_ID = "A";
+var VARIANT_B_ID = "B";
+var FALLBACK_ENGAGEMENT = 50;
+var DEFAULT_RECOMMENDATIONS = [
+  "Test with larger audience",
+  "Monitor click-through rates"
+];
+var ABTestService = class {
+  constructor(executor) {
+    this.executor = executor;
+  }
+  executor;
+  async predictABTest(request) {
+    const predictions = [];
+    for (const variant of request.variants) {
+      const prompt = PromptBuilder.abTestVariant({
+        content: truncateForAbVariantPreview(variant.content),
+        contentType: variant.contentType,
+        tone: variant.tone,
+        targetAudience: request.targetAudience,
+        platform: request.platform,
+        goals: request.goals
+      });
+      const parsed = await this.executor.runJson(
+        prompt,
+        { ...DEFAULT_PREDICTION, variantId: variant.id },
+        { maxTokens: 300, temperature: 0.5 }
+      );
+      predictions.push({
+        variantId: variant.id,
+        predictedEngagement: clampScoreToValidRange(parsed.predictedEngagement),
+        predictedCTR: clampScoreToValidRange(parsed.predictedCTR),
+        predictedConversions: clampScoreToValidRange(parsed.predictedConversions),
+        confidence: clampConfidenceToValidRange(parsed.confidence),
+        reasoning: parsed.reasoning ?? "",
+        strengths: parsed.strengths ?? [],
+        weaknesses: parsed.weaknesses ?? [],
+        suggestions: parsed.suggestions ?? []
       });
-      return "healthy";
-    } catch {
-      return "unavailable";
     }
+    return predictions;
+  }
+  async compareVariants(variantA, variantB) {
+    const predictions = await this.predictABTest({
+      variants: [
+        { id: VARIANT_A_ID, content: variantA, contentType: "social", tone: "casual" },
+        { id: VARIANT_B_ID, content: variantB, contentType: "social", tone: "casual" }
+      ],
+      targetAudience: "general",
+      platform: "twitter",
+      goals: ["engagement", "clicks"]
+    });
+    const scoreA = predictions[0]?.predictedEngagement ?? FALLBACK_ENGAGEMENT;
+    const scoreB = predictions[1]?.predictedEngagement ?? FALLBACK_ENGAGEMENT;
+    const isTie = scoreA === scoreB;
+    const winner = selectHigherScoreVariantId(scoreA, scoreB, VARIANT_A_ID, VARIANT_B_ID);
+    const improvement = calculateImprovementPercentage(scoreA, scoreB);
+    return {
+      winner,
+      confidence: AB_TEST_DEFAULT_CONFIDENCE,
+      improvement: isTie ? "0%" : `+${improvement}% engagement`,
+      reasoning: isTie ? "Both variants have equal predicted engagement" : winner === VARIANT_A_ID ? "Variant A has more engaging content" : "Variant B has more engaging content",
+      recommendations: [...DEFAULT_RECOMMENDATIONS]
+    };
   }
-  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;
+};
+
+// src/content/application/services/ImagePromptService.ts
+var ImagePromptService = class {
+  constructor(executor) {
+    this.executor = executor;
   }
-  extractContent(content) {
-    if (!content) {
-      throw new GroqError(
-        "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
-        "No content generated from Groq API"
-      );
-    }
-    return content;
+  executor;
+  async generateImagePrompt(description, style) {
+    const validated = validateTopicText(description);
+    const prompt = PromptBuilder.imagePrompt(validated, style);
+    return this.executor.runText(prompt, { maxTokens: 300, temperature: 0.8 });
+  }
+  async generateImagePromptsForBlog(blogContent) {
+    const truncated = truncateForBlogPromptPreview(validateContentBody(blogContent));
+    const prompt = PromptBuilder.blogImagePrompts(truncated);
+    const prompts = await this.executor.runJson(prompt, [], {
+      maxTokens: 500,
+      temperature: 0.8
+    });
+    return Array.isArray(prompts) ? prompts : [];
   }
 };
 
-// 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);
+// src/content/application/services/ContentCalendarService.ts
+var toCalendarEntry = (item) => ({
+  date: resolveCalendarEntryDate(item.day),
+  topic: item.topic,
+  contentType: item.contentType,
+  platform: item.platform,
+  description: item.description,
+  estimatedEngagement: item.estimatedEngagement,
+  priority: item.priority
+});
+var ContentCalendarService = class {
+  constructor(executor) {
+    this.executor = executor;
   }
-  return result.slice(0, length);
-}
+  executor;
+  async generateContentCalendar(niche, days) {
+    const validatedNiche = validateTopicText(niche);
+    const validatedDays = validateCalendarDays(days);
+    const prompt = PromptBuilder.contentCalendar(validatedNiche, validatedDays);
+    const data = await this.executor.runJson(
+      prompt,
+      [],
+      {
+        maxTokens: estimateTokenBudgetForCalendarDays(validatedDays),
+        temperature: 0.8
+      }
+    );
+    const items = Array.isArray(data) ? data : Array.isArray(data?.calendar) ? data.calendar : Array.isArray(data?.entries) ? data.entries : [];
+    return items.map(toCalendarEntry);
+  }
+};
 
-// 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;
+// src/content/application/services/ProviderServices.ts
+var wrapProviderError = (operation, error) => {
+  const message = error instanceof Error ? error.message : "Unknown error";
+  return new AIError(`${operation} failed: ${message}`, "PROVIDER_ERROR", error);
+};
+var ensureFactory = (factory, operation) => {
+  if (factory.getAllProviders().length === 0) {
+    throw new AIError(
+      `${operation} failed: No providers are registered. Provide a ProviderConfig with at least one enabled provider when constructing AIContentService.`,
+      "PROVIDER_UNAVAILABLE"
+    );
   }
-  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 MediaGenerationService = class {
+  constructor(providerFactory) {
+    this.providerFactory = providerFactory;
+  }
+  providerFactory;
+  generateImage(request) {
+    ensureFactory(this.providerFactory, "Image generation");
+    return this.providerFactory.generateImage(request).catch((err) => {
+      throw wrapProviderError("Image generation", err);
+    });
+  }
+  generateVideo(request) {
+    ensureFactory(this.providerFactory, "Video generation");
+    return this.providerFactory.generateVideo(request).catch((err) => {
+      throw wrapProviderError("Video generation", err);
+    });
+  }
+  convertImageToVideo(request) {
+    ensureFactory(this.providerFactory, "Image-to-video conversion");
+    return this.providerFactory.imageToVideo(request).catch((err) => {
+      throw wrapProviderError("Image-to-video conversion", err);
+    });
+  }
+  transformVideo(request) {
+    ensureFactory(this.providerFactory, "Video-to-video transformation");
+    return this.providerFactory.videoToVideo(request).catch((err) => {
+      throw wrapProviderError("Video-to-video transformation", err);
+    });
   }
 };
-var chatIdGenerator = new ChatIdGenerator();
 
-// src/chat/utils/message-formatter.ts
-var MessageFormatter = class {
-  constructor(idGenerator = chatIdGenerator) {
-    this.idGenerator = idGenerator;
+// src/content/infrastructure/utils/jsonParser.ts
+function repairCommonJsonDefects2(text) {
+  return text.replace(/(:\s*-?\d+(?:\.\d+)?)\s*"/g, "$1").replace(/(:\s*"[^"]*")"/g, "$1");
+}
+function safeJSONParse(text, fallback, onError) {
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    try {
+      return JSON.parse(repairCommonJsonDefects2(text));
+    } catch {
+    }
+    if (error instanceof SyntaxError) {
+      const positionMatch = error.message.match(/position (\d+)/);
+      const position = positionMatch ? parseInt(positionMatch[1], 10) : -1;
+      if (position > 0) {
+        text.substring(Math.max(0, position - 50), position + 50);
+      }
+    }
+    return fallback;
   }
-  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
-      });
+}
+function extractJSON(text) {
+  const codeBlockMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+  if (codeBlockMatch && codeBlockMatch[1]) {
+    const candidate = codeBlockMatch[1].trim();
+    if (candidate.startsWith("{") || candidate.startsWith("[")) {
+      return candidate;
     }
-    return coreMessages;
   }
-  toChatMessage(content, sender) {
-    return {
-      id: this.idGenerator.next(sender),
-      sender,
-      content: content.trim(),
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      type: "text"
-    };
+  const objectMatch = text.match(/\{[\s\S]*\}/);
+  if (objectMatch) {
+    return objectMatch[0];
   }
-};
-var messageFormatter = new MessageFormatter();
+  const arrayMatch = text.match(/\[[\s\S]*\]/);
+  if (arrayMatch) {
+    return arrayMatch[0];
+  }
+  return null;
+}
+function parseAIResponse(response, fallback, onError) {
+  const json = extractJSON(response);
+  if (!json) {
+    return fallback;
+  }
+  return safeJSONParse(json, fallback);
+}
 
-// src/chat/utils/prompt-strategy.ts
-var DEFAULT_PROMPT_STRATEGY = {
-  resolve: (config) => {
-    if (config.systemPrompt && config.systemPrompt.length > 0) {
-      return config.systemPrompt;
+// src/content/application/services/GenerationExecutor.ts
+var GenerationExecutor = class {
+  constructor(generator) {
+    this.generator = generator;
+  }
+  generator;
+  async runJson(prompt, fallback, generationOptions = {}) {
+    const response = await this.generator.generateText(prompt, generationOptions);
+    return parseAIResponse(response, fallback);
+  }
+  runText(prompt, options = {}) {
+    return this.generator.generateText(prompt, options);
+  }
+  /** Usage-complete pass-through; requires a ProviderFactory engine. */
+  runChat(request) {
+    if (!(this.generator instanceof ProviderFactory)) {
+      throw new AIError(
+        "runChat requires a ProviderFactory engine \u2014 construct AIContentService with a provider config, not a custom ITextGenerator",
+        "PROVIDER_UNAVAILABLE"
+      );
     }
-    return void 0;
+    return this.generator.chat(request);
   }
 };
 
-// src/chat/services/chat.service.ts
-var DEFAULT_CONFIG = {
-  temperature: 0.8,
-  maxTokens: 500
+// src/content/application/services/AIContentService.ts
+var isTextGenerator = (value) => typeof value === "object" && value !== null && typeof value.generateText === "function";
+function toAIProviderConfig(config) {
+  const legacy = config;
+  const modern = config;
+  const anthropic = modern.anthropic ?? (legacy.anthropic?.enabled ? {
+    apiKey: legacy.anthropic.apiKey,
+    baseUrl: legacy.anthropic.baseUrl,
+    timeoutMs: legacy.anthropic.timeout,
+    models: legacy.anthropic.models,
+    effort: legacy.anthropic.effort
+  } : void 0);
+  const groq = modern.groq ?? (legacy.groq?.enabled ? {
+    apiKey: legacy.groq.apiKey,
+    baseUrl: legacy.groq.baseUrl,
+    timeoutMs: legacy.groq.timeout,
+    // legacy {text, chat} model pins map onto the neutral tier slots
+    ...legacy.groq.models?.text ? { models: { balanced: legacy.groq.models.text } } : {}
+  } : void 0);
+  const gemini = modern.gemini ?? (legacy.gemini?.enabled ? { ...legacy.gemini } : void 0);
+  const fal = modern.fal ?? (legacy.fal?.enabled ? { ...legacy.fal } : void 0);
+  const pruna = modern.pruna ?? (legacy.pruna?.enabled ? { ...legacy.pruna } : void 0);
+  return {
+    priority: modern.priority,
+    fallbackEnabled: modern.fallbackEnabled,
+    defaultTier: modern.defaultTier,
+    ...anthropic ? { anthropic } : {},
+    ...groq ? { groq } : {},
+    ...gemini ? { gemini } : {},
+    ...fal ? { fal } : {},
+    ...pruna ? { pruna } : {}
+  };
+}
+var buildServices = (configOrGenerator) => {
+  if (isTextGenerator(configOrGenerator)) {
+    const executor2 = new GenerationExecutor(configOrGenerator);
+    const emptyFactory = new ProviderFactory({
+      priority: [],
+      fallbackEnabled: false
+    });
+    return {
+      providerFactory: emptyFactory,
+      blogService: new BlogService(executor2),
+      socialService: new SocialService(executor2),
+      videoScriptService: new VideoScriptService(executor2),
+      analysisService: new AnalysisService(executor2),
+      seoService: new SeoService(executor2),
+      abTestService: new ABTestService(executor2),
+      imagePromptService: new ImagePromptService(executor2),
+      contentCalendarService: new ContentCalendarService(executor2),
+      mediaGenerationService: new MediaGenerationService(emptyFactory)
+    };
+  }
+  const factory = createAI(toAIProviderConfig(configOrGenerator));
+  const executor = new GenerationExecutor(factory);
+  return {
+    providerFactory: factory,
+    blogService: new BlogService(executor),
+    socialService: new SocialService(executor),
+    videoScriptService: new VideoScriptService(executor),
+    analysisService: new AnalysisService(executor),
+    seoService: new SeoService(executor),
+    abTestService: new ABTestService(executor),
+    imagePromptService: new ImagePromptService(executor),
+    contentCalendarService: new ContentCalendarService(executor),
+    mediaGenerationService: new MediaGenerationService(factory)
+  };
 };
-var ChatService = class {
-  constructor(engine) {
-    this.engine = engine;
+var AIContentService = class {
+  providerFactory;
+  blogService;
+  socialService;
+  videoScriptService;
+  analysisService;
+  seoService;
+  abTestService;
+  imagePromptService;
+  contentCalendarService;
+  mediaGenerationService;
+  constructor(configOrGenerator) {
+    const bundle = buildServices(configOrGenerator);
+    this.providerFactory = bundle.providerFactory;
+    this.blogService = bundle.blogService;
+    this.socialService = bundle.socialService;
+    this.videoScriptService = bundle.videoScriptService;
+    this.analysisService = bundle.analysisService;
+    this.seoService = bundle.seoService;
+    this.abTestService = bundle.abTestService;
+    this.imagePromptService = bundle.imagePromptService;
+    this.contentCalendarService = bundle.contentCalendarService;
+    this.mediaGenerationService = bundle.mediaGenerationService;
   }
-  engine;
-  config = DEFAULT_CONFIG;
-  promptStrategy = DEFAULT_PROMPT_STRATEGY;
-  storage = null;
-  initialize(config) {
-    this.config = { ...DEFAULT_CONFIG, ...config };
+  /** The composed factory — chat()/chatStream() with usage, health, fallback. */
+  get providers() {
+    return this.providerFactory;
   }
-  updateConfig(config) {
-    this.config = { ...this.config, ...config };
+  generateBlogPost(request) {
+    return this.blogService.generateBlogPost(request);
   }
-  setPromptStrategy(strategy) {
-    this.promptStrategy = strategy;
+  generateSocialContent(request) {
+    return this.socialService.generateSocialContent(request);
   }
-  setStorage(storage) {
-    this.storage = storage;
+  generateForAllPlatforms(topic, tone) {
+    return this.socialService.generateForAllPlatforms(topic, tone);
   }
-  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
-    };
+  generateHashtags(content, count) {
+    return this.socialService.generateHashtags(content, count);
   }
-  async getConversations() {
-    if (this.storage && "getConversations" in this.storage && typeof this.storage.getConversations === "function") {
-      return this.storage.getConversations();
-    }
-    return [];
+  optimizeHashtags(hashtags, platform) {
+    return Promise.resolve(this.socialService.optimizeHashtags(hashtags, platform));
   }
-  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 };
+  generateVideoScript(request) {
+    return this.videoScriptService.generateVideoScript(request);
   }
-  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
-      }
-    };
+  generateVoiceScript(topic, emotion, duration) {
+    return this.videoScriptService.generateVoiceScript(topic, emotion, duration);
   }
-  async generateStreamingResponse(userMessage, context, onChunk, signal) {
-    const request = this.buildRequest(userMessage, context, signal);
-    const result = await this.runStream(request, { onChunk });
-    return result.text;
+  generateContentCalendar(niche, days) {
+    return this.contentCalendarService.generateContentCalendar(niche, days);
   }
-  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 } : {}
-    };
+  analyzeSentiment(content) {
+    return this.analysisService.analyzeSentiment(content);
   }
-  resolveSystemPrompt() {
-    const prompt = this.promptStrategy.resolve(this.config);
-    return prompt && prompt.length > 0 ? prompt : void 0;
+  analyzeContent(request) {
+    return this.analysisService.analyzeContent(request);
   }
-  async run(request) {
-    if (this.engine instanceof ProviderFactory) {
-      return this.engine.chat(request);
-    }
-    return this.engine.generate(request);
+  optimizeSEO(request) {
+    return this.seoService.optimizeSEO(request);
   }
-  async runStream(request, callbacks) {
-    if (this.engine instanceof ProviderFactory) {
-      return this.engine.chatStream(request, callbacks);
-    }
-    return this.engine.stream(request, callbacks);
+  calculateSEOScore(content, keywords) {
+    return this.seoService.calculateSEOScore(content, keywords);
   }
-  requireStorage() {
-    if (!this.storage) {
-      throw new AIError(
-        "MISSING_CONFIG" /* MISSING_CONFIG */,
-        "ChatService.getConversation requires setStorage() to be called first."
-      );
-    }
-    return this.storage;
+  analyzeKeywords(content, keywords) {
+    return Promise.resolve(this.seoService.analyzeKeywords(content, keywords));
+  }
+  predictABTest(request) {
+    return this.abTestService.predictABTest(request);
+  }
+  compareVariants(variantA, variantB) {
+    return this.abTestService.compareVariants(variantA, variantB);
+  }
+  generateImagePrompt(description, style) {
+    return this.imagePromptService.generateImagePrompt(description, style);
+  }
+  generateImagePromptsForBlog(blogContent) {
+    return this.imagePromptService.generateImagePromptsForBlog(blogContent);
+  }
+  generateImage(request) {
+    return this.mediaGenerationService.generateImage(request);
+  }
+  generateVideo(request) {
+    return this.mediaGenerationService.generateVideo(request);
+  }
+  convertImageToVideo(request) {
+    return this.mediaGenerationService.convertImageToVideo(request);
+  }
+  transformVideo(request) {
+    return this.mediaGenerationService.transformVideo(request);
   }
 };
-function extractTokenUsage(message) {
-  const meta = message.metadata;
-  if (!meta) return null;
-  const usage = meta["usage"];
-  if (!usage || typeof usage !== "object") return null;
-  const u = usage;
-  const inputTokens = readNumber(u, ["input_tokens", "prompt_tokens"]);
-  const outputTokens = readNumber(u, ["output_tokens", "completion_tokens"]);
-  const totalTokens = readNumber(u, ["total_tokens"]);
-  if (inputTokens === null || outputTokens === null || totalTokens === null) {
-    return null;
+
+// src/wizard/content.wizard.ts
+var CONTENT_WIZARD_STEPS = [
+  {
+    id: "select-type",
+    label: "Select Type",
+    icon: "Layers",
+    description: "Choose the type of content you want to generate",
+    validate: (data) => Boolean(data.contentType)
+  },
+  {
+    id: "input-topic",
+    label: "Topic",
+    icon: "Lightbulb",
+    description: "Enter your topic or idea",
+    validate: (data) => {
+      const topic = data.topic;
+      return typeof topic === "string" && topic.length > 0;
+    }
+  },
+  {
+    id: "configure",
+    label: "Configure",
+    icon: "Settings",
+    description: "Set tone, audience, and platform",
+    validate: (data) => {
+      const d = data;
+      return Boolean(d.tone && d.targetAudience);
+    }
+  },
+  {
+    id: "advanced",
+    label: "Advanced",
+    icon: "Sliders",
+    description: "Additional options and optimizations",
+    optional: true
+  },
+  {
+    id: "preview",
+    label: "Preview",
+    icon: "Eye",
+    description: "Review your settings before generation"
+  },
+  {
+    id: "generating",
+    label: "Generating",
+    icon: "Sparkles",
+    description: "AI is generating your content"
+  },
+  {
+    id: "results",
+    label: "Results",
+    icon: "CheckCircle",
+    description: "Your generated content is ready"
   }
-  return {
-    promptTokens: inputTokens,
-    completionTokens: outputTokens,
-    totalTokens
-  };
-}
-function readNumber(source, keys) {
-  for (const key of keys) {
-    const value = source[key];
-    if (typeof value === "number") return value;
+];
+function buildContentRequest(data) {
+  switch (data.contentType) {
+    case "blog":
+      return {
+        topic: data.topic ?? "",
+        blogType: "tutorial",
+        targetKeywords: data.keywords ?? [],
+        tone: data.tone ?? "professional",
+        wordCount: data.wordCount ?? 1e3,
+        targetAudience: data.targetAudience ?? "",
+        seoOptimization: data.seoOptimization ?? false,
+        includeImages: data.includeImages ?? false,
+        includeSchema: false
+      };
+    case "social":
+      return {
+        topic: data.topic ?? "",
+        platform: data.platform ?? "twitter",
+        tone: data.tone ?? "casual",
+        hashtags: true,
+        targetAudience: data.targetAudience,
+        includeCallToAction: data.includeCallToAction
+      };
+    case "script":
+      return {
+        topic: data.topic ?? "",
+        tone: data.tone ?? "professional",
+        duration: data.duration ?? 60,
+        targetAudience: data.targetAudience ?? "",
+        includeVisuals: true,
+        includeCallToAction: data.includeCallToAction ?? false
+      };
+    default:
+      throw new Error(`Unsupported content type: ${data.contentType}`);
   }
-  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;
+// src/wizard/image.wizard.ts
+var IMAGE_WIZARD_STEPS = [
+  {
+    id: "input-prompt",
+    label: "Describe Image",
+    icon: "Image",
+    description: "Describe the image you want to create",
+    validate: (data) => {
+      const prompt = data.prompt;
+      return typeof prompt === "string" && prompt.length > 0;
+    }
+  },
+  {
+    id: "select-style",
+    label: "Style",
+    icon: "Palette",
+    description: "Choose the artistic style",
+    validate: (data) => Boolean(data.style)
+  },
+  {
+    id: "configure",
+    label: "Configure",
+    icon: "Settings",
+    description: "Set format, quality, and quantity",
+    validate: (data) => {
+      const d = data;
+      return Boolean(d.format && d.quality);
+    }
+  },
+  {
+    id: "advanced",
+    label: "Advanced",
+    icon: "Sliders",
+    description: "Color palette and platform optimization",
+    optional: true
+  },
+  { id: "preview", label: "Preview", icon: "Eye", description: "Review your settings" },
+  { id: "generating", label: "Generating", icon: "Sparkles", description: "AI is creating your image" },
+  { id: "results", label: "Results", icon: "Image", description: "Your generated image is ready" }
+];
+function buildImageRequest(data) {
+  return {
+    type: "image",
+    prompt: data.prompt ?? "",
+    style: data.style,
+    format: data.format,
+    quality: data.quality,
+    quantity: data.quantity ?? 1
+  };
 }
-function resetProvider() {
-  container?.groqHttpClient.reset();
-  container = null;
+
+// src/wizard/video.wizard.ts
+var validateSource = (data) => {
+  const d = data;
+  if (d.generationType === "text-to-video") {
+    return typeof d.prompt === "string" && d.prompt.length > 0;
+  }
+  if (d.generationType === "image-to-video") {
+    return typeof d.imageUrl === "string" && d.imageUrl.length > 0;
+  }
+  if (d.generationType === "video-to-video") {
+    return typeof d.sourceVideoUrl === "string" && d.sourceVideoUrl.length > 0 && typeof d.prompt === "string" && d.prompt.length > 0;
+  }
+  return false;
+};
+var VIDEO_WIZARD_STEPS = [
+  {
+    id: "select-type",
+    label: "Select Type",
+    icon: "Video",
+    description: "Choose video generation type",
+    validate: (data) => Boolean(data.generationType)
+  },
+  {
+    id: "input-source",
+    label: "Source",
+    icon: "FileInput",
+    description: "Provide your source (prompt, image, or video)",
+    validate: validateSource
+  },
+  {
+    id: "configure",
+    label: "Configure",
+    icon: "Settings",
+    description: "Set duration, aspect ratio, and style",
+    validate: (data) => {
+      const d = data;
+      return Boolean(d.duration && d.aspectRatio);
+    }
+  },
+  { id: "advanced", label: "Advanced", icon: "Sliders", description: "Additional video options", optional: true },
+  { id: "preview", label: "Preview", icon: "Eye", description: "Review your settings" },
+  { id: "generating", label: "Generating", icon: "Sparkles", description: "AI is creating your video" },
+  { id: "results", label: "Results", icon: "Video", description: "Your generated video is ready" }
+];
+function buildVideoRequest(data) {
+  switch (data.generationType) {
+    case "text-to-video":
+      return {
+        type: "video",
+        prompt: data.prompt ?? "",
+        duration: data.duration ?? 5,
+        aspectRatio: data.aspectRatio ?? "16:9",
+        style: data.style,
+        quality: data.quality
+      };
+    case "image-to-video":
+      return {
+        type: "video",
+        imageUrl: data.imageUrl ?? "",
+        prompt: data.prompt,
+        duration: data.duration ?? 5,
+        motion: data.motion ?? "medium",
+        camera: data.camera ?? "static"
+      };
+    case "video-to-video":
+      return {
+        type: "video",
+        sourceVideoUrl: data.sourceVideoUrl ?? "",
+        prompt: data.prompt ?? "",
+        styleTransfer: data.styleTransfer,
+        enhanceQuality: data.enhanceQuality
+      };
+    default:
+      throw new Error(`Unsupported generation type: ${data.generationType}`);
+  }
 }
 
+exports.ABTestService = ABTestService;
+exports.AIContentService = AIContentService;
 exports.AIError = AIError;
 exports.AIErrorType = AIErrorType;
 exports.ANTHROPIC_API_VERSION = ANTHROPIC_API_VERSION;
@@ -3592,14 +6041,23 @@ 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.ASPECT_RATIO_OPTIONS = ASPECT_RATIO_OPTIONS;
+exports.ASPECT_RATIO_VALUES = ASPECT_RATIO_VALUES;
+exports.AnalysisService = AnalysisService;
 exports.AnthropicHttpTransport = AnthropicHttpTransport;
 exports.AnthropicProvider = AnthropicProvider;
 exports.AnthropicRequestBuilder = AnthropicRequestBuilder;
+exports.AuthenticationError = AuthenticationError;
+exports.BaseAIProvider = BaseProvider;
 exports.BaseProvider = BaseProvider;
+exports.BlogService = BlogService;
+exports.CONTENT_WIZARD_STEPS = CONTENT_WIZARD_STEPS;
 exports.CacheManager = CacheManager;
+exports.CancellationError = CancellationError;
 exports.ChatIdGenerator = ChatIdGenerator;
 exports.ChatService = ChatService;
 exports.CompositeExecutor = CompositeExecutor;
+exports.ContentCalendarService = ContentCalendarService;
 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;
@@ -3616,9 +6074,12 @@ exports.DebounceManager = DebounceManager;
 exports.DedupeExecutor = DedupeExecutor;
 exports.FalProvider = FalProvider;
 exports.GEMINI_TIERS = GEMINI_TIERS;
+exports.GENERATION_COSTS = CREDIT_COSTS;
 exports.GROQ_MODELS = GROQ_MODELS;
 exports.GROQ_TIERS = GROQ_TIERS;
 exports.GeminiProvider = GeminiProvider;
+exports.GenerationExecutor = GenerationExecutor;
+exports.GenerationFailedError = GenerationFailedError;
 exports.GroqChatRequestBuilder = GroqChatRequestBuilder;
 exports.GroqConfigStore = GroqConfigStore;
 exports.GroqError = GroqError;
@@ -3626,11 +6087,20 @@ exports.GroqErrorType = AIErrorType;
 exports.GroqHttpClient = GroqHttpClient;
 exports.GroqHttpTransport = GroqHttpTransport;
 exports.GroqProvider = GroqProvider;
+exports.IMAGE_QUALITY_OPTIONS = IMAGE_QUALITY_OPTIONS;
+exports.IMAGE_QUALITY_VALUES = IMAGE_QUALITY_VALUES;
+exports.IMAGE_WIZARD_STEPS = IMAGE_WIZARD_STEPS;
+exports.ImagePromptService = ImagePromptService;
 exports.JSON_CODE_BLOCK_PATTERN = JSON_CODE_BLOCK_PATTERN;
 exports.JSON_OBJECT_PATTERN = JSON_OBJECT_PATTERN;
 exports.JsonResponseParser = JsonResponseParser;
+exports.MOTION_OPTIONS = MOTION_OPTIONS;
+exports.MediaGenerationService = MediaGenerationService;
+exports.PromptBuilder = PromptBuilder;
 exports.ProviderError = ProviderError;
 exports.ProviderFactory = ProviderFactory;
+exports.ProviderQuotaExhaustedError = ProviderQuotaExhaustedError;
+exports.ProviderUnavailableError = ProviderUnavailableError;
 exports.PrunaProvider = PrunaProvider;
 exports.QueueExecutor = QueueExecutor;
 exports.RequestDeduplicator = RequestDeduplicator;
@@ -3640,20 +6110,35 @@ exports.RetryManager = RetryManager;
 exports.SSE_BRIDGE_EVENTS = SSE_BRIDGE_EVENTS;
 exports.SSE_DONE_MARKER = SSE_DONE_MARKER;
 exports.SSE_PREFIX = SSE_PREFIX;
+exports.STYLE_PRESETS = STYLE_PRESETS;
+exports.SeoService = SeoService;
+exports.SocialService = SocialService;
 exports.StreamingResponseParser = StreamingResponseParser;
 exports.StructuredPromptBuilder = StructuredPromptBuilder;
 exports.TEXT_TIERS = TEXT_TIERS;
 exports.TIMEOUTS = TIMEOUTS;
 exports.TextGenerationService = TextGenerationService;
 exports.ThrottleManager = ThrottleManager;
+exports.TimeoutError = TimeoutError;
 exports.USER_FRIENDLY_ERROR_MESSAGES = USER_FRIENDLY_ERROR_MESSAGES;
+exports.VIDEO_DURATION_OPTIONS = VIDEO_DURATION_OPTIONS;
+exports.VIDEO_DURATION_OPTIONS_SECONDS = VIDEO_DURATION_OPTIONS_SECONDS;
+exports.VIDEO_QUALITY_OPTIONS = VIDEO_QUALITY_OPTIONS;
+exports.VIDEO_QUALITY_VALUES = VIDEO_QUALITY_VALUES;
+exports.VIDEO_WIZARD_STEPS = VIDEO_WIZARD_STEPS;
+exports.ValidationError = ValidationError2;
+exports.VideoScriptService = VideoScriptService;
 exports.asObjectArray = asObjectArray;
 exports.asRecord = asRecord;
 exports.asStringArray = asStringArray;
 exports.asTrimmedOptionalString = asTrimmedOptionalString;
 exports.buildCacheKey = buildCacheKey;
+exports.buildContentRequest = buildContentRequest;
 exports.buildHttpStatusFallback = buildHttpStatusFallback;
+exports.buildImageRequest = buildImageRequest;
+exports.buildVideoRequest = buildVideoRequest;
 exports.cacheManager = cacheManager;
+exports.calculateCreditCost = calculateContentCreditCost;
 exports.chatIdGenerator = chatIdGenerator;
 exports.clampScore = clampScore;
 exports.classifyHttpStatus = classifyHttpStatus;
@@ -3664,7 +6149,9 @@ exports.createAI = createAI;
 exports.createAssistantMessage = createAssistantMessage;
 exports.createFalProvider = createFalProvider;
 exports.createGeminiProvider = createGeminiProvider;
+exports.createGroqProvider = createGroqProvider;
 exports.createMessage = createMessage;
+exports.createProviderFactory = createProviderFactory;
 exports.createPrunaProvider = createPrunaProvider;
 exports.createSseResponse = createSseResponse;
 exports.createSystemMessage = createSystemMessage;
@@ -3685,8 +6172,12 @@ exports.extractTextFromMessages = extractTextFromMessages;
 exports.extractTokenUsage = extractTokenUsage;
 exports.formatErrorForLogging = formatErrorForLogging;
 exports.formatMessagesForDisplay = formatMessagesForDisplay;
+exports.generateImageThenVideo = generateImageThenVideo;
+exports.generatePruna = generate;
 exports.generateWithPruna = generateWithPruna;
+exports.getDimensionsForAspectRatio = getDimensionsForAspectRatio;
 exports.getProvider = getProvider;
+exports.getRecommendedQuality = getRecommendedQuality;
 exports.isAuthErrorType = isAuthErrorType;
 exports.isMediaProvider = isMediaProvider;
 exports.isRetryableErrorType = isRetryableErrorType;
@@ -3700,6 +6191,7 @@ exports.mergeTierOverrides = mergeTierOverrides;
 exports.messageFormatter = messageFormatter;
 exports.normalizeSseChunk = normalizeSseChunk;
 exports.oneOfCatalog = oneOfCatalog;
+exports.pollForResult = pollForResult;
 exports.promptToMessages = promptToMessages;
 exports.repairCommonJsonDefects = repairCommonJsonDefects;
 exports.requestDeduplicator = requestDeduplicator;
@@ -3711,9 +6203,11 @@ exports.resolveUserFriendlyErrorMessage = resolveUserFriendlyErrorMessage;
 exports.resolveUserFriendlyMessage = resolveUserFriendlyMessage;
 exports.retryManager = retryManager;
 exports.splitSseLines = splitSseLines;
+exports.submitPrediction = submitPrediction;
 exports.throttle = throttle;
 exports.throttleManager = throttleManager;
 exports.toGroqMessages = toGroqMessages;
+exports.uploadImage = uploadImage;
 exports.validateApiKey = validateApiKey;
 exports.withRetry = withRetry;
 //# sourceMappingURL=index.cjs.map