refactor(js/prompts): changed executable-prompt action return type to GenerateActionOptions (#2845)

Author: pavelgj

js/ai/src/generate.ts

@@ -332,79 +332,90 @@ export async function generate<
   const resolvedOptions: GenerateOptions<O, CustomOptions> = {
     ...(await Promise.resolve(options)),
   };
-  const resolvedModel = await resolveModel(registry, resolvedOptions.model);
+  const resolvedFormat = await resolveFormat(registry, resolvedOptions.output);
+
+  const params = await toGenerateActionOptions(registry, resolvedOptions);
 
   const tools = await toolsToActionRefs(registry, resolvedOptions.tools);
+  return await runWithStreamingCallback(
+    registry,
+    stripNoop(resolvedOptions.onChunk ?? resolvedOptions.streamingCallback),
+    async () => {
+      const response = await runWithContext(
+        registry,
+        resolvedOptions.context,
+        () =>
+          generateHelper(registry, {
+            rawRequest: params,
+            middleware: resolvedOptions.use,
+          })
+      );
+      const request = await toGenerateRequest(registry, {
+        ...resolvedOptions,
+        tools,
+      });
+      return new GenerateResponse<O>(response, {
+        request: response.request ?? request,
+        parser: resolvedFormat?.handler(request.output?.schema).parseMessage,
+      });
+    }
+  );
+}
 
-  const messages: MessageData[] = messagesFromOptions(resolvedOptions);
+export async function toGenerateActionOptions<
+  O extends z.ZodTypeAny = z.ZodTypeAny,
+  CustomOptions extends z.ZodTypeAny = typeof GenerationCommonConfigSchema,
+>(
+  registry: Registry,
+  options: GenerateOptions<O, CustomOptions>
+): Promise<GenerateActionOptions> {
+  const resolvedModel = await resolveModel(registry, options.model);
+  const tools = await toolsToActionRefs(registry, options.tools);
+  const messages: MessageData[] = messagesFromOptions(options);
 
   const resolvedSchema = toJsonSchema({
-    schema: resolvedOptions.output?.schema,
-    jsonSchema: resolvedOptions.output?.jsonSchema,
+    schema: options.output?.schema,
+    jsonSchema: options.output?.jsonSchema,
   });
 
   // If is schema is set but format is not explicitly set, default to `json` format.
   if (
-    (resolvedOptions.output?.schema || resolvedOptions.output?.jsonSchema) &&
-    !resolvedOptions.output?.format
+    (options.output?.schema || options.output?.jsonSchema) &&
+    !options.output?.format
   ) {
-    resolvedOptions.output.format = 'json';
+    options.output.format = 'json';
   }
-  const resolvedFormat = await resolveFormat(registry, resolvedOptions.output);
 
   const params: GenerateActionOptions = {
     model: resolvedModel.modelAction.__action.name,
-    docs: resolvedOptions.docs,
+    docs: options.docs,
     messages: messages,
     tools,
-    toolChoice: resolvedOptions.toolChoice,
+    toolChoice: options.toolChoice,
     config: {
       version: resolvedModel.version,
       ...stripUndefinedOptions(resolvedModel.config),
-      ...stripUndefinedOptions(resolvedOptions.config),
+      ...stripUndefinedOptions(options.config),
     },
-    output: resolvedOptions.output && {
-      ...resolvedOptions.output,
-      format: resolvedOptions.output.format,
+    output: options.output && {
+      ...options.output,
+      format: options.output.format,
       jsonSchema: resolvedSchema,
     },
     // coerce reply and restart into arrays for the action schema
-    resume: resolvedOptions.resume && {
-      respond: [resolvedOptions.resume.respond || []].flat(),
-      restart: [resolvedOptions.resume.restart || []].flat(),
-      metadata: resolvedOptions.resume.metadata,
+    resume: options.resume && {
+      respond: [options.resume.respond || []].flat(),
+      restart: [options.resume.restart || []].flat(),
+      metadata: options.resume.metadata,
     },
-    returnToolRequests: resolvedOptions.returnToolRequests,
-    maxTurns: resolvedOptions.maxTurns,
+    returnToolRequests: options.returnToolRequests,
+    maxTurns: options.maxTurns,
   };
   // if config is empty and it was not explicitly passed in, we delete it, don't want {}
-  if (Object.keys(params.config).length === 0 && !resolvedOptions.config) {
+  if (Object.keys(params.config).length === 0 && !options.config) {
     delete params.config;
   }
-
-  return await runWithStreamingCallback(
-    registry,
-    stripNoop(resolvedOptions.onChunk ?? resolvedOptions.streamingCallback),
-    async () => {
-      const response = await runWithContext(
-        registry,
-        resolvedOptions.context,
-        () =>
-          generateHelper(registry, {
-            rawRequest: params,
-            middleware: resolvedOptions.use,
-          })
-      );
-      const request = await toGenerateRequest(registry, {
-        ...resolvedOptions,
-        tools,
-      });
-      return new GenerateResponse<O>(response, {
-        request: response.request ?? request,
-        parser: resolvedFormat?.handler(request.output?.schema).parseMessage,
-      });
-    }
-  );
+  return params;
 }
 
 /**

js/ai/src/prompt.ts

@@ -40,11 +40,14 @@ import {
   generateStream,
   GenerateStreamResponse,
   OutputOptions,
+  toGenerateActionOptions,
   toGenerateRequest,
   ToolChoice,
 } from './generate.js';
 import { Message } from './message.js';
 import {
+  GenerateActionOptions,
+  GenerateActionOptionsSchema,
   GenerateRequest,
   GenerateRequestSchema,
   GenerateResponseChunkSchema,
@@ -355,17 +358,15 @@ function definePromptAsync<
         name: `${options.name}${options.variant ? `.${options.variant}` : ''}`,
         inputJsonSchema: options.input?.jsonSchema,
         inputSchema: options.input?.schema,
+        outputSchema: GenerateActionOptionsSchema,
         description: options.description,
         actionType: 'executable-prompt',
         metadata,
-        fn: async (
-          input: z.infer<I>,
-          { sendChunk }
-        ): Promise<GenerateResponse> => {
-          return await generate(registry, {
-            ...(await renderOptionsFn(input, undefined)),
-            onChunk: sendChunk,
-          });
+        fn: async (input: z.infer<I>): Promise<GenerateActionOptions> => {
+          return await toGenerateActionOptions(
+            registry,
+            await renderOptionsFn(input, undefined)
+          );
         },
       } as ActionAsyncParams<any, any, any>;
     })

js/genkit/tests/prompts_test.ts

@@ -1118,6 +1118,81 @@ describe('prompt', () => {
     });
   });
 
+  it('renders loaded prompt via executable-prompt', async () => {
+    ai.defineModel(
+      { name: 'googleai/gemini-5.0-ultimate-pro-plus' },
+      async () => ({})
+    );
+
+    ai.defineTool(
+      {
+        name: 'toolA',
+        description: 'toolA it is',
+      },
+      async () => {}
+    );
+
+    ai.defineTool(
+      {
+        name: 'toolB',
+        description: 'toolB it is',
+      },
+      async () => {}
+    );
+
+    const generateActionOptions = await (
+      await ai.registry.lookupAction('/executable-prompt/kitchensink')
+    )({ subject: 'banana' });
+
+    assert.deepStrictEqual(stripUndefinedProps(generateActionOptions), {
+      config: {
+        temperature: 11,
+      },
+      model: 'googleai/gemini-5.0-ultimate-pro-plus',
+      maxTurns: 77,
+      messages: [
+        { role: 'system', content: [{ text: ' Hello ' }] },
+        { role: 'model', content: [{ text: ' from the prompt file banana' }] },
+      ],
+      output: {
+        format: 'csv',
+        jsonSchema: {
+          additionalProperties: false,
+          properties: {
+            arr: {
+              description: 'array of objects',
+              items: {
+                additionalProperties: false,
+                properties: {
+                  nest2: {
+                    type: ['boolean', 'null'],
+                  },
+                },
+                type: 'object',
+              },
+              type: 'array',
+            },
+            obj: {
+              additionalProperties: false,
+              description: 'a nested object',
+              properties: {
+                nest1: {
+                  type: ['string', 'null'],
+                },
+              },
+              type: ['object', 'null'],
+            },
+          },
+          required: ['arr'],
+          type: 'object',
+        },
+      },
+      returnToolRequests: true,
+      toolChoice: 'required',
+      tools: ['/tool/toolA', '/tool/toolB'],
+    });
+  });
+
   it('resolved schema refs', async () => {
     const prompt = ai.prompt('schemaRef');