@tstdl/base 0.93.133 → 0.93.135

package/ai/prompts/prompt-builder.d.ts

@@ -1,21 +1,24 @@
 import type { Part } from 'genkit';
-import type { ObjectLiteral, OneOrMany } from '../../types/index.js';
+import type { ObjectLiteral } from '../../types/index.js';
 import { type Instructions } from './instructions-formatter.js';
-export type PromptInstructionItem = string | Instructions;
+export type PromptBuilderInstructions = Record<string, Instructions>;
+export type PromptBuilderContext = Record<string, PromptBuilderContextItem>;
+export type PromptBuilderContextItem = ObjectLiteral;
 export declare class PromptBuilder {
     #private;
     setSystemRole(role: string): this;
     setRole(role: string): this;
     setSystemTask(task: string): this;
     setTask(task: string): this;
+    addSystemMedia(content: Uint8Array, mimeType: string): this;
     addMedia(content: Uint8Array, mimeType: string): this;
     addSystemInstructions(instructions: Record<string, Instructions>): this;
     addInstructions(instructions: Record<string, Instructions>): this;
-    addSystemContext(title: string, context: string | OneOrMany<ObjectLiteral | Record<string, ObjectLiteral | null>>): this;
-    addSystemContext(context: Record<string, OneOrMany<ObjectLiteral | Record<string, ObjectLiteral | null>>>): this;
-    addContext(title: string, context: string | OneOrMany<ObjectLiteral | Record<string, ObjectLiteral | null>>): this;
-    addContext(context: Record<string, OneOrMany<ObjectLiteral | Record<string, ObjectLiteral | null>>>): this;
-    buildSystem(): Part[];
-    buildPrompt(): Part[];
+    addSystemContext(title: string, context: PromptBuilderContextItem): this;
+    addSystemContext(context: PromptBuilderContext): this;
+    addContext(title: string, context: PromptBuilderContextItem): this;
+    addContext(context: PromptBuilderContext): this;
+    buildSystemPrompt(): Part[];
+    buildUserPrompt(): Part[];
 }
 export declare function promptBuilder(): PromptBuilder;

package/ai/prompts/prompt-builder.js

@@ -12,6 +12,7 @@ export class PromptBuilder {
     #instructions = {};
     #systemContextParts = {};
     #contextParts = {};
+    #systemMedia = [];
     #media = [];
     setSystemRole(role) {
         this.#systemRole = role;
@@ -29,10 +30,12 @@ export class PromptBuilder {
         this.#task = task;
         return this;
     }
+    addSystemMedia(content, mimeType) {
+        addMedia(content, mimeType, this.#systemMedia);
+        return this;
+    }
     addMedia(content, mimeType) {
-        const base64Data = encodeBase64(content);
-        const dataUrl = `data:${mimeType};base64,${base64Data}`;
-        this.#media.push({ media: { url: dataUrl } });
+        addMedia(content, mimeType, this.#media);
         return this;
     }
     addSystemInstructions(instructions) {
@@ -59,51 +62,54 @@ export class PromptBuilder {
         this.#contextParts[titleOrContext] = contextOrNothing;
         return this;
     }
-    buildSystem() {
-        const instructions = {};
-        if (isDefined(this.#systemRole)) {
-            instructions['**Role**'] = this.#systemRole;
-        }
-        if (objectKeys(this.#systemContextParts).length > 0) {
-            const contextEntries = objectEntries(this.#systemContextParts).map(([key, contextPart]) => {
-                const string = isString(contextPart) ? contextPart : `\`\`\`toon\n${formatData(contextPart)}\n\`\`\``;
-                return [key, string];
-            });
-            instructions['**Context**'] = sections(fromEntries(contextEntries));
-        }
-        if (objectKeys(this.#systemInstructions).length > 0) {
-            instructions['**Instructions**'] = this.#systemInstructions;
-        }
-        if (isDefined(this.#systemTask)) {
-            instructions['**Task**'] = this.#systemTask;
-        }
-        return [{ text: formatInstructions(instructions) }];
+    buildSystemPrompt() {
+        return buildPrompt({
+            role: this.#systemRole,
+            context: this.#systemContextParts,
+            instructions: this.#systemInstructions,
+            task: this.#systemTask,
+            media: this.#systemMedia,
+        });
     }
-    buildPrompt() {
-        const instructions = {};
-        if (isDefined(this.#role)) {
-            instructions['**Role**'] = this.#role;
-        }
-        if (objectKeys(this.#contextParts).length > 0) {
-            const contextEntries = objectEntries(this.#contextParts).map(([key, contextPart]) => {
-                const string = isString(contextPart) ? contextPart : `\`\`\`toon\n${formatData(contextPart)}\n\`\`\``;
-                return [key, string];
-            });
-            instructions['**Context**'] = sections(fromEntries(contextEntries));
-        }
-        if (objectKeys(this.#instructions).length > 0) {
-            instructions['**Instructions**'] = this.#instructions;
-        }
-        if (isDefined(this.#task)) {
-            instructions['**Task**'] = this.#task;
-        }
-        const formatted = formatInstructions(instructions);
-        return [
-            ...this.#media,
-            { text: formatted },
-        ];
+    buildUserPrompt() {
+        return buildPrompt({
+            role: this.#role,
+            context: this.#contextParts,
+            instructions: this.#instructions,
+            task: this.#task,
+            media: this.#media,
+        });
     }
 }
 export function promptBuilder() {
     return new PromptBuilder();
 }
+function addMedia(content, mimeType, targetArray) {
+    const base64Data = encodeBase64(content);
+    const dataUrl = `data:${mimeType};base64,${base64Data}`;
+    targetArray.push({ media: { url: dataUrl } });
+}
+function buildPrompt(data) {
+    const instructions = {};
+    if (isDefined(data.role)) {
+        instructions['**Role**'] = data.role;
+    }
+    if (isDefined(data.context) && objectKeys(data.context).length > 0) {
+        const contextEntries = objectEntries(data.context).map(([key, contextPart]) => {
+            const string = isString(contextPart) ? contextPart : `\`\`\`toon\n${formatData(contextPart)}\n\`\`\``;
+            return [key, string];
+        });
+        instructions['**Context**'] = sections(fromEntries(contextEntries));
+    }
+    if (isDefined(data.instructions) && (objectKeys(data.instructions).length > 0)) {
+        instructions['**Instructions**'] = data.instructions;
+    }
+    if (isDefined(data.task)) {
+        instructions['**Task**'] = data.task;
+    }
+    const formattedInstructions = formatInstructions(instructions);
+    return [
+        ...(data.media ?? []),
+        { text: formattedInstructions },
+    ];
+}

package/document-management/server/services/document-validation.service.js

@@ -37,7 +37,7 @@ let DocumentValidationService = DocumentValidationService_1 = class DocumentVali
     #validationExecutionService = injectRepository(DocumentValidationExecution);
     #validationExecutionRelatedDocumentService = injectRepository(DocumentValidationExecutionRelatedDocument);
     #documentTypeValidationService = injectRepository(DocumentTypeValidation);
-    #taskQueue = inject((TaskQueue), { namespace: 'DocumentManagement:validation', visibilityTimeout: 5 * millisecondsPerMinute, maxTries: 3 });
+    #taskQueue = inject((TaskQueue), { namespace: 'DocumentManagement:Validation', visibilityTimeout: 5 * millisecondsPerMinute, maxTries: 3 });
     #executors = injectAll(DOCUMENT_VALIDATION_EXECUTORS);
     #logger = inject(Logger, DocumentValidationService_1.name);
     #executorMap = new Map(this.#executors.map((executor) => [executor.identifier, executor]));

package/document-management/server/services/document-workflow.service.js

@@ -37,7 +37,7 @@ let DocumentWorkflowService = DocumentWorkflowService_1 = class DocumentWorkflow
     #documentAssignmentTaskRepository = injectRepository(DocumentAssignmentTask);
     #documentAssignmentScopeRepository = injectRepository(DocumentAssignmentScope);
     #observationService = inject(DocumentManagementObservationService);
-    #taskQueue = inject((TaskQueue), { namespace: 'DocumentManagement:DocumentWorkflow', visibilityTimeout: 5 * 60 * 1000, maxTries: 3 });
+    #taskQueue = inject((TaskQueue), { namespace: 'DocumentManagement:Workflow', visibilityTimeout: 5 * 60 * 1000, maxTries: 3 });
     #logger = inject(Logger, DocumentWorkflowService_1.name);
     documentService = inject(forwardRef(() => DocumentService));
     repository = injectRepository(DocumentWorkflow);
@@ -107,7 +107,7 @@ let DocumentWorkflowService = DocumentWorkflowService_1 = class DocumentWorkflow
     async initiateWorkflow(tenantId, documentId, step, skipAi) {
         const workflow = await this.repository.insert({ tenantId, documentId, step, state: 'pending', failReason: null, completeTimestamp: null, completeUserId: null, skipAi });
         if (!skipAi) {
-            await this.#taskQueue.enqueue('workflow', { workflowId: workflow.id });
+            await this.#taskQueue.enqueue(step, { workflowId: workflow.id });
         }
         this.#observationService.documentChange(workflow.id, this.session);
         return workflow;

package/examples/ai/prompt-builder.js

@@ -79,8 +79,8 @@ async function main() {
     const dummyImage = new Uint8Array([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]);
     builder.addMedia(dummyImage, 'image/png');
     // 4. Build and Display
-    const systemMessage = builder.buildSystem();
-    const userMessage = builder.buildPrompt();
+    const systemMessage = builder.buildSystemPrompt();
+    const userMessage = builder.buildUserPrompt();
     console.log('--- SYSTEM MESSAGE ---');
     for (const part of systemMessage) {
         if (part.text) {

package/notification/server/services/notification-delivery.worker.d.ts

@@ -5,7 +5,7 @@ import { TaskProcessResult } from '../../../task-queue/task-queue.js';
 import { NotificationChannel } from '../../models/index.js';
 import type { ChannelProvider } from '../providers/channel-provider.js';
 export type NotificationTaskDefinitions = TaskDefinitionMap<{
-    'notification/deliver': TaskDefinition<{
+    deliver: TaskDefinition<{
         notificationId: string;
     }>;
 }>;

package/notification/server/services/notification.service.js

@@ -44,7 +44,7 @@ let NotificationService = NotificationService_1 = class NotificationService exte
                 currentStep: 0,
             };
             const insertedNotification = await this.#notificationLogRepository.withTransaction(tx).insert(notificationToInsert);
-            await this.#taskQueue.withTransaction(tx).enqueue('notification/deliver', { notificationId: insertedNotification.id });
+            await this.#taskQueue.withTransaction(tx).enqueue('deliver', { notificationId: insertedNotification.id });
         });
     }
     async listInApp(tenantId, userId, options = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.133",
+  "version": "0.93.135",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/task-queue/task-context.d.ts

@@ -3,7 +3,7 @@ import type { Logger } from '../logger/index.js';
 import type { Transaction } from '../orm/server/index.js';
 import { TaskQueue, type EnqueueManyItem, type EnqueueOptions } from './task-queue.js';
 import type { TaskData, TaskDefinitionMap, TaskOfType, TaskResult, TaskState, TaskTypes } from './types.js';
-export declare class TaskContext<Definitions extends TaskDefinitionMap, Type extends TaskTypes<Definitions>> {
+export declare class TaskContext<Definitions extends TaskDefinitionMap, Type extends TaskTypes<Definitions> = TaskTypes<Definitions>> {
     #private;
     constructor(queue: TaskQueue<Definitions>, task: TaskOfType<Definitions, Type>, signal: CancellationToken, logger: Logger);
     get id(): string;

package/task-queue/task-queue.js

@@ -104,7 +104,7 @@ export class TaskQueue extends Transactional {
     async processWorker(cancellationSignal, handler, options) {
         for await (const task of this.getConsumer(cancellationSignal, options)) {
             const taskToken = cancellationSignal.createChild();
-            const context = new TaskContext(this, task, taskToken, this.logger);
+            const context = new TaskContext(this, task, taskToken, this.logger.with({ type: task.type }));
             let isTaskActive = true;
             context.logger.verbose(`Processing task`);
             void (async () => {

package/test5.js

@@ -6,9 +6,9 @@ import { PrettyPrintLogFormatter } from './logger/index.js';
 import { provideConsoleLogTransport } from './logger/transports/console.js';
 async function main(_cancellationSignal) {
     const x = promptBuilder();
-    console.log(x.buildSystem()[0].text);
+    console.log(x.buildSystemPrompt()[0].text);
     console.log('\n\n---\n\n');
-    console.log(x.buildPrompt()[0].text);
+    console.log(x.buildUserPrompt()[0].text);
 }
 Application.run('Test', [
     provideConsoleLogTransport(PrettyPrintLogFormatter),