@tstdl/base 0.93.110 → 0.93.112

package/ai/genkit/index.d.ts

@@ -1,2 +1,4 @@
 export * from './helpers.js';
 export * from './module.js';
+export * from './multi-region.plugin.js';
+export * from './types.js';

package/ai/genkit/index.js

@@ -1,2 +1,4 @@
 export * from './helpers.js';
 export * from './module.js';
+export * from './multi-region.plugin.js';
+export * from './types.js';

package/ai/genkit/module.d.ts

@@ -1,5 +1,7 @@
-import { vertexAI } from '@genkit-ai/google-genai';
+import { vertexAI, type GeminiConfig } from '@genkit-ai/google-genai';
 import { type Genkit, type GenkitOptions } from 'genkit';
+import { type GeminiModelReference } from './multi-region.plugin.js';
+import type { VertexAiMultiLocationOptions } from './types.js';
 /**
  * Options for configuring the AI Module.
  */
@@ -20,6 +22,8 @@ export declare class GenkitModuleOptions {
         /** Path to the Google Cloud credentials file */
         keyFile?: string;
     };
+    /** Multi-region configuration options. */
+    multiLocationVertex?: VertexAiMultiLocationOptions;
     /** Plugins to register automatically */
     plugins?: GenkitOptions['plugins'];
     /** Default Genkit options */
@@ -32,4 +36,5 @@ export declare class GenkitModuleOptions {
 export declare function configureGenkit(options: GenkitModuleOptions): void;
 export declare function injectGenkit(options?: GenkitOptions): Genkit;
 declare const _injectModel: typeof vertexAI.model;
+export declare function injectMultiLocationModel(model: string, config?: GeminiConfig): GeminiModelReference;
 export { _injectModel as injectModel };

package/ai/genkit/module.js

@@ -1,8 +1,11 @@
 import { googleAI, vertexAI } from '@genkit-ai/google-genai';
 import { genkit } from 'genkit';
+import { CircuitBreakerProvider } from '../../circuit-breaker/provider.js';
 import { inject } from '../../injector/inject.js';
 import { Injector } from '../../injector/injector.js';
+import { Logger } from '../../logger/logger.js';
 import { isDefined, isNotNull } from '../../utils/type-guards.js';
+import { vertexAiMultiLocation } from './multi-region.plugin.js';
 /**
  * Options for configuring the AI Module.
  */
@@ -11,6 +14,8 @@ export class GenkitModuleOptions {
     gemini;
     /** Vertex AI specific options. If provided, the service will use Vertex AI endpoints. */
     vertex;
+    /** Multi-region configuration options. */
+    multiLocationVertex;
     /** Plugins to register automatically */
     plugins;
     /** Default Genkit options */
@@ -36,12 +41,21 @@ export function injectGenkit(options) {
     const geminiPlugin = isDefined(gemini)
         ? googleAI({ apiKey: gemini.apiKey })
         : null;
+    const multiLocationVertexPlugin = isDefined(moduleOptions.multiLocationVertex)
+        ? vertexAiMultiLocation({
+            locations: moduleOptions.multiLocationVertex.locations,
+            circuitBreakerProvider: inject(CircuitBreakerProvider),
+            logger: inject(Logger, 'VertexAiMultiRegion'),
+            circuitBreakerConfig: moduleOptions.multiLocationVertex.circuitBreakerConfig,
+        })
+        : null;
     return genkit({
         ...moduleOptions.options,
         ...options,
         plugins: [
             geminiPlugin,
             vertexPlugin,
+            multiLocationVertexPlugin,
             ...(moduleOptions.plugins ?? []),
             ...(options?.plugins ?? []),
         ].filter(isNotNull),
@@ -53,4 +67,7 @@ function injectModel(...args) {
     return provider.model(...args);
 }
 const _injectModel = injectModel;
+export function injectMultiLocationModel(model, config) {
+    return vertexAiMultiLocation.model(_injectModel(model, config));
+}
 export { _injectModel as injectModel };

package/ai/genkit/multi-region.plugin.d.ts

@@ -0,0 +1,424 @@
+import type { CircuitBreakerProvider } from '../../circuit-breaker/provider.js';
+import type { Logger } from '../../logger/logger.js';
+import type { VertexAiMultiLocationOptions } from './types.js';
+export type GeminiModelReference = typeof geminiModelReference;
+declare const geminiModelReference: import("genkit").ModelReference<import("zod").ZodObject<{
+    version: import("zod").ZodOptional<import("zod").ZodString>;
+    maxOutputTokens: import("zod").ZodOptional<import("zod").ZodNumber>;
+    topK: import("zod").ZodOptional<import("zod").ZodNumber>;
+    stopSequences: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+} & {
+    apiKey: import("zod").ZodOptional<import("zod").ZodString>;
+    labels: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+    temperature: import("zod").ZodOptional<import("zod").ZodNumber>;
+    topP: import("zod").ZodOptional<import("zod").ZodNumber>;
+    location: import("zod").ZodOptional<import("zod").ZodString>;
+    safetySettings: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        category: import("zod").ZodEnum<["HARM_CATEGORY_UNSPECIFIED", "HARM_CATEGORY_HATE_SPEECH", "HARM_CATEGORY_DANGEROUS_CONTENT", "HARM_CATEGORY_HARASSMENT", "HARM_CATEGORY_SEXUALLY_EXPLICIT"]>;
+        threshold: import("zod").ZodEnum<["BLOCK_LOW_AND_ABOVE", "BLOCK_MEDIUM_AND_ABOVE", "BLOCK_ONLY_HIGH", "BLOCK_NONE"]>;
+    }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+        category: import("zod").ZodEnum<["HARM_CATEGORY_UNSPECIFIED", "HARM_CATEGORY_HATE_SPEECH", "HARM_CATEGORY_DANGEROUS_CONTENT", "HARM_CATEGORY_HARASSMENT", "HARM_CATEGORY_SEXUALLY_EXPLICIT"]>;
+        threshold: import("zod").ZodEnum<["BLOCK_LOW_AND_ABOVE", "BLOCK_MEDIUM_AND_ABOVE", "BLOCK_ONLY_HIGH", "BLOCK_NONE"]>;
+    }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+        category: import("zod").ZodEnum<["HARM_CATEGORY_UNSPECIFIED", "HARM_CATEGORY_HATE_SPEECH", "HARM_CATEGORY_DANGEROUS_CONTENT", "HARM_CATEGORY_HARASSMENT", "HARM_CATEGORY_SEXUALLY_EXPLICIT"]>;
+        threshold: import("zod").ZodEnum<["BLOCK_LOW_AND_ABOVE", "BLOCK_MEDIUM_AND_ABOVE", "BLOCK_ONLY_HIGH", "BLOCK_NONE"]>;
+    }, import("zod").ZodTypeAny, "passthrough">>, "many">>;
+    vertexRetrieval: import("zod").ZodOptional<import("zod").ZodObject<{
+        datastore: import("zod").ZodObject<{
+            projectId: import("zod").ZodOptional<import("zod").ZodString>;
+            location: import("zod").ZodOptional<import("zod").ZodString>;
+            dataStoreId: import("zod").ZodString;
+        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+            projectId: import("zod").ZodOptional<import("zod").ZodString>;
+            location: import("zod").ZodOptional<import("zod").ZodString>;
+            dataStoreId: import("zod").ZodString;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            projectId: import("zod").ZodOptional<import("zod").ZodString>;
+            location: import("zod").ZodOptional<import("zod").ZodString>;
+            dataStoreId: import("zod").ZodString;
+        }, import("zod").ZodTypeAny, "passthrough">>;
+        disableAttribution: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+        datastore: import("zod").ZodObject<{
+            projectId: import("zod").ZodOptional<import("zod").ZodString>;
+            location: import("zod").ZodOptional<import("zod").ZodString>;
+            dataStoreId: import("zod").ZodString;
+        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+            projectId: import("zod").ZodOptional<import("zod").ZodString>;
+            location: import("zod").ZodOptional<import("zod").ZodString>;
+            dataStoreId: import("zod").ZodString;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            projectId: import("zod").ZodOptional<import("zod").ZodString>;
+            location: import("zod").ZodOptional<import("zod").ZodString>;
+            dataStoreId: import("zod").ZodString;
+        }, import("zod").ZodTypeAny, "passthrough">>;
+        disableAttribution: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+        datastore: import("zod").ZodObject<{
+            projectId: import("zod").ZodOptional<import("zod").ZodString>;
+            location: import("zod").ZodOptional<import("zod").ZodString>;
+            dataStoreId: import("zod").ZodString;
+        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+            projectId: import("zod").ZodOptional<import("zod").ZodString>;
+            location: import("zod").ZodOptional<import("zod").ZodString>;
+            dataStoreId: import("zod").ZodString;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            projectId: import("zod").ZodOptional<import("zod").ZodString>;
+            location: import("zod").ZodOptional<import("zod").ZodString>;
+            dataStoreId: import("zod").ZodString;
+        }, import("zod").ZodTypeAny, "passthrough">>;
+        disableAttribution: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, import("zod").ZodTypeAny, "passthrough">>>;
+    googleSearchRetrieval: import("zod").ZodOptional<import("zod").ZodObject<{
+        disableAttribution: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+        disableAttribution: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+        disableAttribution: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, import("zod").ZodTypeAny, "passthrough">>>;
+    functionCallingConfig: import("zod").ZodOptional<import("zod").ZodObject<{
+        mode: import("zod").ZodOptional<import("zod").ZodEnum<["MODE_UNSPECIFIED", "AUTO", "ANY", "NONE"]>>;
+        allowedFunctionNames: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        streamFunctionCallArguments: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+        mode: import("zod").ZodOptional<import("zod").ZodEnum<["MODE_UNSPECIFIED", "AUTO", "ANY", "NONE"]>>;
+        allowedFunctionNames: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        streamFunctionCallArguments: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+        mode: import("zod").ZodOptional<import("zod").ZodEnum<["MODE_UNSPECIFIED", "AUTO", "ANY", "NONE"]>>;
+        allowedFunctionNames: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        streamFunctionCallArguments: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, import("zod").ZodTypeAny, "passthrough">>>;
+    retrievalConfig: import("zod").ZodOptional<import("zod").ZodObject<{
+        latLng: import("zod").ZodOptional<import("zod").ZodObject<{
+            latitude: import("zod").ZodOptional<import("zod").ZodNumber>;
+            longitude: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, "strip", import("zod").ZodTypeAny, {
+            latitude?: number | undefined;
+            longitude?: number | undefined;
+        }, {
+            latitude?: number | undefined;
+            longitude?: number | undefined;
+        }>>;
+        languageCode: import("zod").ZodOptional<import("zod").ZodString>;
+    }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+        latLng: import("zod").ZodOptional<import("zod").ZodObject<{
+            latitude: import("zod").ZodOptional<import("zod").ZodNumber>;
+            longitude: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, "strip", import("zod").ZodTypeAny, {
+            latitude?: number | undefined;
+            longitude?: number | undefined;
+        }, {
+            latitude?: number | undefined;
+            longitude?: number | undefined;
+        }>>;
+        languageCode: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+        latLng: import("zod").ZodOptional<import("zod").ZodObject<{
+            latitude: import("zod").ZodOptional<import("zod").ZodNumber>;
+            longitude: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, "strip", import("zod").ZodTypeAny, {
+            latitude?: number | undefined;
+            longitude?: number | undefined;
+        }, {
+            latitude?: number | undefined;
+            longitude?: number | undefined;
+        }>>;
+        languageCode: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod").ZodTypeAny, "passthrough">>>;
+    thinkingConfig: import("zod").ZodOptional<import("zod").ZodObject<{
+        includeThoughts: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        thinkingBudget: import("zod").ZodOptional<import("zod").ZodNumber>;
+        thinkingLevel: import("zod").ZodOptional<import("zod").ZodEnum<["MINIMAL", "LOW", "MEDIUM", "HIGH"]>>;
+    }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+        includeThoughts: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        thinkingBudget: import("zod").ZodOptional<import("zod").ZodNumber>;
+        thinkingLevel: import("zod").ZodOptional<import("zod").ZodEnum<["MINIMAL", "LOW", "MEDIUM", "HIGH"]>>;
+    }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+        includeThoughts: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        thinkingBudget: import("zod").ZodOptional<import("zod").ZodNumber>;
+        thinkingLevel: import("zod").ZodOptional<import("zod").ZodEnum<["MINIMAL", "LOW", "MEDIUM", "HIGH"]>>;
+    }, import("zod").ZodTypeAny, "passthrough">>>;
+}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+    version: import("zod").ZodOptional<import("zod").ZodString>;
+    maxOutputTokens: import("zod").ZodOptional<import("zod").ZodNumber>;
+    topK: import("zod").ZodOptional<import("zod").ZodNumber>;
+    stopSequences: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+} & {
+    apiKey: import("zod").ZodOptional<import("zod").ZodString>;
+    labels: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+    temperature: import("zod").ZodOptional<import("zod").ZodNumber>;
+    topP: import("zod").ZodOptional<import("zod").ZodNumber>;
+    location: import("zod").ZodOptional<import("zod").ZodString>;
+    safetySettings: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        category: import("zod").ZodEnum<["HARM_CATEGORY_UNSPECIFIED", "HARM_CATEGORY_HATE_SPEECH", "HARM_CATEGORY_DANGEROUS_CONTENT", "HARM_CATEGORY_HARASSMENT", "HARM_CATEGORY_SEXUALLY_EXPLICIT"]>;
+        threshold: import("zod").ZodEnum<["BLOCK_LOW_AND_ABOVE", "BLOCK_MEDIUM_AND_ABOVE", "BLOCK_ONLY_HIGH", "BLOCK_NONE"]>;
+    }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+        category: import("zod").ZodEnum<["HARM_CATEGORY_UNSPECIFIED", "HARM_CATEGORY_HATE_SPEECH", "HARM_CATEGORY_DANGEROUS_CONTENT", "HARM_CATEGORY_HARASSMENT", "HARM_CATEGORY_SEXUALLY_EXPLICIT"]>;
+        threshold: import("zod").ZodEnum<["BLOCK_LOW_AND_ABOVE", "BLOCK_MEDIUM_AND_ABOVE", "BLOCK_ONLY_HIGH", "BLOCK_NONE"]>;
+    }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+        category: import("zod").ZodEnum<["HARM_CATEGORY_UNSPECIFIED", "HARM_CATEGORY_HATE_SPEECH", "HARM_CATEGORY_DANGEROUS_CONTENT", "HARM_CATEGORY_HARASSMENT", "HARM_CATEGORY_SEXUALLY_EXPLICIT"]>;
+        threshold: import("zod").ZodEnum<["BLOCK_LOW_AND_ABOVE", "BLOCK_MEDIUM_AND_ABOVE", "BLOCK_ONLY_HIGH", "BLOCK_NONE"]>;
+    }, import("zod").ZodTypeAny, "passthrough">>, "many">>;
+    vertexRetrieval: import("zod").ZodOptional<import("zod").ZodObject<{
+        datastore: import("zod").ZodObject<{
+            projectId: import("zod").ZodOptional<import("zod").ZodString>;
+            location: import("zod").ZodOptional<import("zod").ZodString>;
+            dataStoreId: import("zod").ZodString;
+        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+            projectId: import("zod").ZodOptional<import("zod").ZodString>;
+            location: import("zod").ZodOptional<import("zod").ZodString>;
+            dataStoreId: import("zod").ZodString;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            projectId: import("zod").ZodOptional<import("zod").ZodString>;
+            location: import("zod").ZodOptional<import("zod").ZodString>;
+            dataStoreId: import("zod").ZodString;
+        }, import("zod").ZodTypeAny, "passthrough">>;
+        disableAttribution: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+        datastore: import("zod").ZodObject<{
+            projectId: import("zod").ZodOptional<import("zod").ZodString>;
+            location: import("zod").ZodOptional<import("zod").ZodString>;
+            dataStoreId: import("zod").ZodString;
+        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+            projectId: import("zod").ZodOptional<import("zod").ZodString>;
+            location: import("zod").ZodOptional<import("zod").ZodString>;
+            dataStoreId: import("zod").ZodString;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            projectId: import("zod").ZodOptional<import("zod").ZodString>;
+            location: import("zod").ZodOptional<import("zod").ZodString>;
+            dataStoreId: import("zod").ZodString;
+        }, import("zod").ZodTypeAny, "passthrough">>;
+        disableAttribution: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+        datastore: import("zod").ZodObject<{
+            projectId: import("zod").ZodOptional<import("zod").ZodString>;
+            location: import("zod").ZodOptional<import("zod").ZodString>;
+            dataStoreId: import("zod").ZodString;
+        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+            projectId: import("zod").ZodOptional<import("zod").ZodString>;
+            location: import("zod").ZodOptional<import("zod").ZodString>;
+            dataStoreId: import("zod").ZodString;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            projectId: import("zod").ZodOptional<import("zod").ZodString>;
+            location: import("zod").ZodOptional<import("zod").ZodString>;
+            dataStoreId: import("zod").ZodString;
+        }, import("zod").ZodTypeAny, "passthrough">>;
+        disableAttribution: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, import("zod").ZodTypeAny, "passthrough">>>;
+    googleSearchRetrieval: import("zod").ZodOptional<import("zod").ZodObject<{
+        disableAttribution: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+        disableAttribution: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+        disableAttribution: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, import("zod").ZodTypeAny, "passthrough">>>;
+    functionCallingConfig: import("zod").ZodOptional<import("zod").ZodObject<{
+        mode: import("zod").ZodOptional<import("zod").ZodEnum<["MODE_UNSPECIFIED", "AUTO", "ANY", "NONE"]>>;
+        allowedFunctionNames: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        streamFunctionCallArguments: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+        mode: import("zod").ZodOptional<import("zod").ZodEnum<["MODE_UNSPECIFIED", "AUTO", "ANY", "NONE"]>>;
+        allowedFunctionNames: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        streamFunctionCallArguments: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+        mode: import("zod").ZodOptional<import("zod").ZodEnum<["MODE_UNSPECIFIED", "AUTO", "ANY", "NONE"]>>;
+        allowedFunctionNames: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        streamFunctionCallArguments: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, import("zod").ZodTypeAny, "passthrough">>>;
+    retrievalConfig: import("zod").ZodOptional<import("zod").ZodObject<{
+        latLng: import("zod").ZodOptional<import("zod").ZodObject<{
+            latitude: import("zod").ZodOptional<import("zod").ZodNumber>;
+            longitude: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, "strip", import("zod").ZodTypeAny, {
+            latitude?: number | undefined;
+            longitude?: number | undefined;
+        }, {
+            latitude?: number | undefined;
+            longitude?: number | undefined;
+        }>>;
+        languageCode: import("zod").ZodOptional<import("zod").ZodString>;
+    }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+        latLng: import("zod").ZodOptional<import("zod").ZodObject<{
+            latitude: import("zod").ZodOptional<import("zod").ZodNumber>;
+            longitude: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, "strip", import("zod").ZodTypeAny, {
+            latitude?: number | undefined;
+            longitude?: number | undefined;
+        }, {
+            latitude?: number | undefined;
+            longitude?: number | undefined;
+        }>>;
+        languageCode: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+        latLng: import("zod").ZodOptional<import("zod").ZodObject<{
+            latitude: import("zod").ZodOptional<import("zod").ZodNumber>;
+            longitude: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, "strip", import("zod").ZodTypeAny, {
+            latitude?: number | undefined;
+            longitude?: number | undefined;
+        }, {
+            latitude?: number | undefined;
+            longitude?: number | undefined;
+        }>>;
+        languageCode: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod").ZodTypeAny, "passthrough">>>;
+    thinkingConfig: import("zod").ZodOptional<import("zod").ZodObject<{
+        includeThoughts: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        thinkingBudget: import("zod").ZodOptional<import("zod").ZodNumber>;
+        thinkingLevel: import("zod").ZodOptional<import("zod").ZodEnum<["MINIMAL", "LOW", "MEDIUM", "HIGH"]>>;
+    }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+        includeThoughts: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        thinkingBudget: import("zod").ZodOptional<import("zod").ZodNumber>;
+        thinkingLevel: import("zod").ZodOptional<import("zod").ZodEnum<["MINIMAL", "LOW", "MEDIUM", "HIGH"]>>;
+    }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+        includeThoughts: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        thinkingBudget: import("zod").ZodOptional<import("zod").ZodNumber>;
+        thinkingLevel: import("zod").ZodOptional<import("zod").ZodEnum<["MINIMAL", "LOW", "MEDIUM", "HIGH"]>>;
+    }, import("zod").ZodTypeAny, "passthrough">>>;
+}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+    version: import("zod").ZodOptional<import("zod").ZodString>;
+    maxOutputTokens: import("zod").ZodOptional<import("zod").ZodNumber>;
+    topK: import("zod").ZodOptional<import("zod").ZodNumber>;
+    stopSequences: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+} & {
+    apiKey: import("zod").ZodOptional<import("zod").ZodString>;
+    labels: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+    temperature: import("zod").ZodOptional<import("zod").ZodNumber>;
+    topP: import("zod").ZodOptional<import("zod").ZodNumber>;
+    location: import("zod").ZodOptional<import("zod").ZodString>;
+    safetySettings: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        category: import("zod").ZodEnum<["HARM_CATEGORY_UNSPECIFIED", "HARM_CATEGORY_HATE_SPEECH", "HARM_CATEGORY_DANGEROUS_CONTENT", "HARM_CATEGORY_HARASSMENT", "HARM_CATEGORY_SEXUALLY_EXPLICIT"]>;
+        threshold: import("zod").ZodEnum<["BLOCK_LOW_AND_ABOVE", "BLOCK_MEDIUM_AND_ABOVE", "BLOCK_ONLY_HIGH", "BLOCK_NONE"]>;
+    }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+        category: import("zod").ZodEnum<["HARM_CATEGORY_UNSPECIFIED", "HARM_CATEGORY_HATE_SPEECH", "HARM_CATEGORY_DANGEROUS_CONTENT", "HARM_CATEGORY_HARASSMENT", "HARM_CATEGORY_SEXUALLY_EXPLICIT"]>;
+        threshold: import("zod").ZodEnum<["BLOCK_LOW_AND_ABOVE", "BLOCK_MEDIUM_AND_ABOVE", "BLOCK_ONLY_HIGH", "BLOCK_NONE"]>;
+    }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+        category: import("zod").ZodEnum<["HARM_CATEGORY_UNSPECIFIED", "HARM_CATEGORY_HATE_SPEECH", "HARM_CATEGORY_DANGEROUS_CONTENT", "HARM_CATEGORY_HARASSMENT", "HARM_CATEGORY_SEXUALLY_EXPLICIT"]>;
+        threshold: import("zod").ZodEnum<["BLOCK_LOW_AND_ABOVE", "BLOCK_MEDIUM_AND_ABOVE", "BLOCK_ONLY_HIGH", "BLOCK_NONE"]>;
+    }, import("zod").ZodTypeAny, "passthrough">>, "many">>;
+    vertexRetrieval: import("zod").ZodOptional<import("zod").ZodObject<{
+        datastore: import("zod").ZodObject<{
+            projectId: import("zod").ZodOptional<import("zod").ZodString>;
+            location: import("zod").ZodOptional<import("zod").ZodString>;
+            dataStoreId: import("zod").ZodString;
+        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+            projectId: import("zod").ZodOptional<import("zod").ZodString>;
+            location: import("zod").ZodOptional<import("zod").ZodString>;
+            dataStoreId: import("zod").ZodString;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            projectId: import("zod").ZodOptional<import("zod").ZodString>;
+            location: import("zod").ZodOptional<import("zod").ZodString>;
+            dataStoreId: import("zod").ZodString;
+        }, import("zod").ZodTypeAny, "passthrough">>;
+        disableAttribution: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+        datastore: import("zod").ZodObject<{
+            projectId: import("zod").ZodOptional<import("zod").ZodString>;
+            location: import("zod").ZodOptional<import("zod").ZodString>;
+            dataStoreId: import("zod").ZodString;
+        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+            projectId: import("zod").ZodOptional<import("zod").ZodString>;
+            location: import("zod").ZodOptional<import("zod").ZodString>;
+            dataStoreId: import("zod").ZodString;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            projectId: import("zod").ZodOptional<import("zod").ZodString>;
+            location: import("zod").ZodOptional<import("zod").ZodString>;
+            dataStoreId: import("zod").ZodString;
+        }, import("zod").ZodTypeAny, "passthrough">>;
+        disableAttribution: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+        datastore: import("zod").ZodObject<{
+            projectId: import("zod").ZodOptional<import("zod").ZodString>;
+            location: import("zod").ZodOptional<import("zod").ZodString>;
+            dataStoreId: import("zod").ZodString;
+        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+            projectId: import("zod").ZodOptional<import("zod").ZodString>;
+            location: import("zod").ZodOptional<import("zod").ZodString>;
+            dataStoreId: import("zod").ZodString;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            projectId: import("zod").ZodOptional<import("zod").ZodString>;
+            location: import("zod").ZodOptional<import("zod").ZodString>;
+            dataStoreId: import("zod").ZodString;
+        }, import("zod").ZodTypeAny, "passthrough">>;
+        disableAttribution: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, import("zod").ZodTypeAny, "passthrough">>>;
+    googleSearchRetrieval: import("zod").ZodOptional<import("zod").ZodObject<{
+        disableAttribution: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+        disableAttribution: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+        disableAttribution: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, import("zod").ZodTypeAny, "passthrough">>>;
+    functionCallingConfig: import("zod").ZodOptional<import("zod").ZodObject<{
+        mode: import("zod").ZodOptional<import("zod").ZodEnum<["MODE_UNSPECIFIED", "AUTO", "ANY", "NONE"]>>;
+        allowedFunctionNames: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        streamFunctionCallArguments: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+        mode: import("zod").ZodOptional<import("zod").ZodEnum<["MODE_UNSPECIFIED", "AUTO", "ANY", "NONE"]>>;
+        allowedFunctionNames: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        streamFunctionCallArguments: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+        mode: import("zod").ZodOptional<import("zod").ZodEnum<["MODE_UNSPECIFIED", "AUTO", "ANY", "NONE"]>>;
+        allowedFunctionNames: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        streamFunctionCallArguments: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, import("zod").ZodTypeAny, "passthrough">>>;
+    retrievalConfig: import("zod").ZodOptional<import("zod").ZodObject<{
+        latLng: import("zod").ZodOptional<import("zod").ZodObject<{
+            latitude: import("zod").ZodOptional<import("zod").ZodNumber>;
+            longitude: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, "strip", import("zod").ZodTypeAny, {
+            latitude?: number | undefined;
+            longitude?: number | undefined;
+        }, {
+            latitude?: number | undefined;
+            longitude?: number | undefined;
+        }>>;
+        languageCode: import("zod").ZodOptional<import("zod").ZodString>;
+    }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+        latLng: import("zod").ZodOptional<import("zod").ZodObject<{
+            latitude: import("zod").ZodOptional<import("zod").ZodNumber>;
+            longitude: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, "strip", import("zod").ZodTypeAny, {
+            latitude?: number | undefined;
+            longitude?: number | undefined;
+        }, {
+            latitude?: number | undefined;
+            longitude?: number | undefined;
+        }>>;
+        languageCode: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+        latLng: import("zod").ZodOptional<import("zod").ZodObject<{
+            latitude: import("zod").ZodOptional<import("zod").ZodNumber>;
+            longitude: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, "strip", import("zod").ZodTypeAny, {
+            latitude?: number | undefined;
+            longitude?: number | undefined;
+        }, {
+            latitude?: number | undefined;
+            longitude?: number | undefined;
+        }>>;
+        languageCode: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod").ZodTypeAny, "passthrough">>>;
+    thinkingConfig: import("zod").ZodOptional<import("zod").ZodObject<{
+        includeThoughts: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        thinkingBudget: import("zod").ZodOptional<import("zod").ZodNumber>;
+        thinkingLevel: import("zod").ZodOptional<import("zod").ZodEnum<["MINIMAL", "LOW", "MEDIUM", "HIGH"]>>;
+    }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+        includeThoughts: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        thinkingBudget: import("zod").ZodOptional<import("zod").ZodNumber>;
+        thinkingLevel: import("zod").ZodOptional<import("zod").ZodEnum<["MINIMAL", "LOW", "MEDIUM", "HIGH"]>>;
+    }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+        includeThoughts: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        thinkingBudget: import("zod").ZodOptional<import("zod").ZodNumber>;
+        thinkingLevel: import("zod").ZodOptional<import("zod").ZodEnum<["MINIMAL", "LOW", "MEDIUM", "HIGH"]>>;
+    }, import("zod").ZodTypeAny, "passthrough">>>;
+}, import("zod").ZodTypeAny, "passthrough">>>;
+export declare function vertexAiMultiLocation(options: VertexAiMultiLocationOptions & {
+    circuitBreakerProvider: CircuitBreakerProvider;
+    logger: Logger;
+}): import("genkit/plugin").GenkitPlugin;
+export declare namespace vertexAiMultiLocation {
+    var model: <T extends GeminiModelReference>(baseModel: T) => T;
+}
+export {};

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

@@ -0,0 +1,85 @@
+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 { isInstanceOf, isNullOrUndefined } from '../../utils/type-guards.js';
+const pluginKey = 'vertexai-multi-location';
+const geminiModelReference = vertexAI.model('gemini-2.5-flash');
+export function vertexAiMultiLocation(options) {
+    const createVirtualizedModelAction = async (ai, modelName) => {
+        const baseModelName = `vertexai/${modelName}`;
+        const target = modelName;
+        const baseModelAction = await ai.registry.lookupAction(`/model/${baseModelName}`);
+        if (isNullOrUndefined(baseModelAction)) {
+            return null;
+        }
+        return ai.defineModel({
+            name: target,
+            versions: baseModelAction.__action.metadata?.['model']?.versions,
+            supports: baseModelAction.__action.metadata?.['model']?.supports,
+            configSchema: baseModelAction.__action.inputSchema?.shape?.config,
+            label: `${baseModelAction.__action.description ?? baseModelAction.__action.name} (Multi-Location Routing)`,
+        }, async (request, streamingCallback) => {
+            const shuffledLocations = shuffle([...options.locations]);
+            let lastError;
+            for (const location of shuffledLocations) {
+                const circuitBreakerKey = `genkit:vertex-ai:location:${location}`;
+                const circuitBreaker = options.circuitBreakerProvider.provide(circuitBreakerKey, {
+                    threshold: 1, // Aggressive for 429
+                    resetTimeout: options.circuitBreakerConfig?.resetTimeout ?? 30000,
+                    ...options.circuitBreakerConfig,
+                });
+                const check = await circuitBreaker.check();
+                if (!check.allowed) {
+                    options.logger.warn(`Location ${location} is currently unhealthy. Skipping...`);
+                    continue;
+                }
+                try {
+                    const result = await baseModelAction({
+                        ...request,
+                        config: {
+                            ...request.config,
+                            location: location,
+                        },
+                    }, {
+                        onChunk: streamingCallback,
+                    });
+                    await circuitBreaker.recordSuccess();
+                    return result;
+                }
+                catch (error) {
+                    lastError = error;
+                    if (!isInstanceOf(error, GenkitError)) {
+                        throw error;
+                    }
+                    const isRetryable = ((error.status == 'RESOURCE_EXHAUSTED') || (error.status == 'UNAVAILABLE') || error.message.includes('quota'));
+                    if (!isRetryable) {
+                        throw error;
+                    }
+                    options.logger.warn(`Location ${location} responded with ${error.status}. Tripping circuit breaker and trying next location...`);
+                    await circuitBreaker.recordFailure();
+                }
+            }
+            throw lastError;
+        });
+    };
+    return genkitPlugin(pluginKey, async (_ai) => {
+        // Register nothing initially, rely on lazy resolution via resolver
+    }, async (ai, actionType, target) => {
+        if (actionType != 'model') {
+            return;
+        }
+        // Register the action immediately so the lookup succeeds
+        // We must register it directly in the registry since ai.defineModel is async and might be too late
+        (ai.registry).registerActionAsync('model', target, createVirtualizedModelAction(ai, target), { namespace: pluginKey });
+    });
+}
+vertexAiMultiLocation.model = function multiLocationModel(baseModel) {
+    return modelRef({
+        name: `${pluginKey}/${baseModel.name.replace('vertexai/', '')}`,
+        configSchema: baseModel.configSchema,
+        info: baseModel.info,
+        version: baseModel.version,
+        config: baseModel.config,
+    });
+};

package/ai/genkit/tests/multi-region.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,138 @@
+import { genkit, GenkitError, z } from 'genkit';
+import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { CircuitBreakerState } from '../../../circuit-breaker/index.js';
+import { CircuitBreakerProvider } from '../../../circuit-breaker/provider.js';
+import { Logger } from '../../../logger/logger.js';
+import { setupIntegrationTest } from '../../../unit-test/index.js';
+import { vertexAiMultiLocation } from '../multi-region.plugin.js';
+vi.mock('#/utils/array/index.js', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        shuffle: vi.fn((items) => [...items]),
+    };
+});
+vi.mock('@genkit-ai/google-genai', () => ({
+    vertexAI: {
+        model: vi.fn((name) => ({
+            name: `vertexai/${name}`,
+            info: { label: 'mock' },
+            configSchema: z.object({}),
+        })),
+    },
+    googleAI: vi.fn(),
+}));
+describe('Genkit vertexai-multi-location Plugin Tests', () => {
+    let ai;
+    let cbProvider;
+    let logger;
+    beforeAll(async () => {
+        const { injector } = await setupIntegrationTest({ modules: { circuitBreaker: true } });
+        cbProvider = injector.resolve(CircuitBreakerProvider);
+        logger = injector.resolve(Logger, 'Test');
+        ai = genkit({
+            plugins: [
+                vertexAiMultiLocation({
+                    locations: ['region-1', 'region-2'],
+                    circuitBreakerProvider: cbProvider,
+                    logger,
+                    circuitBreakerConfig: { resetTimeout: 1000000 },
+                }),
+            ],
+        });
+    });
+    beforeEach(async () => {
+        vi.clearAllMocks();
+        const config = { threshold: 1, resetTimeout: 1000000 };
+        await cbProvider.provide('genkit:vertex-ai:location:region-1', config).recordSuccess();
+        await cbProvider.provide('genkit:vertex-ai:location:region-2', config).recordSuccess();
+        await cbProvider.provide('genkit:vertex-ai:location:cb-fail', config).recordSuccess();
+        await cbProvider.provide('genkit:vertex-ai:location:cb-success', config).recordSuccess();
+    });
+    it('should route to a location successfully', async () => {
+        // Register a mock for the regional model in the registry
+        ai.defineModel({
+            name: 'vertexai/gemini-2.5-flash',
+        }, async (request) => {
+            return {
+                message: {
+                    role: 'model',
+                    content: [{ text: `hello from ${request.config?.location}` }],
+                },
+            };
+        });
+        const response = await ai.generate({
+            model: 'vertexai-multi-location/gemini-2.5-flash',
+            prompt: 'test',
+        });
+        expect(response.text).toContain('hello from');
+    });
+    it('should failover on 429 error', async () => {
+        let callCount = 0;
+        // Overwrite the mock model to fail once
+        ai.defineModel({
+            name: 'vertexai/gemini-2.5-flash',
+        }, async (request) => {
+            callCount++;
+            if (callCount === 1) {
+                throw new GenkitError({ status: 'RESOURCE_EXHAUSTED', message: 'Rate limit exceeded' });
+            }
+            return {
+                message: {
+                    role: 'model',
+                    content: [{ text: `success from ${request.config?.location}` }],
+                },
+            };
+        });
+        const response = await ai.generate({
+            model: 'vertexai-multi-location/gemini-2.5-flash',
+            prompt: 'test',
+        });
+        expect(response.text).toContain('success from');
+        expect(callCount).toBe(2);
+    });
+    it('should trip circuit breaker on 429 and skip location', async () => {
+        const locationToFail = 'cb-fail';
+        const locationToSuccess = 'cb-success';
+        const locations = [locationToFail, locationToSuccess];
+        ai = genkit({
+            plugins: [
+                vertexAiMultiLocation({
+                    locations,
+                    circuitBreakerProvider: cbProvider,
+                    logger,
+                    circuitBreakerConfig: { resetTimeout: 1000000 },
+                }),
+            ],
+        });
+        ai.defineModel({
+            name: 'vertexai/gemini-2.5-flash',
+        }, async (request) => {
+            if (request.config?.location === locationToFail) {
+                throw new GenkitError({ status: 'RESOURCE_EXHAUSTED', message: 'Rate limit' });
+            }
+            return {
+                message: {
+                    role: 'model',
+                    content: [{ text: `success from ${request.config?.location}` }],
+                },
+            };
+        });
+        // First call to trip the breaker for 'locationToFail'
+        const response1 = await ai.generate({
+            model: 'vertexai-multi-location/gemini-2.5-flash',
+            prompt: 'test',
+        });
+        expect(response1.text).toBe('success from cb-success');
+        const cb = cbProvider.provide(`genkit:vertex-ai:location:${locationToFail}`, { threshold: 1, resetTimeout: 1000000 });
+        const status = await cb.check();
+        expect(status.state).toBe(CircuitBreakerState.Open);
+        expect(status.allowed).toBe(false);
+        // Second call should skip 'locationToFail' automatically
+        const response2 = await ai.generate({
+            model: 'vertexai-multi-location/gemini-2.5-flash',
+            prompt: 'test',
+        });
+        expect(response2.text).toBe('success from cb-success');
+    });
+});

package/ai/genkit/types.d.ts

@@ -0,0 +1,10 @@
+import type { CircuitBreakerConfig } from '../../circuit-breaker/circuit-breaker.js';
+export interface VertexAiMultiLocationOptions {
+    /** The Google Cloud locations to use for routing. */
+    locations: string[];
+    /**
+     * Optional circuit breaker configuration.
+     * By default, a threshold of 1 is used for 429 errors.
+     */
+    circuitBreakerConfig?: Partial<CircuitBreakerConfig>;
+}

package/ai/genkit/types.js

@@ -0,0 +1 @@
+export {};

package/authentication/tests/authentication.api-controller.test.js

@@ -1,4 +1,4 @@
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from 'vitest';
+import { afterAll, beforeAll, beforeEach, describe, expect, test, vi } from 'vitest';
 import { AuthenticationClientService } from '../../authentication/client/index.js';
 import { AuthenticationAncillaryService, AuthenticationService as AuthenticationServerService } from '../../authentication/server/index.js';
 import { HttpClientOptions } from '../../http/client/index.js';
@@ -17,6 +17,13 @@ describe('AuthenticationApiController Integration', () => {
     const schema = 'authentication';
     const tenantId = crypto.randomUUID();
     beforeAll(async () => {
+        const storage = new Map();
+        globalThis.localStorage = {
+            getItem: vi.fn((key) => storage.get(key) ?? null),
+            setItem: vi.fn((key, value) => storage.set(key, value)),
+            removeItem: vi.fn((key) => storage.delete(key)),
+            clear: vi.fn(() => storage.clear()),
+        };
         ({ injector, database } = await setupIntegrationTest({
             modules: { authentication: true, audit: true, keyValueStore: true, test: true, api: true, webServer: true },
             authenticationAncillaryService: DefaultAuthenticationAncillaryService,
@@ -36,6 +43,7 @@ describe('AuthenticationApiController Integration', () => {
         await injector?.dispose();
     });
     beforeEach(async () => {
+        globalThis.localStorage?.clear();
         await clearTenantData(database, schema, ['credentials', 'session', 'user', 'service_account', 'system_account', 'subject'], tenantId);
     });
     test('login should work via API client', async () => {

package/authentication/tests/authentication.client-service.test.js

@@ -1,4 +1,4 @@
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from 'vitest';
+import { afterAll, beforeAll, beforeEach, describe, expect, test, vi } from 'vitest';
 import { AuthenticationClientService } from '../../authentication/client/index.js';
 import { AuthenticationService as AuthenticationServerService } from '../../authentication/server/index.js';
 import { HttpClientOptions } from '../../http/client/index.js';
@@ -17,6 +17,13 @@ describe('AuthenticationClientService Integration', () => {
     const schema = 'authentication';
     const tenantId = crypto.randomUUID();
     beforeAll(async () => {
+        const storage = new Map();
+        globalThis.localStorage = {
+            getItem: vi.fn((key) => storage.get(key) ?? null),
+            setItem: vi.fn((key, value) => storage.set(key, value)),
+            removeItem: vi.fn((key) => storage.delete(key)),
+            clear: vi.fn(() => storage.clear()),
+        };
         ({ injector, database } = await setupIntegrationTest({
             modules: { authentication: true, audit: true, keyValueStore: true, test: true, api: true, webServer: true },
             authenticationAncillaryService: DefaultAuthenticationAncillaryService,
@@ -36,6 +43,7 @@ describe('AuthenticationClientService Integration', () => {
         await injector?.dispose();
     });
     beforeEach(async () => {
+        globalThis.localStorage?.clear();
         await clearTenantData(database, schema, ['credentials', 'session', 'user', 'service_account', 'system_account', 'subject'], tenantId);
     });
     test('login and logout should work', async () => {

package/logger/formatters/pretty-print.js

@@ -4,10 +4,10 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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 { formatError } from '../../errors/index.js';
 import { Singleton } from '../../injector/decorators.js';
 import { supportsColoredStdout } from '../../supports.js';
 import { enumValueName } from '../../utils/enum.js';
-import { formatError } from '../../errors/index.js';
 import { objectKeys } from '../../utils/object/object.js';
 import { isNotNullOrUndefined } from '../../utils/type-guards.js';
 import { LogFormatter } from '../formatter.js';

package/orm/sqls/sqls.d.ts

@@ -4,7 +4,7 @@
  * simplifying common SQL operations like generating UUIDs, working with intervals,
  * and aggregating data.
  */
-import { Column, type AnyColumn, type SQL, type SQLChunk } from 'drizzle-orm';
+import { Column, SQL, type AnyColumn, type SQLChunk, type SQLWrapper } from 'drizzle-orm';
 import type { GetSelectTableSelection, SelectResultField, TableLike } from 'drizzle-orm/query-builders/select.types';
 import type { EnumerationObject, EnumerationValue, Record } from '../../types/types.js';
 import { type PgEnumFromEnumeration } from '../enums.js';
@@ -155,12 +155,12 @@ export declare namespace jsonAgg {
 export declare function coalesce<T extends (Column | SQL | SQL.Aliased)[]>(...columns: T): SQL<SelectResultField<T>[number]>;
 /**
  * Creates a PostgreSQL `to_jsonb` function call.
- * Converts the input column or SQL expression to a JSONB value.
- * @template T - The Drizzle column or SQL expression type.
- * @param column - The column or SQL expression to convert.
+ * Converts the input SQL expression to a JSONB value.
+ * @template T - The value type.
+ * @param value - The value to convert.
  * @returns A Drizzle SQL object representing the value as JSONB.
  */
-export declare function toJsonb<T extends (Column | SQL | SQL.Aliased)>(column: T): SQL<SelectResultField<T>>;
+export declare function toJsonb<T extends SQLWrapper>(value: T): SQL<SelectResultField<T>>;
 /**
  * Creates a PostgreSQL `num_nulls` function call.
  * Counts the number of null arguments.

package/orm/sqls/sqls.js

@@ -4,13 +4,27 @@
  * simplifying common SQL operations like generating UUIDs, working with intervals,
  * and aggregating data.
  */
-import { and, Column, eq, isSQLWrapper, sql, isNotNull as sqlIsNotNull, isNull as sqlIsNull, Table } from 'drizzle-orm';
+import { and, Column, eq, isSQLWrapper, sql, SQL, isNotNull as sqlIsNotNull, isNull as sqlIsNull, Table } from 'drizzle-orm';
 import { match, P } from 'ts-pattern';
 import { distinct, toArray } from '../../utils/array/array.js';
 import { objectEntries, objectValues } from '../../utils/object/object.js';
 import { assertDefined, isArray, isBoolean, isDefined, isInstanceOf, isNotNull, isNull, isNullOrUndefined, isNumber, isObject, isString } from '../../utils/type-guards.js';
 import { getEnumName } from '../enums.js';
 import { caseWhen } from './case-when.js';
+const isJsonbSymbol = Symbol('isJsonb');
+function markAsJsonb(value) {
+    value[isJsonbSymbol] = true;
+    return value;
+}
+function isJsonb(value) {
+    if (value?.[isJsonbSymbol] == true) {
+        return true;
+    }
+    if (isInstanceOf(value, Column) && (value.getSQLType() === 'jsonb')) {
+        return true;
+    }
+    return false;
+}
 export const simpleJsonKeyPattern = /^[a-zA-Z0-9_-]+$/u;
 /** Drizzle SQL helper for getting the current transaction's timestamp. Returns a Date object. */
 export const TRANSACTION_TIMESTAMP = sql `transaction_timestamp()`;
@@ -171,13 +185,16 @@ export function coalesce(...columns) {
 }
 /**
  * Creates a PostgreSQL `to_jsonb` function call.
- * Converts the input column or SQL expression to a JSONB value.
- * @template T - The Drizzle column or SQL expression type.
- * @param column - The column or SQL expression to convert.
+ * Converts the input SQL expression to a JSONB value.
+ * @template T - The value type.
+ * @param value - The value to convert.
  * @returns A Drizzle SQL object representing the value as JSONB.
  */
-export function toJsonb(column) {
-    return sql `to_jsonb(${column})`;
+export function toJsonb(value) {
+    if (isJsonb(value)) {
+        return value.getSQL();
+    }
+    return markAsJsonb(sql `to_jsonb(${value})`);
 }
 /**
  * Creates a PostgreSQL `num_nulls` function call.
@@ -395,9 +412,9 @@ export function jsonbBuildObject(properties) {
         }
     }
     if (chunks.length == 0) {
-        return sql `'{}'::jsonb`;
+        return markAsJsonb(sql `'{}'::jsonb`);
     }
-    return sql `jsonb_build_object(${sql.join(chunks, sql `, `)})`;
+    return markAsJsonb(sql `jsonb_build_object(${sql.join(chunks, sql `, `)})`);
 }
 /**
  * A recursive utility to build PostgreSQL JSONB from TS structures.
@@ -405,20 +422,20 @@ export function jsonbBuildObject(properties) {
  */
 export function buildJsonb(value) {
     if (isSQLWrapper(value)) {
-        return sql `to_jsonb(${value})`;
+        return toJsonb(value);
     }
     if (isNullOrUndefined(value)) {
-        return sql `'null'::jsonb`;
+        return markAsJsonb(sql `'null'::jsonb`);
     }
     if (isArray(value)) {
         if (value.length == 0) {
-            return sql `'[]'::jsonb`;
+            return markAsJsonb(sql `'[]'::jsonb`);
         }
         const elements = value.map((inner) => buildJsonb(inner));
-        return sql `jsonb_build_array(${sql.join(elements, sql `, `)})`;
+        return markAsJsonb(sql `jsonb_build_array(${sql.join(elements, sql `, `)})`);
     }
     if (isObject(value)) {
         return jsonbBuildObject(value);
     }
-    return sql `${JSON.stringify(value)}::jsonb`;
+    return markAsJsonb(sql `${JSON.stringify(value)}::jsonb`);
 }

package/orm/tests/query-converter-complex.test.js

@@ -68,7 +68,7 @@ describe('ORM Query Converter Complex', () => {
         const condition = convertQuery(q, table, colMap);
         const sqlStr = dialect.sqlToQuery(condition).sql;
         // Tokenizer is supported via JSON object syntax
-        expect(sqlStr).toContain('"test"."complex_items"."name" @@@ jsonb_build_object(\'match\', jsonb_build_object(\'value\', $1, \'tokenizer\', jsonb_build_object(\'type\', $2, \'min_gram\', $3, \'max_gram\', $4)))::pdb.query');
+        expect(sqlStr).toContain('"test"."complex_items"."name" @@@ jsonb_build_object(\'match\', jsonb_build_object(\'value\', $1::jsonb, \'tokenizer\', jsonb_build_object(\'type\', $2::jsonb, \'min_gram\', $3::jsonb, \'max_gram\', $4::jsonb)))::pdb.query');
     });
     test('should handle ParadeDB $parade range', () => {
         const q = {
@@ -84,7 +84,7 @@ describe('ORM Query Converter Complex', () => {
         const condition = convertQuery(q, table, colMap);
         const sqlStr = dialect.sqlToQuery(condition).sql;
         // This should fall back to convertParadeComparisonQuery with recursive jsonb build
-        expect(sqlStr).toContain('"test"."complex_items"."value" @@@ jsonb_build_object(\'range\', jsonb_build_object(\'lower_bound\', jsonb_build_object(\'included\', $1), \'upper_bound\', jsonb_build_object(\'excluded\', $2)))::pdb.query');
+        expect(sqlStr).toContain('"test"."complex_items"."value" @@@ jsonb_build_object(\'range\', jsonb_build_object(\'lower_bound\', jsonb_build_object(\'included\', $1::jsonb), \'upper_bound\', jsonb_build_object(\'excluded\', $2::jsonb)))::pdb.query');
     });
     test('should handle ParadeDB $parade phrasePrefix', () => {
         const q = {
@@ -96,7 +96,7 @@ describe('ORM Query Converter Complex', () => {
         };
         const condition = convertQuery(q, table, colMap);
         const sqlStr = dialect.sqlToQuery(condition).sql;
-        expect(sqlStr).toContain('"test"."complex_items"."name" @@@ jsonb_build_object(\'phrase_prefix\', jsonb_build_object(\'phrases\', jsonb_build_array($1, $2), \'max_expansions\', $3))::pdb.query');
+        expect(sqlStr).toContain('"test"."complex_items"."name" @@@ jsonb_build_object(\'phrase_prefix\', jsonb_build_object(\'phrases\', jsonb_build_array($1::jsonb, $2::jsonb), \'max_expansions\', $3::jsonb))::pdb.query');
     });
     test('should handle ParadeDB $parade regexPhrase', () => {
         const q = {
@@ -108,7 +108,7 @@ describe('ORM Query Converter Complex', () => {
         };
         const condition = convertQuery(q, table, colMap);
         const sqlStr = dialect.sqlToQuery(condition).sql;
-        expect(sqlStr).toContain('"test"."complex_items"."name" @@@ jsonb_build_object(\'regex_phrase\', jsonb_build_object(\'regexes\', jsonb_build_array($1, $2), \'slop\', $3))::pdb.query');
+        expect(sqlStr).toContain('"test"."complex_items"."name" @@@ jsonb_build_object(\'regex_phrase\', jsonb_build_object(\'regexes\', jsonb_build_array($1::jsonb, $2::jsonb), \'slop\', $3::jsonb))::pdb.query');
     });
     test('should handle ParadeDB top-level moreLikeThis', () => {
         const q = {
@@ -121,6 +121,6 @@ describe('ORM Query Converter Complex', () => {
         };
         const condition = convertQuery(q, table, colMap);
         const sqlStr = dialect.sqlToQuery(condition).sql;
-        expect(sqlStr).toContain('"test"."complex_items"."id" @@@ jsonb_build_object(\'more_like_this\', jsonb_build_object(\'key_value\', $1, \'fields\', ARRAY[$2, $3]))::pdb.query');
+        expect(sqlStr).toContain('"test"."complex_items"."id" @@@ jsonb_build_object(\'more_like_this\', jsonb_build_object(\'key_value\', $1::jsonb, \'fields\', to_jsonb(ARRAY[$2, $3])))::pdb.query');
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.110",
+  "version": "0.93.112",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -153,7 +153,7 @@
   "peerDependencies": {
     "@genkit-ai/google-genai": "^1.28",
     "@google-cloud/storage": "^7.18",
-    "@google/genai": "^1.39",
+    "@google/genai": "^1.40",
     "@toon-format/toon": "^2.1.0",
     "@tstdl/angular": "^0.93",
     "@zxcvbn-ts/core": "^3.0",

package/task-queue/task-queue.js

@@ -79,7 +79,7 @@ export const defaultQueueConfig = {
 };
 export class TaskQueue extends Transactional {
     config = this.transactionalContextData ?? (() => { const arg = injectArgument(this); return isString(arg) ? { namespace: arg } : arg; })();
-    logger = inject(Logger, `TaskQueue:${this.config.namespace}`);
+    logger = inject(Logger, TaskQueue.name).with({ namespace: this.config.namespace });
     batch() {
         return new TaskQueueEnqueueBatch(this);
     }

package/test1.js

@@ -1,20 +1,16 @@
 import './polyfills.js';
-import { AiService } from './ai/ai.service.js';
-import { configureAiService } from './ai/module.js';
+import { z } from 'genkit';
+import { convertToGenkitSchema } from './ai/genkit/helpers.js';
+import { configureGenkit, injectGenkit, injectMultiLocationModel } from './ai/genkit/module.js';
 import { Application, provideInitializer, provideModule, provideSignalHandler } from './application/index.js';
-import { migrateAuditSchema } from './audit/index.js';
-import { configureAuthenticationServer } from './authentication/server/module.js';
+import { configurePostgresCircuitBreaker, migratePostgresCircuitBreaker } from './circuit-breaker/postgres/module.js';
 import { inject, Injector, runInInjectionContext } from './injector/index.js';
-import { configurePostgresKeyValueStore, migratePostgresKeyValueStoreSchema } from './key-value-store/postgres/module.js';
-import { configurePostgresLock, migratePostgresLockSchema } from './lock/postgres/index.js';
 import { PrettyPrintLogFormatter, provideConsoleLogTransport } from './logger/index.js';
-import { configureOrm, injectRepository } from './orm/server/index.js';
-import { configurePostgresTaskQueue, migratePostgresTaskQueueSchema } from './task-queue/postgres/index.js';
-import { migrateTestSchema } from './test/module.js';
-import { Test, testData } from './test/test.model.js';
-import { timedBenchmarkAsync } from './utils/benchmark.js';
+import { configureOrm } from './orm/server/index.js';
+import { object, string } from './schema/index.js';
+import { configurePostgresTaskQueue, migratePostgresTaskQueueSchema } from './task-queue/postgres/module.js';
 import * as configParser from './utils/config-parser.js';
-import { string } from './utils/config-parser.js';
+import { assert } from './utils/type-guards.js';
 const config = {
     database: {
         host: configParser.string('DATABASE_HOST', '127.0.0.1'),
@@ -24,74 +20,95 @@ const config = {
         database: configParser.string('DATABASE_NAME', 'tstdl'),
     },
     ai: {
-        apiKey: string('AI_API_KEY', undefined),
-        keyFile: string('AI_API_KEY_FILE', undefined),
+        keyFile: configParser.string('AI_API_KEY_FILE', undefined),
         vertex: {
-            project: string('AI_VERTEX_PROJECT', undefined),
-            location: string('AI_VERTEX_LOCATION', undefined),
+            project: configParser.string('AI_VERTEX_PROJECT', undefined),
+            location: configParser.string('AI_VERTEX_LOCATION', undefined),
+            bucket: configParser.string('AI_VERTEX_BUCKET', undefined),
         },
     },
 };
 async function bootstrap() {
     const injector = inject(Injector);
-    configureAiService({
+    assert(config.ai.vertex.location?.startsWith('europe') == true, 'AI vertex location must be in europe for data protection reasons');
+    configureGenkit({
         vertex: {
-            project: '922353391551', // insolytics-application
+            projectId: '922353391551', // insolytics-application
             location: 'europe-west4', // netherlands
+            // keyFile: '/home/patrick/.environments/insolytix-application-service-key.json',
+        },
+        multiLocationVertex: {
+            locations: [
+                'europe-west4',
+                'europe-west9',
+            ],
         },
-        keyFile: '/home/patrick/.secret-files/insolytic-application-service-key.json',
     });
-    /*
     configureOrm({
-      repositoryConfig: {
-        schema: 'test',
-      },
-      connection: {
-        host: config.database.host,
-        port: config.database.port,
-        user: config.database.user,
-        password: config.database.pass,
-        database: config.database.database,
-      },
-    });
-  
-    configureAuthenticationServer({
-      serviceOptions: {
-        secret: '6fze56uz5e6ufrtzufrtu',
-      },
+        repositoryConfig: {
+            schema: 'test',
+        },
+        connection: {
+            host: config.database.host,
+            port: config.database.port,
+            user: config.database.user,
+            password: config.database.pass,
+            database: config.database.database,
+        },
     });
-  
-    configurePostgresLock();
-    configurePostgresQueue();
-    configurePostgresKeyValueStore();
-  
-    await runInInjectionContext(injector, migratePostgresKeyValueStoreSchema);
-    await runInInjectionContext(injector, migratePostgresLockSchema);
-    await runInInjectionContext(injector, migratePostgresQueueSchema);
-    await runInInjectionContext(injector, migrateAuditSchema);
-    await runInInjectionContext(injector, migrateTestSchema);
-    */
+    configurePostgresCircuitBreaker();
+    configurePostgresTaskQueue();
+    await runInInjectionContext(injector, migratePostgresCircuitBreaker);
+    await runInInjectionContext(injector, migratePostgresTaskQueueSchema);
 }
 async function main(_cancellationSignal) {
-    const aiService = inject(AiService);
-    const aiStream = aiService.generateStream({
-        generationOptions: {
-            includeThoughts: true,
-            thinkingBudget: 1000,
+    const genkit = injectGenkit();
+    const model = injectMultiLocationModel('gemini-2.5-flash');
+    console.log('--- TEST 1: Simple Generation ---');
+    const response1 = await genkit.generate({
+        model,
+        prompt: 'Say hello in one word.',
+    });
+    console.log('Response:', response1.text);
+    console.log('\n--- TEST 2: Structured Output ---');
+    const response2 = await genkit.generate({
+        model,
+        prompt: 'Generate a greeting.',
+        output: {
+            schema: convertToGenkitSchema(object({
+                greeting: string(),
+            })),
         },
-        model: 'gemini-2.5-flash-lite',
-        contents: [{
-                role: 'user',
-                parts: [
-                    { text: 'Count from 1 to 1000. List *every* number.' },
-                ],
-            }],
     });
-    for await (const { text, usage } of aiStream) {
-        console.log({ text, usage });
+    console.log('Response:', JSON.stringify(response2.output));
+    console.log('\n--- TEST 3: Streaming ---');
+    const { response: response3Promise, stream } = genkit.generateStream({
+        model,
+        prompt: 'Write a very short poem about the ocean (max 20 words).',
+    });
+    process.stdout.write('Stream: ');
+    for await (const chunk of stream) {
+        process.stdout.write(chunk.text);
     }
-    if (1 + 1 == 2)
-        process.exit(0);
+    process.stdout.write('\n');
+    const response3 = await response3Promise;
+    console.log('Final Response length:', response3.text.length);
+    console.log('\n--- TEST 4: Tools ---');
+    const getWeather = genkit.defineTool({
+        name: 'getWeather',
+        description: 'Gets the weather for a location.',
+        inputSchema: z.object({ location: z.string() }),
+        outputSchema: z.object({ weather: z.string() }),
+    }, async (input) => {
+        console.log(`  [Tool] getWeather called for ${input.location}`);
+        return { weather: `Sunny in ${input.location}` };
+    });
+    const response4 = await genkit.generate({
+        model,
+        prompt: 'What is the weather in Berlin?',
+        tools: [getWeather],
+    });
+    console.log('Response:', response4.text);
 }
 Application.run('Test', [
     provideInitializer(bootstrap),

package/typst/render.d.ts

@@ -20,4 +20,4 @@ export type TypstRenderOptions = {
  * @param source
  * @param options
  */
-export declare function renderTypst(source: string, options?: TypstRenderOptions): Promise<Uint8Array>;
+export declare function renderTypst(source: string, options?: TypstRenderOptions): Promise<Uint8Array<ArrayBuffer>>;