@umituz/web-ai 1.0.4 → 1.0.5

package/dist/content/index.cjs

@@ -4190,7 +4190,14 @@ var BlogService = class {
 };
 
 // src/content/infrastructure/utils/requestQueue.ts
-({
+var RequestPriority = /* @__PURE__ */ ((RequestPriority2) => {
+  RequestPriority2[RequestPriority2["LOW"] = 0] = "LOW";
+  RequestPriority2[RequestPriority2["NORMAL"] = 1] = "NORMAL";
+  RequestPriority2[RequestPriority2["HIGH"] = 2] = "HIGH";
+  RequestPriority2[RequestPriority2["URGENT"] = 3] = "URGENT";
+  return RequestPriority2;
+})(RequestPriority || {});
+var DEFAULT_CONFIG = {
   maxConcurrent: RequestQueueConfig.MAX_CONCURRENT,
   maxQueueSize: RequestQueueConfig.MAX_QUEUE_SIZE,
   defaultTimeout: RequestQueueConfig.DEFAULT_TIMEOUT_MS,
@@ -4198,7 +4205,133 @@ var BlogService = class {
   enableRateLimit: RequestQueueConfig.RATE_LIMIT.ENABLED,
   rateLimitWindow: RequestQueueConfig.RATE_LIMIT.WINDOW_MS,
   rateLimitMaxRequests: RequestQueueConfig.RATE_LIMIT.MAX_REQUESTS_PER_WINDOW
-});
+};
+var RequestQueue2 = class {
+  queue = [];
+  running = /* @__PURE__ */ new Set();
+  config;
+  requestHistory = [];
+  isProcessing = false;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  async add(fn, priority = 1 /* NORMAL */, maxRetries = 3) {
+    if (this.queue.length >= this.config.maxQueueSize) {
+      throw new Error("Queue is full");
+    }
+    return new Promise((resolve, reject) => {
+      const request = {
+        id: generateId("req"),
+        priority,
+        timestamp: Date.now(),
+        fn,
+        resolve,
+        reject,
+        retries: 0,
+        maxRetries
+      };
+      this.queue.push(request);
+      this.sortQueue();
+      if (!this.isProcessing) {
+        this.process();
+      }
+    });
+  }
+  sortQueue() {
+    this.queue.sort((a, b) => {
+      if (a.priority !== b.priority) {
+        return b.priority - a.priority;
+      }
+      return a.timestamp - b.timestamp;
+    });
+  }
+  async process() {
+    if (this.isProcessing) return;
+    this.isProcessing = true;
+    while (this.queue.length > 0 || this.running.size > 0) {
+      while (this.queue.length > 0 && this.running.size < this.config.maxConcurrent) {
+        if (this.config.enableRateLimit && !this.canMakeRequest()) {
+          break;
+        }
+        const request = this.queue.shift();
+        if (!request) break;
+        this.running.add(request.id);
+        this.executeRequest(request);
+      }
+      await new Promise((resolve) => setTimeout(resolve, RequestQueueConfig.POLL_INTERVAL_MS));
+    }
+    this.isProcessing = false;
+  }
+  canMakeRequest() {
+    const now = Date.now();
+    const windowStart = now - this.config.rateLimitWindow;
+    this.requestHistory = this.requestHistory.filter(
+      (timestamp) => timestamp > windowStart
+    );
+    return this.requestHistory.length < this.config.rateLimitMaxRequests;
+  }
+  async executeRequest(request) {
+    try {
+      if (this.config.enableRateLimit) {
+        this.requestHistory.push(Date.now());
+      }
+      const result = await this.withTimeout(
+        request.fn,
+        this.config.defaultTimeout
+      );
+      request.resolve(result);
+    } catch (error) {
+      if (request.retries < request.maxRetries) {
+        request.retries++;
+        const delay = this.config.retryDelay * request.retries;
+        setTimeout(() => {
+          this.queue.unshift(request);
+          this.sortQueue();
+        }, delay);
+      } else {
+        request.reject(error);
+      }
+    } finally {
+      this.running.delete(request.id);
+    }
+  }
+  async withTimeout(fn, timeout) {
+    const controller = new AbortController();
+    let timeoutId;
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutId = setTimeout(() => {
+        controller.abort();
+        reject(new Error("Request timeout"));
+      }, timeout);
+    });
+    try {
+      const result = await Promise.race([fn(controller.signal), timeoutPromise]);
+      return result;
+    } finally {
+      if (timeoutId) clearTimeout(timeoutId);
+    }
+  }
+  getStats() {
+    return {
+      queued: this.queue.length,
+      running: this.running.size,
+      rateLimitRemaining: this.config.enableRateLimit ? this.config.rateLimitMaxRequests - this.requestHistory.filter(
+        (timestamp) => Date.now() - timestamp < this.config.rateLimitWindow
+      ).length : Infinity
+    };
+  }
+  clear() {
+    for (const request of this.queue) {
+      request.reject(new Error("Queue cleared"));
+    }
+    this.queue = [];
+  }
+  async drain() {
+    while (this.running.size > 0) {
+      await new Promise((resolve) => setTimeout(resolve, RequestQueueConfig.POLL_INTERVAL_MS));
+    }
+  }
+};
 async function batchRequest(requests, options = {}) {
   const {
     concurrency = 3,
@@ -4682,7 +4815,10 @@ function safeJSONParse(text, fallback, onError) {
       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);
+        const context = text.substring(Math.max(0, position - 50), position + 50);
+        onError?.(`JSON parse error at position ${position}: "${context}"`);
+      } else {
+        onError?.(`JSON parse error: ${error.message}`);
       }
     }
     return fallback;
@@ -4709,9 +4845,23 @@ function extractJSON(text) {
 function parseAIResponse(response, fallback, onError) {
   const json = extractJSON(response);
   if (!json) {
+    onError?.("No JSON payload found in response");
     return fallback;
   }
-  return safeJSONParse(json, fallback);
+  return safeJSONParse(json, fallback, onError);
+}
+function isValidJSON(text) {
+  const trimmed = text.trim();
+  if (trimmed.length === 0) return false;
+  if (!(trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]"))) {
+    return false;
+  }
+  try {
+    JSON.parse(trimmed);
+    return true;
+  } catch {
+    return false;
+  }
 }
 
 // src/content/application/services/GenerationExecutor.ts
@@ -4772,7 +4922,48 @@ function toAIProviderConfig(config) {
     ...pruna ? { pruna } : {}
   };
 }
-var buildServices = (configOrGenerator) => {
+var buildServices = (configOrGenerator, model, customGenerator) => {
+  if (customGenerator) {
+    const executor2 = new GenerationExecutor(customGenerator);
+    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)
+    };
+  }
+  if (typeof configOrGenerator === "string") {
+    const aiConfig = {
+      anthropic: {
+        apiKey: configOrGenerator,
+        ...model ? { models: { balanced: model } } : {}
+      }
+    };
+    const factory2 = createAI(aiConfig);
+    const executor2 = new GenerationExecutor(factory2);
+    return {
+      providerFactory: factory2,
+      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(factory2)
+    };
+  }
   if (isTextGenerator(configOrGenerator)) {
     const executor2 = new GenerationExecutor(configOrGenerator);
     const emptyFactory = new ProviderFactory({
@@ -4818,8 +5009,8 @@ var AIContentService = class {
   imagePromptService;
   contentCalendarService;
   mediaGenerationService;
-  constructor(configOrGenerator) {
-    const bundle = buildServices(configOrGenerator);
+  constructor(configOrGenerator, model, textGenerator) {
+    const bundle = buildServices(configOrGenerator, model, textGenerator);
     this.providerFactory = bundle.providerFactory;
     this.blogService = bundle.blogService;
     this.socialService = bundle.socialService;
@@ -5131,6 +5322,7 @@ exports.BlogService = BlogService;
 exports.CONTENT_WIZARD_STEPS = CONTENT_WIZARD_STEPS;
 exports.CREDIT_COSTS = CREDIT_COSTS;
 exports.ContentCalendarService = ContentCalendarService;
+exports.ContentRequestQueue = RequestQueue2;
 exports.DEFAULT_CREDIT_COST = DEFAULT_CREDIT_COST;
 exports.DEFAULT_HASHTAG_BUDGET = DEFAULT_HASHTAG_BUDGET;
 exports.GENERATION_COSTS = CREDIT_COSTS;
@@ -5148,6 +5340,7 @@ exports.PromptBuilder = PromptBuilder;
 exports.ProviderQuotaExhaustedError = ProviderQuotaExhaustedError;
 exports.ProviderTimingConfig = ProviderTimingConfig;
 exports.ProviderUnavailableError = ProviderUnavailableError;
+exports.RequestPriority = RequestPriority;
 exports.RequestQueueConfig = RequestQueueConfig;
 exports.STYLE_PRESETS = STYLE_PRESETS;
 exports.SeoService = SeoService;
@@ -5162,6 +5355,7 @@ exports.VIDEO_WIZARD_STEPS = VIDEO_WIZARD_STEPS;
 exports.ValidationError = ValidationError;
 exports.ValidationLimits = ValidationLimits;
 exports.VideoScriptService = VideoScriptService;
+exports.batchRequest = batchRequest;
 exports.buildContentRequest = buildContentRequest;
 exports.buildImageRequest = buildImageRequest;
 exports.buildVideoRequest = buildVideoRequest;
@@ -5183,10 +5377,13 @@ exports.estimateTokenBudgetForCalendarDays = estimateTokenBudgetForCalendarDays;
 exports.estimateTokenBudgetForDuration = estimateTokenBudgetForDuration;
 exports.estimateUnknownProviderCost = estimateUnknownProviderCost;
 exports.estimateWordCountForDuration = estimateWordCountForDuration;
+exports.extractJSON = extractJSON;
 exports.generateId = generateId;
 exports.getDimensionsForAspectRatio = getDimensionsForAspectRatio;
 exports.getRecommendedQuality = getRecommendedQuality;
 exports.isUnderutilizedKeyword = isUnderutilizedKeyword;
+exports.isValidJSON = isValidJSON;
+exports.parseAIResponse = parseAIResponse;
 exports.rankAndTrimHashtags = rankAndTrimHashtags;
 exports.recommendQualityForAspectRatio = recommendQualityForAspectRatio;
 exports.resolveCalendarEntryDate = resolveCalendarEntryDate;
@@ -5197,6 +5394,7 @@ exports.resolveFalInferenceSteps = resolveFalInferenceSteps;
 exports.resolveHashtagBudget = resolveHashtagBudget;
 exports.resolveMaxContentLength = resolveMaxContentLength;
 exports.resolvePlatformSpec = resolvePlatformSpec;
+exports.safeJSONParse = safeJSONParse;
 exports.selectHigherScoreVariantId = selectHigherScoreVariantId;
 exports.toQualityTier = toQualityTier;
 exports.truncateForAbVariantPreview = truncateForAbVariantPreview;