@tstdl/base 0.93.159 → 0.93.161

package/ai/genkit/multi-region.plugin.js

@@ -1,12 +1,18 @@
 import { vertexAI } from '@genkit-ai/google-genai';
 import { GenkitError, modelRef } from 'genkit';
 import { genkitPlugin } from 'genkit/plugin';
-import { shuffle } from '../../utils/array/index.js';
+import { distinct, shuffle } from '../../utils/array/index.js';
 import { isInstanceOf, isNullOrUndefined } from '../../utils/type-guards.js';
 import { millisecondsPerMinute, millisecondsPerSecond } from '../../utils/units.js';
 const pluginKey = 'vertexai-multi-location';
 const geminiModelReference = vertexAI.model('gemini-2.5-flash');
 export function vertexAiMultiLocation(options) {
+    if (options.locations.length == 0) {
+        throw new GenkitError({
+            status: 'INVALID_ARGUMENT',
+            message: 'At least one location must be provided for vertexAiMultiLocation',
+        });
+    }
     const locationConfigs = options.locations.map((location) => {
         const circuitBreakerKey = `genkit:vertex-ai:location:${location}`;
         const tokenLimitCircuitBreakerKey = `${circuitBreakerKey}:token-limit`;
@@ -41,16 +47,19 @@ export function vertexAiMultiLocation(options) {
             const shuffledConfigs = shuffle([...locationConfigs]);
             let lastError;
             let isLargeRequest = false;
+            const skippedLocations = [];
             for (const { location, circuitBreaker, tokenLimitCircuitBreaker } of shuffledConfigs) {
                 const check = await circuitBreaker.check();
                 if (!check.allowed) {
                     options.logger.warn(`Location ${location} is currently unhealthy. Skipping...`);
+                    skippedLocations.push({ location, reason: 'unhealthy' });
                     continue;
                 }
                 if (isLargeRequest) {
                     const tokenCheck = await tokenLimitCircuitBreaker.check();
                     if (!tokenCheck.allowed) {
                         options.logger.warn(`Location ${location} is known to have a low token limit. Skipping for this large request...`);
+                        skippedLocations.push({ location, reason: 'known to have low token limits' });
                         continue;
                     }
                 }
@@ -88,6 +97,14 @@ export function vertexAiMultiLocation(options) {
                     }
                 }
             }
+            if (isNullOrUndefined(lastError)) {
+                const uniqueReasons = distinct(skippedLocations.map((s) => s.reason));
+                const reasonsString = uniqueReasons.join(' or ');
+                throw new GenkitError({
+                    status: 'UNAVAILABLE',
+                    message: `All locations were skipped because they are ${reasonsString}`,
+                });
+            }
             throw lastError;
         });
     };

package/ai/genkit/tests/multi-region.test.js

@@ -138,4 +138,42 @@ describe('Genkit vertexai-multi-location Plugin Tests', () => {
         });
         expect(response2.text).toBe('success from cb-success');
     });
+    it('should throw if no locations are provided', async () => {
+        expect(() => {
+            vertexAiMultiLocation({
+                locations: [],
+                circuitBreakerProvider: cbProvider,
+                logger,
+            });
+        }).toThrow('At least one location must be provided');
+    });
+    it('should throw if all locations are unhealthy', async () => {
+        const ai2 = genkit({
+            plugins: [
+                vertexAiMultiLocation({
+                    locations: ['unhealthy-1'],
+                    circuitBreakerProvider: cbProvider,
+                    logger,
+                    circuitBreakerConfig: { resetTimeout: 1000000, threshold: 1 },
+                }),
+            ],
+        });
+        // Manually trip the circuit breaker
+        const cb = cbProvider.provide('genkit:vertex-ai:location:unhealthy-1', { threshold: 1, resetTimeout: 1000000 });
+        await cb.recordFailure();
+        ai2.defineModel({
+            name: 'vertexai/gemini-2.5-flash',
+        }, async () => {
+            return {
+                message: {
+                    role: 'model',
+                    content: [{ text: 'success' }],
+                },
+            };
+        });
+        await expect(ai2.generate({
+            model: 'vertexai-multi-location/gemini-2.5-flash',
+            prompt: 'test',
+        })).rejects.toThrow('All locations were skipped because they are unhealthy');
+    });
 });

package/errors/custom.error.d.ts

@@ -16,7 +16,7 @@ export type CustomErrorOptions = {
     /**
      * Cause for error
      */
-    cause?: Error;
+    cause?: unknown;
     /** Skip {@link Error} super call, which improves speed but looses stack trace */
     fast?: boolean | undefined;
 };

package/package.json

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

package/task-queue/postgres/task-queue.js

@@ -787,7 +787,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             if (isUndefined(updatedTask)) {
                 return;
             }
-            if (updatedTask.status == TaskStatus.Completed) {
+            if (updatedTask.status == TaskStatus.Completed || updatedTask.status == TaskStatus.WaitingChildren) {
                 await this.#circuitBreaker.recordSuccess();
             }
             await this.resolveDependencies(task.id, updatedTask.status, { namespace: task.namespace, transaction: tx });
@@ -828,7 +828,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                 .select({ id: updated.id, status: updated.status })
                 .from(updated);
             if (updatedRows.length > 0) {
-                if (updatedRows.some((r) => r.status == TaskStatus.Completed)) {
+                if (updatedRows.some((r) => r.status == TaskStatus.Completed || r.status == TaskStatus.WaitingChildren)) {
                     await this.#circuitBreaker.recordSuccess();
                 }
                 await this.resolveDependenciesMany(updatedRows.map((r) => ({ id: r.id, status: r.status })), { transaction: tx });
@@ -1171,6 +1171,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                     .where(inArray(taskTable.id, tx.pgTransaction.select().from(selection)))
                     .returning({ id: taskTable.id, status: taskTable.status });
                 if (updatedRows.length > 0) {
+                    await this.#circuitBreaker.recordFailures(updatedRows.length);
                     await this.resolveDependenciesMany(updatedRows.map((r) => ({ id: r.id, status: r.status, namespace: this.#namespace })), { transaction: tx });
                 }
                 return updatedRows;

package/task-queue/task.error.js

@@ -12,7 +12,7 @@ export function ensureTaskError(error) {
         return error;
     }
     if (isString(error)) {
-        return new TaskError(error, undefined);
+        return new TaskError(error);
     }
     return new TaskError(`A task error occurred: ${formatError(error)}`);
 }