@tstdl/base 0.93.111 → 0.93.112

package/ai/genkit/module.js

@@ -43,7 +43,6 @@ export function injectGenkit(options) {
         : null;
     const multiLocationVertexPlugin = isDefined(moduleOptions.multiLocationVertex)
         ? vertexAiMultiLocation({
-            modelNames: moduleOptions.multiLocationVertex.modelNames,
             locations: moduleOptions.multiLocationVertex.locations,
             circuitBreakerProvider: inject(CircuitBreakerProvider),
             logger: inject(Logger, 'VertexAiMultiRegion'),

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

@@ -1,6 +1,7 @@
 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>;
@@ -413,7 +414,6 @@ declare const geminiModelReference: import("genkit").ModelReference<import("zod"
         thinkingLevel: import("zod").ZodOptional<import("zod").ZodEnum<["MINIMAL", "LOW", "MEDIUM", "HIGH"]>>;
     }, import("zod").ZodTypeAny, "passthrough">>>;
 }, import("zod").ZodTypeAny, "passthrough">>>;
-export type GeminiModelReference = typeof geminiModelReference;
 export declare function vertexAiMultiLocation(options: VertexAiMultiLocationOptions & {
     circuitBreakerProvider: CircuitBreakerProvider;
     logger: Logger;

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

@@ -1,67 +1,82 @@
 import { vertexAI } from '@genkit-ai/google-genai';
 import { GenkitError, modelRef } from 'genkit';
 import { genkitPlugin } from 'genkit/plugin';
-import { shuffle, toArray } from '../../utils/array/index.js';
-import { isInstanceOf } from '../../utils/type-guards.js';
+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) {
-    return genkitPlugin('vertexai-multi-location', (ai) => {
-        const modelNames = toArray(options.modelNames);
-        for (const modelName of modelNames) {
-            ai.defineModel({
-                name: `vertexai-multi-location/${modelName}`,
-                versions: geminiModelReference.info?.versions,
-                supports: geminiModelReference.info?.supports,
-                configSchema: geminiModelReference.configSchema,
-                label: `${geminiModelReference.info?.label} (Multi-Location Routing)`,
-            }, async (request) => {
-                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 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,
                     });
-                    const check = await circuitBreaker.check();
-                    if (!check.allowed) {
-                        options.logger.warn(`Location ${location} is currently unhealthy. Skipping...`);
-                        continue;
-                    }
-                    try {
-                        const result = await ai.generate({
-                            model: `vertexai/${modelName}`,
-                            ...request,
-                            config: {
-                                ...request.config,
-                                location: location,
-                            },
-                        });
-                        await circuitBreaker.recordSuccess();
-                        return result;
+                    await circuitBreaker.recordSuccess();
+                    return result;
+                }
+                catch (error) {
+                    lastError = error;
+                    if (!isInstanceOf(error, GenkitError)) {
+                        throw error;
                     }
-                    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();
+                    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;
-            });
+            }
+            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: `vertexai-multi-location/${baseModel.name.replace('vertexai/', '')}`,
+        name: `${pluginKey}/${baseModel.name.replace('vertexai/', '')}`,
         configSchema: baseModel.configSchema,
         info: baseModel.info,
         version: baseModel.version,

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

@@ -33,7 +33,6 @@ describe('Genkit vertexai-multi-location Plugin Tests', () => {
         ai = genkit({
             plugins: [
                 vertexAiMultiLocation({
-                    modelNames: 'gemini-2.5-flash',
                     locations: ['region-1', 'region-2'],
                     circuitBreakerProvider: cbProvider,
                     logger,
@@ -99,7 +98,6 @@ describe('Genkit vertexai-multi-location Plugin Tests', () => {
         ai = genkit({
             plugins: [
                 vertexAiMultiLocation({
-                    modelNames: 'gemini-2.5-flash',
                     locations,
                     circuitBreakerProvider: cbProvider,
                     logger,

package/ai/genkit/types.d.ts

@@ -1,7 +1,5 @@
 import type { CircuitBreakerConfig } from '../../circuit-breaker/circuit-breaker.js';
 export interface VertexAiMultiLocationOptions {
-    /** The model name(s) to be virtualized (e.g., 'gemini-2.5-flash'). */
-    modelNames: string | string[];
     /** The Google Cloud locations to use for routing. */
     locations: string[];
     /**

package/package.json

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

package/test1.js

@@ -1,14 +1,15 @@
 import './polyfills.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 { configurePostgresCircuitBreaker, migratePostgresCircuitBreaker } from './circuit-breaker/postgres/module.js';
 import { inject, Injector, runInInjectionContext } from './injector/index.js';
 import { PrettyPrintLogFormatter, provideConsoleLogTransport } from './logger/index.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 { createArray } from './utils/array/array.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: {
@@ -19,11 +20,11 @@ const config = {
         database: configParser.string('DATABASE_NAME', 'tstdl'),
     },
     ai: {
-        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),
-            bucket: string('AI_VERTEX_BUCKET', undefined),
+            project: configParser.string('AI_VERTEX_PROJECT', undefined),
+            location: configParser.string('AI_VERTEX_LOCATION', undefined),
+            bucket: configParser.string('AI_VERTEX_BUCKET', undefined),
         },
     },
 };
@@ -37,18 +38,9 @@ async function bootstrap() {
             // keyFile: '/home/patrick/.environments/insolytix-application-service-key.json',
         },
         multiLocationVertex: {
-            modelNames: ['gemini-2.5-flash'],
             locations: [
                 'europe-west4',
                 'europe-west9',
-                // 'europe-west3',
-                // 'europe-west1',
-                // 'europe-southwest1',
-                // 'europe-west8',
-                // 'europe-north1',
-                // 'europe-central2',
-                // 'europe-west2', // UK - not EU
-                // 'europe-west6', // Switzerland - not EU
             ],
         },
     });
@@ -72,14 +64,51 @@ async function bootstrap() {
 async function main(_cancellationSignal) {
     const genkit = injectGenkit();
     const model = injectMultiLocationModel('gemini-2.5-flash');
-    const promises = createArray(1000, async () => await genkit.generate({
+    console.log('--- TEST 1: Simple Generation ---');
+    const response1 = await genkit.generate({
         model,
-        prompt: 'Hello, world!',
-    }));
-    const responses = await Promise.all(promises);
-    for (const response of responses) {
-        console.log(response.text);
+        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(),
+            })),
+        },
+    });
+    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);
     }
+    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),