@llm-newsletter-kit/core 2.0.6 → 3.0.0

package/README.md

@@ -21,7 +21,7 @@ A type‑first, extensible toolkit that automates LLM‑based newsletter creatio
 - Type-first design (TypeScript, ESM) with strong contracts
 - Flexible dependency injection: easily swap Crawling/Analysis/ContentGenerate/Task/Logging/Email
 - Operational features built-in: retries, chain options, preview email sending, etc.
-- Rollup build (ESM+CJS+d.ts), Vitest 100% coverage, GitHub Actions CI included
+- Rollup build (ESM+d.ts), Vitest 100% coverage, GitHub Actions CI included
 
 ## Project Background
 
@@ -101,12 +101,8 @@ const config: GenerateNewsletterConfig<string> = {
   },
   crawlingProvider: {
     // customFetch: myProxyFetch,  // Optional: custom fetch for proxy support
-    crawlingTargetGroups: [
-      /* ... */
-    ],
-    fetchExistingArticlesByUrls: async (urls) => [
-      /* ... */
-    ],
+    crawlingTargetGroups: [/* ... */],
+    fetchExistingArticlesByUrls: async (urls) => [/* ... */],
     saveCrawledArticles: async (articles, context) => articles.length,
   },
   analysisProvider: {
@@ -114,12 +110,8 @@ const config: GenerateNewsletterConfig<string> = {
     classifyTagOptions: { model: openai('gpt-5-mini') },
     analyzeImagesOptions: { model: openai('gpt-5.1') },
     determineScoreOptions: { model: openai('gpt-5.1') },
-    fetchUnscoredArticles: async () => [
-      /* ... */
-    ],
-    fetchTags: async () => [
-      /* ... */
-    ],
+    fetchUnscoredArticles: async () => [/* ... */],
+    fetchTags: async () => [/* ... */],
     update: async (article) => {},
   },
   contentGenerateProvider: {
@@ -128,9 +120,7 @@ const config: GenerateNewsletterConfig<string> = {
     issueOrder: 1,
     newsletterBrandName: 'Tech Insight Weekly',
     publicationCriteria: { minimumArticleCountForIssue: 5 },
-    fetchArticleCandidates: async () => [
-      /* ... */
-    ],
+    fetchArticleCandidates: async () => [/* ... */],
     htmlTemplate: ({ content }) => `<html>...</html>`,
     saveNewsletter: async ({ newsletter }) => ({ id: 1 }),
   },
@@ -149,6 +139,88 @@ const newsletterId = await generator.generate();
 
 👉 **See the reference implementation: https://github.com/heripo-lab/heripo-research-radar**
 
+## Customizing LLM Prompts (PromptProvider)
+
+The kit ships with built-in prompts designed to cover a wide range of domains. However, these general-purpose prompts may not be flexible enough for specialized requirements. For example:
+
+- Your domain uses unique terminology or jargon that the default prompts don't account for
+- You need a specific newsletter tone or structure (e.g., academic style, casual briefing)
+- Tag classification requires domain-specific taxonomy rules
+- Importance scoring needs custom criteria tailored to your industry
+
+`PromptProvider` lets you **replace** any built-in prompt — system prompt, user prompt, or both — on a per-stage basis while keeping the rest of the pipeline intact.
+
+### How It Works
+
+PromptProvider is organized by pipeline stage. Every field is optional — omitted prompts fall back to the built-in defaults.
+
+```
+PromptProvider
+├── analysis
+│   ├── classifyTags        — Tag classification (system / user)
+│   ├── analyzeImages       — Image analysis (system / user)
+│   └── determineImportance — Importance scoring (system / user)
+└── contentGenerate
+    └── generateNewsletter  — Final newsletter generation (system / user)
+```
+
+Each prompt slot is a `PromptBuilder<TContext>` — an object with optional `system` and `user` functions. The function receives a typed context object containing all the data the default prompt would use (articles, tags, expert fields, dates, etc.), so you have full control over prompt construction.
+
+> **Dependency note:** Analysis prompts (classifyTags → analyzeImages → determineImportance) produce data that flows into the content generation prompt. Changing an analysis prompt may indirectly affect the final newsletter output.
+
+### Example
+
+```ts
+import type {
+  GenerateNewsletterConfig,
+  PromptProvider,
+} from '@llm-newsletter-kit/core';
+
+const promptProvider: PromptProvider = {
+  analysis: {
+    // Override only the system prompt for tag classification
+    classifyTags: {
+      system: (ctx) =>
+        `You are a legal-domain specialist. Classify articles using ` +
+        `legal taxonomy standards. Available tags: ${ctx.existTags.join(', ')}. ` +
+        `Output language: ${ctx.outputLanguage}.`,
+      // user prompt falls back to the built-in default
+    },
+    // Override importance scoring with domain-specific criteria
+    determineImportance: {
+      system: (ctx) =>
+        `Score article importance for ${ctx.expertFields.join(', ')} professionals. ` +
+        `Regulatory changes and court rulings score 8+. ` +
+        `Commentary and opinion pieces score 3-5.`,
+      user: (ctx) =>
+        `Article: ${ctx.targetArticle.title}\n` +
+        `Content: ${ctx.targetArticle.detailContent}\n` +
+        `Score this article 1-10.`,
+    },
+  },
+  contentGenerate: {
+    // Override the newsletter generation prompt entirely
+    generateNewsletter: {
+      system: (ctx) =>
+        `You produce a weekly legal digest for "${ctx.newsletterBrandName}". ` +
+        `Write in ${ctx.outputLanguage}. Use formal academic tone.`,
+      user: (ctx) =>
+        `Publication date: ${ctx.dateService.getPublicationDisplayDateString()}\n\n` +
+        ctx.targetArticles
+          .map((a) => `- [${a.title}](${a.url}) (score: ${a.importanceScore})`)
+          .join('\n'),
+    },
+  },
+};
+
+const config: GenerateNewsletterConfig<string> = {
+  // ... other config (contentOptions, dateService, taskService, providers, etc.)
+  promptProvider, // Inject custom prompts
+};
+```
+
+For full context types (`ClassifyTagsPromptContext`, `GenerateNewsletterPromptContext`, etc.), see `src/generate-newsletter/models/prompt-provider.ts`.
+
 ## Public API Overview
 
 Entry point: `src/index.ts`
@@ -163,6 +235,7 @@ Entry point: `src/index.ts`
   - AnalysisProvider { classifyTagOptions.model, analyzeImagesOptions.model, determineScoreOptions(model, minimumImportanceScoreRules), fetchUnscoredArticles, fetchTags, update }
   - ContentGenerateProvider { model and generation options, issueOrder, publicationCriteria, subscribePageUrl, newsletterBrandName, fetchArticleCandidates, htmlTemplate, saveNewsletter }
   - GenerateNewsletterOptions { logger, llm, chain, previewNewsletter(emailService/emailMessage/fetchNewsletterForPreview) }
+  - PromptProvider { analysis?(classifyTags, analyzeImages, determineImportance), contentGenerate?(generateNewsletter) }
   - Domain models: DateService, EmailService, Newsletter, etc.
 
 For detailed field descriptions, see `src/generate-newsletter/models/interfaces.ts` and type definitions under `src/models/*`.

package/dist/index.d.ts

@@ -289,44 +289,6 @@ type ChainOptions = {
     stopAfterAttempt?: number;
 };
 
-/**
- * Token markers in template.
- */
-type HtmlTemplateMarkers = {
-    /**
-     * Title token
-     *
-     * When the title is set to "NEWSLETTER_TITLE", it replaces the "{{NEWSLETTER_TITLE}}" pattern in the template string.
-     *
-     * @default "NEWSLETTER_TITLE"
-     */
-    title?: string;
-    /**
-     * Content HTML token
-     *
-     * When content is set to "NEWSLETTER_CONTENT", it replaces the "{{NEWSLETTER_CONTENT}}" pattern in the template string.
-     *
-     * @default "NEWSLETTER_CONTENT"
-     */
-    content?: string;
-};
-/**
- * String template and marker set
- */
-type HtmlTemplate = {
-    /**
-     * Original template string
-     */
-    html: string;
-    /**
-     * Uses default markers when not specified
-     */
-    markers?: HtmlTemplateMarkers;
-};
-type RequiredHtmlTemplate = Pick<HtmlTemplate, 'html'> & {
-    markers: Required<HtmlTemplateMarkers>;
-};
-
 /**
  * Type representing an email address.
  * @example "user@example.com"
@@ -488,6 +450,108 @@ interface DateService {
     getPublicationDisplayDateString: () => string;
 }
 
+/**
+ * A pair of optional prompt builder functions.
+ * The returned string **replaces** the built-in default prompt entirely.
+ * If omitted, the default prompt is used.
+ */
+type PromptBuilder<TContext> = {
+    system?: (context: TContext) => string;
+    user?: (context: TContext) => string;
+};
+type ClassifyTagsPromptContext = {
+    expertFields: string[];
+    outputLanguage: string;
+    targetArticle: UnscoredArticle;
+    existTags: string[];
+};
+type AnalyzeImagesPromptContext = {
+    expertFields: string[];
+    outputLanguage: string;
+    targetArticle: UnscoredArticle;
+};
+type DetermineImportancePromptContext = {
+    expertFields: string[];
+    targetArticle: UnscoredArticle;
+    dateService: DateService;
+    minimumImportanceScoreRules: MinimumImportanceScoreRule[];
+};
+type GenerateNewsletterPromptContext = {
+    expertFields: string[];
+    outputLanguage: string;
+    dateService: DateService;
+    targetArticles: ArticleForGenerateContent[];
+    freeFormIntro?: boolean;
+    titleContext?: string;
+    subscribePageUrl?: UrlString;
+    newsletterBrandName: string;
+};
+/**
+ * Optional provider for customizing LLM prompts.
+ * Grouped by pipeline stage. All fields are optional —
+ * omitted prompts fall back to built-in defaults.
+ *
+ * **Dependency note:** Analysis prompts (❶❷❸) produce data that flows
+ * into the content generation prompt (❹). Changing an analysis prompt
+ * may indirectly affect the final newsletter output.
+ */
+interface PromptProvider {
+    /**
+     * Analysis stage prompts (❶ classifyTags → ❷ analyzeImages → ❸ determineImportance).
+     * Results feed into the content generation stage.
+     */
+    analysis?: {
+        classifyTags?: PromptBuilder<ClassifyTagsPromptContext>;
+        analyzeImages?: PromptBuilder<AnalyzeImagesPromptContext>;
+        determineImportance?: PromptBuilder<DetermineImportancePromptContext>;
+    };
+    /**
+     * Content generation stage prompt (❹ generateNewsletter).
+     * Produces the final newsletter title and body.
+     */
+    contentGenerate?: {
+        generateNewsletter?: PromptBuilder<GenerateNewsletterPromptContext>;
+    };
+}
+
+/**
+ * Token markers in template.
+ */
+type HtmlTemplateMarkers = {
+    /**
+     * Title token
+     *
+     * When the title is set to "NEWSLETTER_TITLE", it replaces the "{{NEWSLETTER_TITLE}}" pattern in the template string.
+     *
+     * @default "NEWSLETTER_TITLE"
+     */
+    title?: string;
+    /**
+     * Content HTML token
+     *
+     * When content is set to "NEWSLETTER_CONTENT", it replaces the "{{NEWSLETTER_CONTENT}}" pattern in the template string.
+     *
+     * @default "NEWSLETTER_CONTENT"
+     */
+    content?: string;
+};
+/**
+ * String template and marker set
+ */
+type HtmlTemplate = {
+    /**
+     * Original template string
+     */
+    html: string;
+    /**
+     * Uses default markers when not specified
+     */
+    markers?: HtmlTemplateMarkers;
+};
+type RequiredHtmlTemplate = Pick<HtmlTemplate, 'html'> & {
+    markers: Required<HtmlTemplateMarkers>;
+};
+
 /**
  * Publishable final Newsletter entity.
  */
@@ -807,6 +871,11 @@ type GenerateNewsletterConfig<TaskId> = {
      * Optional behavior/settings.
      */
     options?: GenerateNewsletterOptions;
+    /**
+     * Optional provider for customizing LLM prompts.
+     * When omitted, built-in default prompts are used.
+     */
+    promptProvider?: PromptProvider;
 };
 
 /**
@@ -822,6 +891,7 @@ declare class GenerateNewsletter<TaskId> {
     private readonly contentGenerateProvider;
     private readonly logger;
     private readonly options;
+    private readonly promptProvider?;
     private readonly previewNewsletterOptions?;
     /** Independent internal field **/
     private taskId;
@@ -858,4 +928,4 @@ declare class GenerateNewsletter<TaskId> {
 }
 
 export { DateType, GenerateNewsletter };
-export type { AnalysisProvider, AppLogger, ArticleForGenerateContent, ArticleForUpdateByAnalysis, ContentGenerateProvider, CrawlingProvider, CrawlingTarget, CrawlingTargetGroup, DateService, EmailAddress, EmailAttachment, EmailMessage, EmailService, GenerateNewsletterConfig, GenerateNewsletterOptions, HtmlString, HtmlTemplate, HtmlTemplateMarkers, IsoDateString, LogLevel, LogMessage, MarkdownString, MinimumImportanceScoreRule, Newsletter, ParsedTarget, ParsedTargetDetail, ParsedTargetListItem, RequiredHtmlTemplate, TaskService, UniqueIdentifier, UnscoredArticle, UrlString };
+export type { AnalysisProvider, AnalyzeImagesPromptContext, AppLogger, ArticleForGenerateContent, ArticleForUpdateByAnalysis, ClassifyTagsPromptContext, ContentGenerateProvider, CrawlingProvider, CrawlingTarget, CrawlingTargetGroup, DateService, DetermineImportancePromptContext, EmailAddress, EmailAttachment, EmailMessage, EmailService, GenerateNewsletterConfig, GenerateNewsletterOptions, GenerateNewsletterPromptContext, HtmlString, HtmlTemplate, HtmlTemplateMarkers, IsoDateString, LogLevel, LogMessage, MarkdownString, MinimumImportanceScoreRule, Newsletter, ParsedTarget, ParsedTargetDetail, ParsedTargetListItem, PromptBuilder, PromptProvider, RequiredHtmlTemplate, TaskService, UniqueIdentifier, UnscoredArticle, UrlString };

package/dist/index.js

@@ -3,6 +3,7 @@ import { pick, omit } from 'es-toolkit';
 import { z } from 'zod';
 import { generateText, Output } from 'ai';
 import { JSDOM } from 'jsdom';
+import juice from 'juice';
 import safeMarkdown2Html from 'safe-markdown2html';
 import { randomUUID } from 'node:crypto';
 
@@ -191,8 +192,10 @@ class AnalyzeImages extends LLMQuery {
             .string()
             .describe('A high-level overview of the general theme, mood, and context conveyed by the images (without specific names, titles, or exact figures from text within images)'),
     });
+    promptBuilder;
     constructor(config) {
         super(config);
+        this.promptBuilder = config.promptBuilder;
     }
     async execute() {
         if (!this.targetArticle.hasAttachedImage ||
@@ -206,7 +209,7 @@ class AnalyzeImages extends LLMQuery {
             model: this.model,
             maxRetries: this.options.llm.maxRetries,
             schema: this.schema,
-            system: this.systemPrompt,
+            instructions: this.systemPrompt,
             messages: [
                 {
                     role: 'user',
@@ -216,7 +219,17 @@ class AnalyzeImages extends LLMQuery {
         });
         return { result: output.imageContext, usage };
     }
+    get promptContext() {
+        return {
+            expertFields: this.expertFields,
+            outputLanguage: this.options.content.outputLanguage,
+            targetArticle: this.targetArticle,
+        };
+    }
     get systemPrompt() {
+        if (this.promptBuilder?.system) {
+            return this.promptBuilder.system(this.promptContext);
+        }
         return `# Image Analysis Expert System
 
 ## Identity & Expertise
@@ -282,11 +295,18 @@ You are a specialized image analysis expert in: ${this.expertFields.join(', ')}
     }
     get imageMessages() {
         return this.imageUrls.map((url) => ({
-            type: 'image',
-            image: url,
+            type: 'file',
+            mediaType: 'image',
+            data: url,
         }));
     }
     get textMessage() {
+        if (this.promptBuilder?.user) {
+            return {
+                type: 'text',
+                text: this.promptBuilder.user(this.promptContext),
+            };
+        }
         return {
             type: 'text',
             text: `## Analysis Task
@@ -324,9 +344,11 @@ class ClassifyTags extends LLMQuery {
         tag2: z.string(),
         tag3: z.string(),
     });
+    promptBuilder;
     existTags = [];
     constructor(config) {
         super(config);
+        this.promptBuilder = config.promptBuilder;
     }
     async execute({ existTags }) {
         this.existTags = existTags;
@@ -334,12 +356,23 @@ class ClassifyTags extends LLMQuery {
             model: this.model,
             maxRetries: this.options.llm.maxRetries,
             schema: this.schema,
-            system: this.systemPrompt,
+            instructions: this.systemPrompt,
             prompt: this.userPrompt,
         });
         return { result: output, usage };
     }
+    get promptContext() {
+        return {
+            expertFields: this.expertFields,
+            outputLanguage: this.options.content.outputLanguage,
+            targetArticle: this.targetArticle,
+            existTags: this.existTags,
+        };
+    }
     get systemPrompt() {
+        if (this.promptBuilder?.system) {
+            return this.promptBuilder.system(this.promptContext);
+        }
         return `You are an AI specializing in analyzing and categorizing articles for professionals in ${this.expertFields.join(', ')}.
 
 ## Core Responsibility
@@ -353,7 +386,7 @@ All classifications must be written in ${this.options.content.outputLanguage}.
 2. **New Tag Criteria**: Create new classifications only when:
    - Best existing match scores below 80% compatibility
    - New tag demonstrates versatility across 10+ similar articles
-3. **Naming Standards**: 
+3. **Naming Standards**:
    - Length: 3-15 characters
    - Style: Clear, intuitive ${this.options.content.outputLanguage} terms
    - Balance industry precision with general reader comprehension
@@ -367,6 +400,9 @@ Prioritize in order:
 - Long-term scalability and maintainability`;
     }
     get userPrompt() {
+        if (this.promptBuilder?.user) {
+            return this.promptBuilder.user(this.promptContext);
+        }
         return `**Task**: Classify this article with 3 optimal detailed tags.
 
 **Article Information**
@@ -404,17 +440,19 @@ class DetermineArticleImportance extends LLMQuery {
             .describe('Article importance score (1-10, 10 is most important)'),
     });
     dateService;
+    promptBuilder;
     constructor(config) {
         super(config);
         this.minimumImportanceScoreRules = config.minimumImportanceScoreRules ?? [];
         this.dateService = config.dateService;
+        this.promptBuilder = config.promptBuilder;
     }
     async execute() {
         const { output, usage } = await generateObjectByLLM({
             model: this.model,
             maxRetries: this.options.llm.maxRetries,
             schema: this.schema,
-            system: this.systemPrompt,
+            instructions: this.systemPrompt,
             prompt: this.userPrompt,
         });
         return { result: output.importanceScore, usage };
@@ -426,7 +464,18 @@ class DetermineArticleImportance extends LLMQuery {
     get hasHigherMinimumScore() {
         return this.minPoint > 1;
     }
+    get promptContext() {
+        return {
+            expertFields: this.expertFields,
+            targetArticle: this.targetArticle,
+            dateService: this.dateService,
+            minimumImportanceScoreRules: this.minimumImportanceScoreRules,
+        };
+    }
     get systemPrompt() {
+        if (this.promptBuilder?.system) {
+            return this.promptBuilder.system(this.promptContext);
+        }
         return `You are an expert in importance evaluation in the field of ${this.expertFields.join(', ')}.
 
 Role:
@@ -463,6 +512,9 @@ Important Notes:
 - Be sensitive to core keywords, events, policies considered important in the field.`;
     }
     get userPrompt() {
+        if (this.promptBuilder?.user) {
+            return this.promptBuilder.user(this.promptContext);
+        }
         return `Please rate the importance of this article from ${this.minPoint} to 10.
 
 **Newsletter Publication Date:** ${this.dateService.getPublicationISODateString()}${this.targetArticle.publishedDate
@@ -507,9 +559,11 @@ class PrivateChain extends BaseChain {
 
 class ArticleInsightsChain extends PrivateChain {
     dateService;
+    promptProvider;
     constructor(config) {
         super(config);
         this.dateService = config.dateService;
+        this.promptProvider = config.promptProvider;
     }
     /* istanbul ignore next - pipeline arrow functions are exercised via higher-level tests */
     get chain() {
@@ -605,7 +659,10 @@ class ArticleInsightsChain extends PrivateChain {
                     },
                 });
                 try {
-                    const classifyTags = new ClassifyTags(this.getLlmQueryConfig(this.provider.classifyTagOptions.model, article));
+                    const classifyTags = new ClassifyTags({
+                        ...this.getLlmQueryConfig(this.provider.classifyTagOptions.model, article),
+                        promptBuilder: this.promptProvider?.classifyTags,
+                    });
                     const { result: generatedTags } = await classifyTags.execute({
                         existTags,
                     });
@@ -680,7 +737,10 @@ class ArticleInsightsChain extends PrivateChain {
                     },
                 });
                 try {
-                    const analyzeImages = new AnalyzeImages(this.getLlmQueryConfig(this.provider.analyzeImagesOptions.model, article));
+                    const analyzeImages = new AnalyzeImages({
+                        ...this.getLlmQueryConfig(this.provider.analyzeImagesOptions.model, article),
+                        promptBuilder: this.promptProvider?.analyzeImages,
+                    });
                     const { result: imageContextByLlm } = await analyzeImages.execute();
                     if (imageContextByLlm) {
                         articlesWithImageContext.push({
@@ -779,6 +839,7 @@ class ArticleInsightsChain extends PrivateChain {
                         ...this.getLlmQueryConfig(this.provider.determineScoreOptions.model, article),
                         minimumImportanceScoreRules: this.provider.determineScoreOptions.minimumImportanceScoreRules,
                         dateService: this.dateService,
+                        promptBuilder: this.promptProvider?.determineImportance,
                     });
                     const { result: importanceScore } = await determineArticleImportance.execute();
                     const processedArticle = {
@@ -843,9 +904,11 @@ class ArticleInsightsChain extends PrivateChain {
 
 class AnalysisChain extends Chain {
     dateService;
+    promptProvider;
     constructor(config) {
         super(config);
         this.dateService = config.dateService;
+        this.promptProvider = config.promptProvider;
     }
     get chain() {
         return RunnablePassthrough.assign({
@@ -901,6 +964,7 @@ class AnalysisChain extends Chain {
                 options: this.options,
                 loggingExecutor: new LoggingExecutor(this.logger, this.taskId),
                 dateService: this.dateService,
+                promptProvider: this.promptProvider,
             });
             return await articleInsightsChain.generateInsights();
         });
@@ -934,6 +998,7 @@ let GenerateNewsletter$1 = class GenerateNewsletter extends BaseLLMQuery {
     dateService;
     subscribePageUrl;
     newsletterBrandName;
+    promptBuilder;
     schema = z.object({
         title: z.string().max(70).min(20).describe('Title of the newsletter email'),
         content: z.string().describe('Email content in markdown format'),
@@ -959,6 +1024,7 @@ let GenerateNewsletter$1 = class GenerateNewsletter extends BaseLLMQuery {
         this.dateService = config.dateService;
         this.subscribePageUrl = config.subscribePageUrl;
         this.newsletterBrandName = config.newsletterBrandName;
+        this.promptBuilder = config.promptBuilder;
     }
     async execute() {
         const { output, usage, finishReason } = await generateObjectByLLM({
@@ -971,7 +1037,7 @@ let GenerateNewsletter$1 = class GenerateNewsletter extends BaseLLMQuery {
             presencePenalty: this.presencePenalty,
             frequencyPenalty: this.frequencyPenalty,
             schema: this.schema,
-            system: this.systemPrompt,
+            instructions: this.systemPrompt,
             prompt: this.userPrompt,
         });
         if (finishReason === 'length') {
@@ -993,7 +1059,22 @@ let GenerateNewsletter$1 = class GenerateNewsletter extends BaseLLMQuery {
         }
         return { result: pick(output, ['title', 'content']), usage };
     }
+    get promptContext() {
+        return {
+            expertFields: this.expertFields,
+            outputLanguage: this.options.content.outputLanguage,
+            dateService: this.dateService,
+            targetArticles: this.targetArticles,
+            freeFormIntro: this.options.content.freeFormIntro,
+            titleContext: this.options.content.titleContext,
+            subscribePageUrl: this.subscribePageUrl,
+            newsletterBrandName: this.newsletterBrandName,
+        };
+    }
     get systemPrompt() {
+        if (this.promptBuilder?.system) {
+            return this.promptBuilder.system(this.promptContext);
+        }
         return `You are a newsletter production expert for "${this.newsletterBrandName}" who analyzes and delivers trends in the fields of ${this.expertFields.join(', ')}. Your goal is to provide in-depth analysis that helps industry professionals easily understand complex information and make informed decisions.
 
 Important rule for displaying date ranges: When displaying date ranges, you must use a hyphen (-) instead of a tilde (~). For example, use 'June 1-2, 2025' instead of 'June 1~2, 2025'. The tilde (~) can be rendered as strikethrough in markdown.
@@ -1125,6 +1206,9 @@ Output Format & Requirements:
    ${this.subscribePageUrl ? `-   Add \`${this.subscribePageUrl}\`(Subscribe to ${this.newsletterBrandName}) page access link button at appropriate attention-worthy spot for natural recommendation to others.` : ''}`;
     }
     get userPrompt() {
+        if (this.promptBuilder?.user) {
+            return this.promptBuilder.user(this.promptContext);
+        }
         return `Below is the complete list of newly collected ${this.expertFields.join(', ')} related news:
 
 ${this.targetArticles
@@ -1192,8 +1276,7 @@ function addUsage(a, b) {
     };
 }
 
-async function inlineCss(html) {
-    const { default: juice } = await import('juice');
+function inlineCss(html) {
     return juice(html);
 }
 class ContentGenerateChain extends Chain {
@@ -1201,9 +1284,11 @@ class ContentGenerateChain extends Chain {
     minimumArticleCountForIssue;
     priorityArticleScoreThreshold;
     htmlTemplate;
+    promptProvider;
     constructor(config) {
         super(config);
         this.dateService = config.dateService;
+        this.promptProvider = config.promptProvider;
         this.minimumArticleCountForIssue =
             config.provider.publicationCriteria?.minimumArticleCountForIssue ?? 5;
         this.priorityArticleScoreThreshold =
@@ -1286,6 +1371,7 @@ class ContentGenerateChain extends Chain {
                 subscribePageUrl: this.provider.subscribePageUrl,
                 newsletterBrandName: this.provider.newsletterBrandName,
                 dateService: this.dateService,
+                promptBuilder: this.promptProvider?.generateNewsletter,
             });
             const { result } = await generateNewsletter.execute();
             return result;
@@ -1325,7 +1411,7 @@ class ContentGenerateChain extends Chain {
             const { id } = await this.provider.saveNewsletter({
                 newsletter: {
                     ...coreContent,
-                    htmlBody: await inlineCss(html),
+                    htmlBody: inlineCss(html),
                     issueOrder: this.provider.issueOrder,
                     date: this.dateService.getPublicationISODateString(),
                 },
@@ -1775,6 +1861,7 @@ class GenerateNewsletter {
     contentGenerateProvider;
     logger;
     options;
+    promptProvider;
     previewNewsletterOptions;
     /** Independent internal field **/
     taskId = null;
@@ -1818,6 +1905,7 @@ class GenerateNewsletter {
                 ...config.options?.chain,
             },
         };
+        this.promptProvider = config.promptProvider;
         // Default logger (no-op)
         this.logger = config.options?.logger ?? {
             info: (_msg) => { },
@@ -1847,6 +1935,7 @@ class GenerateNewsletter {
                 options: this.options,
                 loggingExecutor,
                 dateService: this.dateService,
+                promptProvider: this.promptProvider?.analysis,
             });
             const contentGenerateChain = new ContentGenerateChain({
                 logger: this.logger,
@@ -1855,6 +1944,7 @@ class GenerateNewsletter {
                 options: this.options,
                 loggingExecutor,
                 dateService: this.dateService,
+                promptProvider: this.promptProvider?.contentGenerate,
             });
             const taskChain = RunnableSequence.from([
                 crawlingChain.chain,

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}