@tstdl/base 0.93.125 → 0.93.127

package/task-queue/task-queue.js

@@ -1,5 +1,5 @@
 import { defineEnum } from '../enumeration/enumeration.js';
-import { inject, injectArgument } from '../injector/index.js';
+import { inject, injectArgument, Injector } from '../injector/index.js';
 import { Logger } from '../logger/logger.js';
 import { Transactional } from '../orm/server/transactional.js';
 import { currentTimestamp } from '../utils/date-time.js';
@@ -78,6 +78,7 @@ export const defaultQueueConfig = {
     idempotencyWindow: millisecondsPerMinute * 60,
 };
 export class TaskQueue extends Transactional {
+    injector = inject(Injector);
     config = this.transactionalContextData ?? (() => { const arg = injectArgument(this); return isString(arg) ? { namespace: arg } : arg; })();
     logger = inject(Logger, TaskQueue.name).with({ namespace: this.config.namespace });
     batch() {
@@ -87,9 +88,12 @@ export class TaskQueue extends Transactional {
      * Starts processing tasks with the provided worker function in the background until the cancellation signal is triggered.
      */
     process({ concurrency = 1, cancellationSignal, types, forceDequeue }, handler) {
+        const promises = [];
         for (let i = 0; i < concurrency; i++) {
-            void this.processWorker(cancellationSignal, handler, { types, forceDequeue });
+            const processPromise = this.processWorker(cancellationSignal, handler, { types, forceDequeue });
+            promises.push(processPromise);
         }
+        this.injector.addDisposeHandler(async () => await Promise.all(promises));
     }
     getTransactionalContextData() {
         return this.config;

package/task-queue/tests/complex.test.js

@@ -1,6 +1,6 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
 import { DependencyJoinMode, TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
-import { setupIntegrationTest } from '../../unit-test/index.js';
+import { setupIntegrationTest } from '../../testing/index.js';
 import { currentTimestamp } from '../../utils/date-time.js';
 import { timeout } from '../../utils/timing.js';
 describe('Complex Queue Scenarios', () => {

package/task-queue/tests/dependencies.test.js

@@ -1,7 +1,7 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
 import { CancellationToken } from '../../cancellation/index.js';
 import { DependencyJoinMode, TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
-import { setupIntegrationTest } from '../../unit-test/index.js';
+import { setupIntegrationTest } from '../../testing/index.js';
 import { timeout } from '../../utils/timing.js';
 describe('Queue Dependencies & Tree Tests', () => {
     let injector;
@@ -147,9 +147,9 @@ describe('Queue Dependencies & Tree Tests', () => {
             const token = new CancellationToken();
             const consumer = queue.getConsumer(token);
             const t1 = (await consumer.next()).value;
-            expect(t1.data.val).toBe(1);
+            expect(t1.data['val']).toBe(1);
             const t2 = (await consumer.next()).value;
-            expect(t2.data.val).toBe(2);
+            expect(t2.data['val']).toBe(2);
             token.set(); // Stop consumer
             const t3 = await consumer.next();
             expect(t3.done).toBe(true);

package/task-queue/tests/extensive-dependencies.test.js

@@ -1,6 +1,6 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
 import { DependencyJoinMode, TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
-import { setupIntegrationTest } from '../../unit-test/index.js';
+import { setupIntegrationTest } from '../../testing/index.js';
 import { timeout } from '../../utils/timing.js';
 describe('Extensive Task Queue Dependency Tests', () => {
     let injector;

package/task-queue/tests/queue.test.js

@@ -1,6 +1,6 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
 import { TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
-import { setupIntegrationTest } from '../../unit-test/index.js';
+import { setupIntegrationTest } from '../../testing/index.js';
 import { currentTimestamp } from '../../utils/date-time.js';
 import { timeout } from '../../utils/timing.js';
 describe('Queue Integration Tests', () => {

package/task-queue/tests/worker.test.js

@@ -1,11 +1,12 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
 import { CancellationToken } from '../../cancellation/index.js';
 import { TaskProcessResult, TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
-import { setupIntegrationTest } from '../../unit-test/index.js';
+import { setupIntegrationTest } from '../../testing/index.js';
 import { timeout } from '../../utils/timing.js';
 describe('Worker & Base Class Tests', () => {
     let injector;
     let queue;
+    let token;
     beforeAll(async () => {
         ({ injector } = await setupIntegrationTest({ modules: { taskQueue: true } }));
     });
@@ -15,8 +16,10 @@ describe('Worker & Base Class Tests', () => {
         queue = queueProvider.get(queueName, {
             visibilityTimeout: 500, // Short visibility for testing lease loss
         });
+        token = new CancellationToken();
     });
     afterEach(async () => {
+        token.set();
         await queue.clear();
         const queueProvider = injector.resolve(TaskQueueProvider);
         await queueProvider.get('other-queue').clear();
@@ -28,7 +31,6 @@ describe('Worker & Base Class Tests', () => {
         const t1 = await queue.enqueue('work', { val: 1 });
         const t2 = await queue.enqueue('work', { val: 2 });
         const processed = [];
-        const token = new CancellationToken();
         queue.process({ cancellationSignal: token }, async (context) => {
             processed.push(context.data['val']);
             return TaskProcessResult.Complete();
@@ -50,7 +52,6 @@ describe('Worker & Base Class Tests', () => {
     });
     it('should handle errors in worker gracefully', async () => {
         const task = await queue.enqueue('fail', {});
-        const token = new CancellationToken();
         queue.process({ cancellationSignal: token }, async () => {
             throw new Error('worker error');
         });
@@ -63,7 +64,6 @@ describe('Worker & Base Class Tests', () => {
     });
     it('should extend lease (heartbeat) during long processing', async () => {
         const task = await queue.enqueue('long', {});
-        const token = new CancellationToken();
         let executed = false;
         queue.process({ cancellationSignal: token }, async (_context) => {
             // Simulate long work > visibilityTimeout (500ms)
@@ -80,7 +80,6 @@ describe('Worker & Base Class Tests', () => {
     it('should handle TaskResult actions (Fail, Reschedule)', async () => {
         const tFail = await queue.enqueue('fail-action', {});
         const tResched = await queue.enqueue('resched-action', {});
-        const token = new CancellationToken();
         const processed = new Set();
         queue.process({ cancellationSignal: token }, async (context) => {
             processed.add(context.id);
@@ -107,7 +106,6 @@ describe('Worker & Base Class Tests', () => {
     });
     it('should exercise TaskContext methods', async () => {
         const task = await queue.enqueue('context-test', { val: 1 });
-        const token = new CancellationToken();
         let executed = false;
         queue.process({ cancellationSignal: token, types: ['context-test'] }, async (context) => {
             expect(context.id).toBe(task.id);
@@ -149,7 +147,6 @@ describe('Worker & Base Class Tests', () => {
         });
         await testQueue.enqueue('work', {});
         testQueue.notify();
-        const token = new CancellationToken();
         const finalAttemptValues = [];
         testQueue.process({ cancellationSignal: token }, async (context) => {
             finalAttemptValues.push(context.isFinalAttempt);

package/test5.js

@@ -1,17 +1,61 @@
 import './polyfills.js';
-import { writeFile } from 'node:fs/promises';
+import { buildPrompts, orderedList } from './ai/index.js';
+import { fewShotPrompt } from './ai/prompts/steering.js';
 import { Application } from './application/application.js';
 import { provideModule, provideSignalHandler } from './application/index.js';
 import { PrettyPrintLogFormatter } from './logger/index.js';
 import { provideConsoleLogTransport } from './logger/transports/console.js';
-import { renderTypst } from './typst/render.js';
-const template = `
-I got an ice cream for
-\\$1.50! \\u{1f600}
-`;
 async function main(_cancellationSignal) {
-    const pdfBytes = await renderTypst(template, { format: 'docx' });
-    await writeFile('/tmp/output.docx', pdfBytes);
+    const prompt = buildPrompts({
+        baseSystemInstructions: { Role: 'You are a helpful assistant.' },
+        baseUserInstructions: 'Please process the following data.',
+        additionalSystemInstructions: 'Make sure to follow the user instructions carefully.',
+        additionalUserInstructions: [
+            'The data is in JSON format.',
+            fewShotPrompt([
+                {
+                    input: { a: 1, b: 2 },
+                    output: 3,
+                    reason: 'This is a positive example showing that the function should add the two numbers.',
+                },
+                {
+                    input: { a: 1, b: 2 },
+                    output: 4,
+                    isNegative: true,
+                    reason: 'This is a negative example showing that the function should NOT return 4 for these inputs.',
+                },
+            ]),
+            {
+                Foo: {
+                    Bar: 'This is a nested instruction example.',
+                    Baz: {
+                        Qux: 'Make sure to handle nested instructions properly.',
+                        Bux: orderedList('This is an ordered list of instructions', [
+                            'First instruction',
+                            'Second instruction',
+                            'Third instruction',
+                        ]),
+                    },
+                },
+            },
+        ],
+        data: {
+            context: {
+                task: 'Our favorite hikes together',
+                location: 'Boulder',
+                season: 'spring_2025',
+            },
+            friends: ['ana', 'luis', 'sam'],
+            hikes: [
+                { id: 1, name: 'Blue Lake Trail', distanceKm: 7.5, elevationGain: 320, companion: 'ana', wasSunny: true },
+                { id: 2, name: 'Ridge Overlook', distanceKm: 9.2, elevationGain: 540, companion: 'luis', wasSunny: false },
+                { id: 3, name: 'Wildflower Loop', distanceKm: 5.1, elevationGain: 180, companion: 'sam', wasSunny: true },
+            ],
+        },
+    });
+    console.log(prompt.systemPrompt[0].text);
+    console.log();
+    console.log(prompt.userPrompt[0].text);
 }
 Application.run('Test', [
     provideConsoleLogTransport(PrettyPrintLogFormatter),

package/{unit-test → testing}/integration-setup.d.ts

@@ -19,6 +19,7 @@ export type IntegrationTestOptions = {
         audit?: boolean;
         authentication?: boolean;
         circuitBreaker?: boolean;
+        documentManagement?: boolean;
         keyValueStore?: boolean;
         lock?: boolean;
         messageBus?: boolean;

package/{unit-test → testing}/integration-setup.js

@@ -5,6 +5,7 @@ import { AuthenticationApiClient } from '../authentication/client/api.client.js'
 import { configureAuthenticationClient } from '../authentication/client/index.js';
 import { AuthenticationApiController, configureAuthenticationServer, migrateAuthenticationSchema } from '../authentication/server/index.js';
 import { configurePostgresCircuitBreaker, migratePostgresCircuitBreaker } from '../circuit-breaker/postgres/module.js';
+import { configureDocumentManagement, migrateDocumentManagementSchema } from '../document-management/server/index.js';
 import { configureUndiciHttpClientAdapter } from '../http/client/adapters/undici.adapter.js';
 import { configureHttpClient } from '../http/client/index.js';
 import { HttpServer } from '../http/server/index.js';
@@ -107,6 +108,18 @@ export async function setupIntegrationTest(options = {}) {
             configureNotification({ injector });
             await runInInjectionContext(injector, migrateNotificationSchema);
         }
+        if (options.modules?.documentManagement) {
+            configureDocumentManagement({
+                ancillaryService: undefined, // Should be overridden by test if needed
+                authorizationService: undefined, // Should be overridden by test if needed
+                fileObjectStorageModule: 'docs',
+                fileUploadObjectStorageModule: 'uploads',
+                filePreviewObjectStorageModule: 'previews',
+                skipAi: true,
+                injector,
+            });
+            await runInInjectionContext(injector, migrateDocumentManagementSchema);
+        }
         if (options.modules?.objectStorage) {
             configureS3ObjectStorage({
                 endpoint: configParser.string('S3_ENDPOINT', 'http://127.0.0.1:9000'),

package/utils/base64.d.ts

@@ -1,4 +1,11 @@
 import type { BinaryData } from '../types/index.js';
+/**
+ * Converts data to a base64 data URL.
+ * @param mimeType The MIME type of the data.
+ * @param data The data as Uint8Array.
+ * @returns A base64 data URL.
+ */
+export declare function encodeDataUrl(mimeType: string, data: Uint8Array): string;
 export declare function encodeBase64(array: BinaryData, bytesOffset?: number, bytesLength?: number): string;
 export declare function decodeBase64(base64: string): Uint8Array<ArrayBuffer>;
 export declare function encodeBase64Url(array: BinaryData, bytesOffset?: number, length?: number): string;

package/utils/base64.js

@@ -1,7 +1,16 @@
-/* eslint-disable @typescript-eslint/no-magic-numbers, no-bitwise */
 import { supportsBuffer } from '../supports.js';
 import { toUint8Array } from './binary.js';
 import { isArrayBufferLike, isDefined } from './type-guards.js';
+/**
+ * Converts data to a base64 data URL.
+ * @param mimeType The MIME type of the data.
+ * @param data The data as Uint8Array.
+ * @returns A base64 data URL.
+ */
+export function encodeDataUrl(mimeType, data) {
+    const base64 = encodeBase64(data);
+    return `data:${mimeType};base64,${base64}`;
+}
 export function encodeBase64(array, bytesOffset, bytesLength) {
     let arrayBuffer;
     let offset;

package/utils/noop.d.ts

@@ -1,2 +1,8 @@
+/**
+ * A no-operation function that does nothing. Useful as a default placeholder for optional callbacks or functions.
+ */
 export declare function noop(): void;
-export declare function noopPass<T>(value: T): T;
+/**
+ * A passthrough function that returns the provided value. Useful as a default for optional transformation functions.
+ */
+export declare function passthrough<T>(value: T): T;

package/utils/noop.js

@@ -1,6 +1,12 @@
+/**
+ * A no-operation function that does nothing. Useful as a default placeholder for optional callbacks or functions.
+ */
 export function noop() {
     // noop
 }
-export function noopPass(value) {
+/**
+ * A passthrough function that returns the provided value. Useful as a default for optional transformation functions.
+ */
+export function passthrough(value) {
     return value;
 }

package/ai/ai-file.service.d.ts

@@ -1,57 +0,0 @@
-import type { Resolvable, resolveArgumentType } from '../injector/interfaces.js';
-import { AiModuleOptions } from './module.js';
-import { type FileContentPart, type FileInput } from './types.js';
-/**
- * Options for {@link AiFileService}.
- */
-export type AiFileServiceOptions = Pick<AiModuleOptions, 'apiKey' | 'keyFile' | 'vertex'>;
-export type AiFileServiceArgument = AiFileServiceOptions;
-type File = {
-    id: string;
-    name: string;
-    uri: string;
-    mimeType: string;
-};
-/**
- * Manages file uploads and state for use with AI models.
- * Handles both Google Generative AI File API and Google Cloud Storage for Vertex AI.
- */
-export declare class AiFileService implements Resolvable<AiFileServiceArgument> {
-    #private;
-    readonly [resolveArgumentType]: AiFileServiceArgument;
-    /**
-     * Uploads and processes a single file, making it available for AI model consumption.
-     * @param fileInput The file to process.
-     * @returns A promise that resolves to a {@link FileContentPart} for use in AI requests.
-     */
-    processFile(fileInput: FileInput): Promise<FileContentPart>;
-    /**
-     * Uploads and processes multiple files in parallel, making them available for AI model consumption.
-     * @param fileInputs The files to process.
-     * @returns A promise that resolves to an array of {@link FileContentPart} for use in AI requests.
-     */
-    processFiles(fileInputs: FileInput[]): Promise<FileContentPart[]>;
-    /**
-     * Retrieves a file by its internal ID.
-     * The file must have been processed by this service instance before.
-     * @param id The internal ID of the file.
-     * @returns The file, or `undefined` if not found.
-     */
-    getFileById(id: string): File | undefined;
-    /**
-     * Retrieves a file by its URI (e.g., GCS URI).
-     * The file must have been processed by this service instance before.
-     * @param uri The URI of the file.
-     * @returns The file, or `undefined` if not found.
-     */
-    getFileByUri(uri: string): File | undefined;
-    private getFile;
-    private getFiles;
-    private uploadFile;
-    private uploadFileVertex;
-    private uploadFileGenAi;
-    private getBucket;
-    private waitForFileActive;
-    private waitForFilesActive;
-}
-export {};

package/ai/ai-file.service.js

@@ -1,233 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { createReadStream } from 'node:fs';
-import { stat } from 'node:fs/promises';
-import { Readable } from 'node:stream';
-import { ReadableStream as NodeReadableStream } from 'node:stream/web';
-import { Storage } from '@google-cloud/storage';
-import { FileState, GoogleGenAI } from '@google/genai';
-import { CancellationSignal } from '../cancellation/token.js';
-import { AsyncEnumerable } from '../enumerable/async-enumerable.js';
-import { DetailsError } from '../errors/details.error.js';
-import { Singleton } from '../injector/decorators.js';
-import { inject, injectArgument } from '../injector/inject.js';
-import { Logger } from '../logger/logger.js';
-import { createArray } from '../utils/array/array.js';
-import { backoffGenerator } from '../utils/backoff.js';
-import { formatBytes } from '../utils/format.js';
-import { readBinaryStream } from '../utils/stream/stream-reader.js';
-import { assertDefinedPass, isBlob, isDefined, isUndefined } from '../utils/type-guards.js';
-import { AiModuleOptions } from './module.js';
-import { isPathFileInput } from './types.js';
-/**
- * Manages file uploads and state for use with AI models.
- * Handles both Google Generative AI File API and Google Cloud Storage for Vertex AI.
- */
-let AiFileService = class AiFileService {
-    #options = injectArgument(this, { optional: true }) ?? inject(AiModuleOptions);
-    #genAI = new GoogleGenAI({
-        vertexai: isDefined(this.#options.vertex?.project),
-        project: this.#options.vertex?.project,
-        location: this.#options.vertex?.location,
-        googleAuthOptions: isDefined(this.#options.vertex?.project) ? { apiKey: this.#options.apiKey, keyFile: this.#options.keyFile } : undefined,
-        apiKey: isUndefined(this.#options.vertex?.project) ? assertDefinedPass(this.#options.apiKey, 'Api key not defined') : undefined,
-    });
-    #storage = isDefined(this.#options.vertex) ? new Storage({ keyFile: assertDefinedPass(this.#options.keyFile, 'Key file not defined'), projectId: this.#options.vertex.project }) : undefined;
-    #fileMap = new Map();
-    #fileUriMap = new Map();
-    #logger = inject(Logger, 'AiFileService');
-    #cancellationSignal = inject(CancellationSignal);
-    #backoffOptions = {
-        cancellationSignal: this.#cancellationSignal,
-        strategy: 'linear',
-        initialDelay: 1000,
-        increase: 500,
-        jitter: 0.2,
-        maximumDelay: 10000,
-    };
-    #bucket;
-    /**
-     * Uploads and processes a single file, making it available for AI model consumption.
-     * @param fileInput The file to process.
-     * @returns A promise that resolves to a {@link FileContentPart} for use in AI requests.
-     */
-    async processFile(fileInput) {
-        const file = await this.getFile(fileInput);
-        this.#fileMap.set(file.id, file);
-        this.#fileUriMap.set(file.uri, file);
-        return { file: file.id };
-    }
-    /**
-     * Uploads and processes multiple files in parallel, making them available for AI model consumption.
-     * @param fileInputs The files to process.
-     * @returns A promise that resolves to an array of {@link FileContentPart} for use in AI requests.
-     */
-    async processFiles(fileInputs) {
-        const files = await this.getFiles(fileInputs);
-        return files.map((file) => {
-            this.#fileMap.set(file.id, file);
-            this.#fileUriMap.set(file.uri, file);
-            return { file: file.id };
-        });
-    }
-    /**
-     * Retrieves a file by its internal ID.
-     * The file must have been processed by this service instance before.
-     * @param id The internal ID of the file.
-     * @returns The file, or `undefined` if not found.
-     */
-    getFileById(id) {
-        return this.#fileMap.get(id);
-    }
-    /**
-     * Retrieves a file by its URI (e.g., GCS URI).
-     * The file must have been processed by this service instance before.
-     * @param uri The URI of the file.
-     * @returns The file, or `undefined` if not found.
-     */
-    getFileByUri(uri) {
-        return this.#fileUriMap.get(uri);
-    }
-    async getFile(fileInput) {
-        const id = crypto.randomUUID();
-        const file = await this.uploadFile(fileInput, id);
-        this.#logger.verbose(`Processing file "${id}"...`);
-        await this.waitForFileActive(file);
-        return file;
-    }
-    async getFiles(fileInputs) {
-        const ids = createArray(fileInputs.length, () => crypto.randomUUID());
-        const files = await AsyncEnumerable.from(fileInputs).parallelMap(5, true, async (file, index) => await this.uploadFile(file, ids[index])).toArray();
-        this.#logger.verbose(`Processing ${fileInputs.length} files...`);
-        await this.waitForFilesActive(files);
-        return files;
-    }
-    async uploadFile(fileInput, id) {
-        if (isDefined(this.#storage)) {
-            return await this.uploadFileVertex(fileInput, id);
-        }
-        return await this.uploadFileGenAi(fileInput, id);
-    }
-    async uploadFileVertex(fileInput, id) {
-        const bucket = await this.getBucket();
-        const file = bucket.file(id);
-        let stream;
-        let contentType;
-        let size;
-        if (isBlob(fileInput)) {
-            stream = Readable.fromWeb(fileInput.stream());
-            contentType = fileInput.type;
-            size = fileInput.size;
-        }
-        else if (isPathFileInput(fileInput)) {
-            const stats = await stat(fileInput.path);
-            stream = createReadStream(fileInput.path);
-            contentType = fileInput.mimeType;
-            size = stats.size;
-        }
-        else {
-            stream = Readable.fromWeb(fileInput.stream);
-            contentType = fileInput.mimeType;
-            size = fileInput.size;
-        }
-        this.#logger.verbose(`Uploading file "${id}"${isDefined(size) ? ` (${formatBytes(size)})` : ''}...`);
-        await file.save(stream, { contentType, resumable: false });
-        return {
-            id,
-            name: id,
-            uri: `gs://${bucket.name}/${file.name}`,
-            mimeType: contentType,
-        };
-    }
-    async uploadFileGenAi(fileInput, id) {
-        let uploadData;
-        let contentType;
-        let size;
-        if (isBlob(fileInput)) {
-            uploadData = fileInput;
-            contentType = fileInput.type;
-            size = fileInput.size;
-        }
-        else if (isPathFileInput(fileInput)) {
-            const fileState = await stat(fileInput.path);
-            uploadData = fileInput.path;
-            contentType = fileInput.mimeType;
-            size = fileState.size;
-        }
-        else {
-            const fileBytes = await readBinaryStream(fileInput.stream);
-            const blob = new Blob([fileBytes], { type: fileInput.mimeType });
-            uploadData = blob;
-            contentType = blob.type;
-            size = blob.size;
-        }
-        this.#logger.verbose(`Uploading file "${id}" (${formatBytes(size)})...`);
-        // upload supports paths and blobs, but not streams (yet)
-        const response = await this.#genAI.files.upload({ file: uploadData, config: { mimeType: contentType } });
-        return {
-            id,
-            name: assertDefinedPass(response.name, 'Missing file name'),
-            uri: assertDefinedPass(response.uri, 'Missing file uri'),
-            mimeType: assertDefinedPass(response.mimeType, 'Missing file mime type'),
-        };
-    }
-    async getBucket() {
-        if (isUndefined(this.#options.vertex)) {
-            throw new Error('Not using Vertex');
-        }
-        if (isDefined(this.#bucket)) {
-            return this.#bucket;
-        }
-        const bucketName = assertDefinedPass(this.#options.vertex.bucket, 'Bucket not specified');
-        const bucket = this.#storage.bucket(bucketName);
-        const [exists] = await bucket.exists();
-        if (!exists) {
-            this.#logger.info(`Bucket "${bucketName}" not found, creating...`);
-            const [createdBucket] = await this.#storage.createBucket(bucketName, {
-                location: this.#options.vertex.location,
-                lifecycle: {
-                    rule: [{
-                            action: { type: 'Delete' },
-                            condition: { age: 1 },
-                        }],
-                },
-            });
-            this.#bucket = createdBucket;
-        }
-        else {
-            this.#bucket = bucket;
-        }
-        return this.#bucket;
-    }
-    async waitForFileActive(file) {
-        if (isDefined(this.#options.vertex)) {
-            // For Vertex, uploads to GCS are instantly "active"
-            return;
-        }
-        for await (const backoff of backoffGenerator(this.#backoffOptions)) {
-            const state = await this.#genAI.files.get({ name: file.name });
-            if (state.state == FileState.ACTIVE) {
-                this.#logger.verbose(`File "${file.id}" is active.`);
-                return;
-            }
-            if (state.state == FileState.FAILED) {
-                throw new DetailsError(state.error?.message ?? `Failed to process file ${state.name}`, state.error?.details);
-            }
-            backoff();
-        }
-    }
-    async waitForFilesActive(files) {
-        // parallelizing does not help here, as each file upload is independently processed in the background
-        for (const file of files) {
-            await this.waitForFileActive(file);
-        }
-    }
-};
-AiFileService = __decorate([
-    Singleton()
-], AiFileService);
-export { AiFileService };

package/ai/ai-session.d.ts

@@ -1,38 +0,0 @@
-import type { OneOrMany } from '../types/index.js';
-import type { AiService, CallFunctionsOptions, SpecializedGenerationResult } from './ai.service.js';
-import type { Content, GenerationRequest, GenerationResult, SchemaFunctionDeclarations, SchemaFunctionDeclarationsResult } from './types.js';
-/**
- * Represents a conversational session with an AI model.
- *
- * This class maintains the history of contents (messages) in a conversation,
- * allowing for stateful, multi-turn interactions with the AI.
- */
-export declare class AiSession {
-    #private;
-    /**
-     * The history of contents in the session.
-     */
-    readonly contents: Content[];
-    /**
-     * Creates an instance of `AiSession`.
-     * @param aiService The {@link AiService} instance to use for AI interactions.
-     */
-    constructor(aiService: AiService);
-    /**
-     * Adds new content to the session's history without triggering a generation.
-     * @param content The content or contents to add.
-     */
-    addContent(content: OneOrMany<Content>): void;
-    /**
-     * Prompts the model to call one or more functions based on the provided context and session history.
-     * The new user content and the resulting model response (function calls) are automatically added to the session history.
-     * @param options The options for the function call request.
-     */
-    callFunctions<const T extends SchemaFunctionDeclarations>(options: CallFunctionsOptions<T>): Promise<SpecializedGenerationResult<SchemaFunctionDeclarationsResult<T>[]>>;
-    /**
-     * Generates content from the model based on the provided request and the current session history.
-     * The new user content and the resulting model response are automatically added to the session history.
-     * @param request The generation request.
-     */
-    generate(request: GenerationRequest): Promise<GenerationResult>;
-}