refactor(js/plugins): switch to implicit namespacing of actions in v2 plugin api (#3436)

Author: pavelgj

js/core/src/background-action.ts

@@ -246,20 +246,24 @@ export function defineBackgroundAction<
 
 export function registerBackgroundAction(
   registry: Registry,
-  act: BackgroundAction<any, any>
+  act: BackgroundAction<any, any>,
+  opts?: { namespace?: string }
 ) {
   registry.registerAction(
     act.startAction.__action.actionType!,
-    act.startAction
+    act.startAction,
+    opts
   );
   registry.registerAction(
     act.checkAction.__action.actionType!,
-    act.checkAction
+    act.checkAction,
+    opts
   );
   if (act.cancelAction) {
     registry.registerAction(
       act.cancelAction.__action.actionType!,
-      act.cancelAction
+      act.cancelAction,
+      opts
     );
   }
 }

js/core/src/registry.ts

@@ -207,14 +207,21 @@ export class Registry {
    */
   registerAction<I extends z.ZodTypeAny, O extends z.ZodTypeAny>(
     type: ActionType,
-    action: Action<I, O>
+    action: Action<I, O>,
+    opts?: { namespace?: string }
   ) {
     if (type !== action.__action.actionType) {
       throw new GenkitError({
         status: 'INVALID_ARGUMENT',
         message: `action type (${type}) does not match type on action (${action.__action.actionType})`,
       });
     }
+    if (
+      opts?.namespace &&
+      !action.__action.name.startsWith(`${opts.namespace}/`)
+    ) {
+      action.__action.name = `${opts.namespace}/${action.__action.name}`;
+    }
     const key = `/${type}/${action.__action.name}`;
     logger.debug(`registering ${key}`);
     if (this.actionsById.hasOwnProperty(key)) {
@@ -236,8 +243,12 @@ export class Registry {
   registerActionAsync<I extends z.ZodTypeAny, O extends z.ZodTypeAny>(
     type: ActionType,
     name: string,
-    action: PromiseLike<Action<I, O>>
+    action: PromiseLike<Action<I, O>>,
+    opts?: { namespace?: string }
   ) {
+    if (opts?.namespace && !name.startsWith(`${opts.namespace}/`)) {
+      name = `${opts.namespace}/${name}`;
+    }
     const key = `/${type}/${name}`;
     logger.debug(`registering ${key} (async)`);
     if (this.actionsById.hasOwnProperty(key)) {

js/core/tests/registry_test.ts

@@ -407,6 +407,43 @@ describe('registry class', () => {
       );
     });
 
+    it('returns registered action with namespace', async () => {
+      const fooSomethingAction = action(
+        { name: 'foo_something', actionType: 'model' },
+        async () => null
+      );
+      registry.registerAction('model', fooSomethingAction, {
+        namespace: 'my-plugin',
+      });
+      const barSomethingAction = action(
+        { name: 'my-plugin/bar_something', actionType: 'model' },
+        async () => null
+      );
+      registry.registerAction('model', barSomethingAction, {
+        namespace: 'my-plugin',
+      });
+      const barSubSomethingAction = action(
+        { name: 'sub/bar_something', actionType: 'model' },
+        async () => null
+      );
+      registry.registerAction('model', barSubSomethingAction, {
+        namespace: 'my-plugin',
+      });
+
+      assert.strictEqual(
+        await registry.lookupAction('/model/my-plugin/foo_something'),
+        fooSomethingAction
+      );
+      assert.strictEqual(
+        await registry.lookupAction('/model/my-plugin/bar_something'),
+        barSomethingAction
+      );
+      assert.strictEqual(
+        await registry.lookupAction('/model/my-plugin/sub/bar_something'),
+        barSubSomethingAction
+      );
+    });
+
     it('returns action registered by plugin', async () => {
       registry.registerPluginProvider('foo', {
         name: 'foo',

js/genkit/src/genkit.ts

@@ -945,7 +945,11 @@ export class Genkit implements HasRegistry {
           },
           async listActions() {
             if (typeof plugin.list === 'function') {
-              return await plugin.list();
+              return (await plugin.list()).map((a) => ({
+                ...a,
+                // Apply namespace for v2 plugins.
+                name: `${plugin.name}/${a.name}`,
+              }));
             }
             return [];
           },
@@ -990,15 +994,21 @@ function registerActionV2(
   plugin: GenkitPluginV2
 ) {
   if (isBackgroundAction(resolvedAction)) {
-    registerBackgroundAction(registry, resolvedAction);
+    registerBackgroundAction(registry, resolvedAction, {
+      namespace: plugin.name,
+    });
   } else if (isAction(resolvedAction)) {
     if (!resolvedAction.__action.actionType) {
       throw new GenkitError({
         status: 'INVALID_ARGUMENT',
         message: 'Action type is missing for ' + resolvedAction.__action.name,
       });
     }
-    registry.registerAction(resolvedAction.__action.actionType, resolvedAction);
+    registry.registerAction(
+      resolvedAction.__action.actionType,
+      resolvedAction,
+      { namespace: plugin.name }
+    );
   } else {
     throw new GenkitError({
       status: 'INVALID_ARGUMENT',

js/genkit/tests/plugins_test.ts

@@ -70,20 +70,20 @@ const v2Plugin = genkitPluginV2({
   name: 'myV2Plugin',
   init() {
     return [
-      model({ name: 'myV2Plugin/model_eager' }, async () => {
+      model({ name: 'model_eager' }, async () => {
         return {};
       }),
     ];
   },
   resolve(actionType, name) {
     switch (actionType) {
       case 'model':
-        return model({ name: 'myV2Plugin/' + name }, async () => {
+        return model({ name }, async () => {
           return {};
         });
       case 'background-model':
         return backgroundModel({
-          name: 'myV2Plugin/' + name,
+          name,
           async start() {
             return { id: 'abc' };
           },
@@ -100,10 +100,10 @@ const v2Plugin = genkitPluginV2({
   list() {
     return [
       modelActionMetadata({
-        name: 'myV2Plugin/potential_model',
+        name: 'potential_model',
       }),
       embedderActionMetadata({
-        name: 'myV2Plugin/potential_embedder',
+        name: 'potential_embedder',
       }),
     ];
   },