@tstdl/base 0.92.108 → 0.92.110

package/ai/ai.service.d.ts

@@ -2,7 +2,7 @@ import type { Resolvable, resolveArgumentType } from '../injector/interfaces.js'
 import { type OneOrMany, type SchemaTestable } from '../schema/index.js';
 import type { Enumeration as EnumerationType, EnumerationValue } from '../types.js';
 import { AiSession } from './ai-session.js';
-import { type AiModel, type Content, type ContentPart, type FileContentPart, type FileInput, type GenerationOptions, type GenerationRequest, type GenerationResult, type SchemaFunctionDeclarations, type SchemaFunctionDeclarationsResult } from './types.js';
+import { type AiModel, type Content, type ContentPart, type FileContentPart, type FileInput, type FunctionResultContentPart, type GenerationOptions, type GenerationRequest, type GenerationResult, type SchemaFunctionDeclarations, type SchemaFunctionDeclarationsResult } from './types.js';
 export type SpecializedGenerationResult<T> = {
     result: T;
     raw: GenerationResult;
@@ -32,7 +32,7 @@ export type AnalyzeContentResult<T extends EnumerationType> = {
     documentTypes: ClassificationResult<T>[];
     tags: string[];
 };
-export type CallFunctionsOptions<T extends SchemaFunctionDeclarations> = Pick<GenerationRequest, 'contents' | 'model' | 'systemInstruction'> & GenerationOptions & {
+export type CallFunctionsOptions<T extends SchemaFunctionDeclarations> = Pick<GenerationRequest, 'contents' | 'model' | 'systemInstruction' | 'functionCallingMode'> & GenerationOptions & {
     functions: T;
 };
 export declare class AiService implements Resolvable<AiServiceArgument> {
@@ -52,7 +52,9 @@ export declare class AiService implements Resolvable<AiServiceArgument> {
         maximumNumberOfTags?: number;
     }): Promise<SpecializedGenerationResult<AnalyzeContentResult<T>>>;
     getAnalyzeContentConents(parts: OneOrMany<ContentPart>): Content[];
-    callFunctions<const T extends SchemaFunctionDeclarations>(options: CallFunctionsOptions<T>): Promise<SpecializedGenerationResult<SchemaFunctionDeclarationsResult<T>[]>>;
+    callFunctions<const T extends SchemaFunctionDeclarations>(options: CallFunctionsOptions<T>): Promise<SpecializedGenerationResult<SchemaFunctionDeclarationsResult<T>[]> & {
+        getFunctionResultContentParts: () => FunctionResultContentPart[];
+    }>;
     callFunctionsStream<const T extends SchemaFunctionDeclarations>(options: CallFunctionsOptions<T>): SpecializedGenerationResultGenerator<SchemaFunctionDeclarationsResult<T>>;
     generate<S>(request: GenerationRequest<S>): Promise<GenerationResult<S>>;
     generateStream<S>(request: GenerationRequest<S>): AsyncGenerator<GenerationResult<S>>;

package/ai/ai.service.js

@@ -41,6 +41,7 @@ const functionCallingModeMap = {
     force: GoogleFunctionCallingMode.ANY,
     none: GoogleFunctionCallingMode.NONE
 };
+let generationCounter = 0;
 let AiService = AiService_1 = class AiService {
     #options = injectArgument(this, { optional: true }) ?? inject(AiServiceOptions);
     #fileService = inject(AiFileService, this.#options);
@@ -170,7 +171,7 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
             },
             systemInstruction: options.systemInstruction,
             functions: options.functions,
-            functionCallingMode: 'force',
+            functionCallingMode: options.functionCallingMode ?? 'force',
             contents: options.contents
         });
         const result = [];
@@ -179,11 +180,17 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
             const parametersSchema = await resolveValueOrAsyncProvider(fn.parameters);
             const parameters = isDefined(parametersSchema) ? parametersSchema.parse(call.parameters) : call.parameters;
             const handlerResult = isSchemaFunctionDeclarationWithHandler(fn) ? await fn.handler(parameters) : undefined;
-            result.push({ functionName: call.name, parameters: parameters, handlerResult: handlerResult });
+            result.push({
+                functionName: call.name,
+                parameters: parameters,
+                handlerResult: handlerResult,
+                getFunctionResultContentPart: () => ({ functionResult: { name: call.name, value: handlerResult } })
+            });
         }
         return {
             result,
-            raw: generation
+            raw: generation,
+            getFunctionResultContentParts: () => result.map((result) => result.getFunctionResultContentPart())
         };
     }
     callFunctionsStream(options) {
@@ -200,7 +207,7 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
         return mergeGenerationStreamItems(items, request.generationSchema);
     }
     async *generateStream(request) {
-        this.#logger.verbose('Generating...');
+        const generationNumber = ++generationCounter;
         const googleFunctionDeclarations = isDefined(request.functions) ? await this.convertFunctions(request.functions) : undefined;
         const generationConfig = {
             maxOutputTokens: request.generationOptions?.maxOutputTokens,
@@ -223,6 +230,7 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
             let generation;
             for (let i = 0;; i++) {
                 try {
+                    this.#logger.verbose(`[C:${generationNumber}] [I:${iterations + 1}] Generating...`);
                     generation = await this.getModel(model).generateContentStream({
                         generationConfig: {
                             ...generationConfig,
@@ -308,7 +316,7 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
             },
             systemInstruction: options.systemInstruction,
             functions: options.functions,
-            functionCallingMode: 'force',
+            functionCallingMode: options.functionCallingMode ?? 'force',
             contents: options.contents
         });
         const items = [];
@@ -319,7 +327,12 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
                 const parametersSchema = await resolveValueOrAsyncProvider(fn.parameters);
                 const parameters = isDefined(parametersSchema) ? parametersSchema.parse(call.parameters) : call.parameters;
                 const handlerResult = isSchemaFunctionDeclarationWithHandler(fn) ? await fn.handler(parameters) : undefined;
-                yield { functionName: call.name, parameters: parameters, handlerResult: handlerResult };
+                yield {
+                    functionName: call.name,
+                    parameters: parameters,
+                    handlerResult: handlerResult,
+                    getFunctionResultContentPart: () => ({ functionResult: { name: call.name, value: handlerResult } })
+                };
             }
         }
         itemsPromise.resolve(items);

package/ai/types.d.ts

@@ -22,6 +22,7 @@ export type SchemaFunctionDeclarationsResult<T extends SchemaFunctionDeclaration
         functionName: P;
         parameters: SchemaOutput<NonNullable<ResolvedValueOrProvider<T[P]['parameters']>>>;
         handlerResult: SchemaFunctionDeclarationHandlerResult<T[P]>;
+        getFunctionResultContentPart: () => FunctionResultContentPart;
     };
 }[keyof T];
 export type ContentRole = 'user' | 'model';

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

@@ -132,7 +132,7 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
         return this.collectionChangeMessageBus.allMessages$.pipe(filter((message) => isUndefined(message) || collectionIdsArray.some((id) => message.includes(id))), debounceTime(250), map(() => undefined));
     }
     processQueues(cancellationSignal) {
-        this.extractionQueue.process({ concurrency: 1, cancellationSignal }, async (job) => {
+        this.extractionQueue.process({ concurrency: 5, cancellationSignal }, async (job) => {
             const [entry] = objectEntries(job.data);
             this.logger.verbose(`Processing extraction job for ${entry?.[0]} ${entry?.[1]}`);
             await match(job.data)
@@ -141,7 +141,7 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
                 .with({ requestAssignmentTaskId: P.string.select() }, async (requestAssignmentTaskId) => this.enrichDocumentRequestAssignmentTask(requestAssignmentTaskId))
                 .exhaustive();
         }, this.logger);
-        this.assignmentQueue.process({ concurrency: 1, cancellationSignal }, async (job) => {
+        this.assignmentQueue.process({ concurrency: 5, cancellationSignal }, async (job) => {
             this.logger.verbose(`Processing assignment job "${job.data.requestAssignmentTaskId}"`);
             await this.assignDocumentRequest(job.data.requestAssignmentTaskId);
         }, this.logger);

package/package.json

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

package/queue/postgres/queue.js

@@ -101,16 +101,24 @@ let PostgresQueue = class PostgresQueue extends Queue {
         return jobs[0];
     }
     async dequeueMany(count) {
-        const rows = await this.#repository.session
-            .update(job)
-            .set(this.#dequeueUpdate)
-            .where(inArray(job.id, this.#repository.session
+        /*
+         * Materialization required for LIMIT clause
+         * https://stackoverflow.com/questions/73966670/select-for-update-subquery-not-respecting-limit-clause-under-load
+         * https://dba.stackexchange.com/questions/69471/postgres-update-limit-1
+         */
+        const selection = this.#repository.session.$with('selection').as((qb) => qb
             .select({ id: job.id })
             .from(job)
-            .where(this.#dequeueQuery)
+            .where(and(this.#dequeueQuery, sql `pg_sleep(0) IS NOT NULL` // workaround to force materialization until drizzle implements https://github.com/drizzle-team/drizzle-orm/issues/2318
+        ))
             .orderBy(asc(job.priority), asc(job.enqueueTimestamp), asc(job.lastDequeueTimestamp), asc(job.tries))
             .limit(count)
-            .for('update', { skipLocked: true })))
+            .for('update', { skipLocked: true }));
+        const rows = await this.#repository.session
+            .with(selection)
+            .update(job)
+            .set(this.#dequeueUpdate)
+            .where(inArray(job.id, selection))
             .returning();
         return this.#repository.mapManyToEntity(rows);
     }