Thanks for writing this up @MichaelDoyle!

Just adding some comments here to perhaps save others some time. There are a few questions raised inline too!

The following is a sample dotPrompt saved as weather.prompt

You'll see at the top of the file I have used it with gpt-4o and gemini.

It would be great if we could pull the list of available models literal name strings (e.g. "googleai/gemini-1.5-pro-latest") via the genKit api, ideally, across all LLM providers i.e. Ollama, OpenAI, Google, Grok etc? If not this is not possible via the api, then having them listed in Github in one place would be a good start.

---
# model: googleai/gemini-1.5-pro-latest
model: openai/gpt-4o
config:
  temperature: 0.6
# input:
  # schema:
    # type: object
    # properties:
      # cities:
        # type: array
        # items:
          # type: string
        # No 'required' keyword here, making it optional
output:
  format: text
tools:
  - getWeather
---

{{role "system"}}
Always try to be as efficient as possible, and request tool calls in batches.

{{role "user"}}
I really enjoy traveling to places where it's not too hot and not too cold. 

{{role "model"}}
Sure, I can help you with that. 

{{role "user"}}
Help me decide which is a better place to visit today based on the weather. 
I want to be outside as much as possible. Here are the cities I am considering: 
New York
London
Amsterdam

A small thing here to remember is to configureGenkit and not to forget the "apiVersion: 'v1beta'", otherwise, you'll get googleai/gemini-1.5-pro-latest not found.

import * as functions from 'firebase-functions';
import * as admin from 'firebase-admin';
admin.initializeApp();
import { dotprompt } from '@genkit-ai/dotprompt';
import { configureGenkit } from '@genkit-ai/core';
import { googleAI } from '@genkit-ai/googleai';
import {  openAI } from 'genkitx-openai';

configureGenkit({ plugins: [
                        dotprompt(), 
                        googleAI({ apiKey: '<YOUR_API_KEY>', apiVersion: 'v1beta' }),
                        openAI({ apiKey: '<YOUR_API_KEY>' })
                    ] });

The calling code

const weatherPrompt = await prompt('weather');       
promptResult =  await weatherPrompt.generate({});

I have tested this simple tool with Gemini and Gpt-4o

const getWeather = defineTool(
    {
      name: 'getWeather',
      description: 'Get the weather for the given location.',
      inputSchema: z.object({ city: z.string() }),
      outputSchema: z.object({
        temperatureF: z.number(),
        conditions: z.string(),
      }),
    },
    async (input) => {
      const conditions = ['Sunny', 'Cloudy', 'Partially Cloudy', 'Raining'];
      const c = Math.floor(Math.random() * conditions.length);
      const temp = Math.floor(Math.random() * (120 - 32) + 32);
  
      return {
        temperatureF: temp,
        conditions: conditions[c],
      };
    }
  );
  export { getWeather };

The tool is called as expected, however, "promptResult.toolRequests" never seems to return anything, perhaps, I am not calling it correctly?

if (promptResult.toolRequests) {
    for (const toolRequest of promptResult.toolRequests()) {
        const tool = this._tools[toolRequest.name];
        if (tool) {
            await tool.run(this._agent_doc_ref, toolRequest?.input);
            this._last_tool_completion_datetime = new Date(new Date().toUTCString());
            await this.updateAgentData({
                last_action: toolRequest?.name,
                [`last_tool_completion_datetime_${this._agent_chat_id}`]: this._last_tool_completion_datetime,
                [`current_prompt_step_${this._agent_chat_id}`]: this._current_prompt_step,
                retry: retryCount
            });
            hasCalledTool = true;
        }
    }
}

I have got around this by looking at the const responseHistory = promptResult.toHistory();

The toHistory returns messages with a content array of type toolRequest and toolResponse, so at least, we have access it to it.

content (array) (map)
                  toolRequest (map) input (map) city "New York" (string)

and a toolResponse

content (array) (map) toolResponse (map) name "getWeather" (string) output (map)

I am wondering the best way to handle more complex tools let's say, whereabouts, we need to pass in parameters from the underlying code. For example, we might want to pass in the relevant IDatabase and associate database record key. As follows, you'll see I created a wrapper function for this called createToolWithContext:

const createToolWithContext = (database: IDatabase, agentDocId: string) => {
    return <TInput, TOutput>(config: { name: string; description: string; inputSchema: z.ZodSchema<TInput>; outputSchema?: z.ZodSchema<TOutput>; }, handler: (input: TInput, context: { database: IDatabase; agentDocId: string }) => Promise<TOutput>) => {
        return defineTool(config, (input: TInput) => handler(input, { database, agentDocId }));
    };
};

/**
 * Tool to save the user's first and last name.
 */
const saveName = (database: IDatabase, agentDocId: string) => createToolWithContext(database, agentDocId)(
    {
        name: 'SaveName',
        description: 'Saves the user\'s first and last name.',
        inputSchema: z.object({
            firstName: z.string().optional(),
            lastName: z.string().optional(),
        }),
    },
    async (input, { database, agentDocId }) => {
        // Split the agent document ID to get the user ID.
        const userId = agentDocId.split('_')[0];

        // Prepare the update data object.
        const updateData: any = {};
        if (input.firstName) {
            updateData.firstName = input.firstName.trim();
        }
        if (input.lastName) {
            updateData.lastName = input.lastName.trim();
        }

        // Update the user profile document in the database.
        await database.set('userProfile', userId, updateData, true);

        return { success: true };
    }
);

I assume the correct way is then to programmatically set it (when using dotPrompt), is this the correct approach?

dotPrompt.tools = [saveName(database, agentDocId)];
promptResult =  await dotPrompt.generate({});

Lastly, thanks for the notes on history. I may pass that into dotPrompt as a parameter and render it. It would be great if there was some way to auto summarise the history based on the number of tokens used and pass that in as history. The plumbing code is quite tedious to write and difficult to test. Is this something GenKit api could handle with the call to saveHistory()?

First off - thank you so much for taking the time to do such a detailed write up. We'll definitely leverage these insights as we continue make improvements to the framework. See answers to your questions below:

It would be great if we could pull the list of available models literal name strings (e.g. "googleai/gemini-1.5-pro-latest") via the genKit api

Are you looking for code completion / compile time checking for model names? Or a reflective way to interrogate Genkit programatically ? Currently, we do not provide the former, but we do provide the latter. Granted, you'll only be able to interrogate the registry for plugins that are loaded.

A small thing here to remember is to configureGenkit and not to forget the "apiVersion: 'v1beta'", otherwise, you'll get googleai/gemini-1.5-pro-latest not found.

Good call out - the Gemini 1.5 family of models are now GA, and will be available in the v1 API starting in next week's Genkit release Separately, we're working on improved messaging if configureGenit() is missed. See: #173

The tool is called as expected, however, "promptResult.toolRequests" never seems to return anything, perhaps, I am not calling it correctly?

What would be most intuitive for you here? What will you do with access to the tool calls? In short, you are handling this correctly by looking through the message history. You'll only see toolRequests if you pass returnToolRequests: true as a config param. In that case, generate() will not make the tool call, and you'll have the ability to do it manually.

I am wondering the best way to handle more complex tools...

I think you have an interesting solution here; you should be able to reference the tool by name in your dotprompt file. If I understand it correctly, your wrapper method approach may or may not be OK depending on what your set-up is like. When you call defineTool it will be registered in Genkit, and then later resolved (by name) when you call prompt.generate().

Depending on whether or not this code is run once then thrown away (e.g. inside a cloud/firebase function) or is long lived, this may or not behave the way you are expecting. You don't want to register the same tool name twice. And you also don't want to register a new one globally for every user request either.

If you need something truly dynamic should be able to pass an action as a tool instead. Let me come back to you on this one.

It would be great if there was some way to auto summarise the history based on the number of tokens used and pass that in as history.

Thanks for the suggestion/request. We'll give this one some thought. There are a few of us working through what it might look like in Genkit to support Agents in a more first-class way.

Thank you @MichaelDoyle

I'll answer inline as follows:

Are you looking for code completion / compile time checking for model names? Or a reflective way to interrogate Genkit programatically ? Currently, we do not provide the former, but we do provide the latter. Granted, you'll only be able to interrogate the registry for plugins that are loaded.

The code completion would be a nice to have, a programmatic, reflective way to query GenKit would be ideal. For all models e.g. all supported OpenAI models, Ollama etc.

"promptResult.toolRequests" never seems to return anything, perhaps, I am not calling it correctly?

What would be most intuitive for you here?

Processing the history is a bit of a pain and Im not sure if it would be performant if it is a long conversation. If promptResult.toolRequests returned what tools were called, when the tool was called, what parameters, and what the return was: Essentially all the history filtered by the role="tools" I guess...

Depending on whether or not this code is run once then thrown away (e.g. inside a cloud/firebase function) or is long lived, this may or not behave the way you are expecting. You don't want to register the same tool name twice. And you also don't want to register a new one globally for every user request either. Depending on whether or not this code is run once then thrown away (e.g. inside a cloud/firebase function) or is long lived, this may or not behave the way you are expecting. You don't want to register the same tool name twice. And you also don't want to register a new one globally for every user request either. If you need something truly dynamic should be able to pass an action as a tool instead. Let me come back to you on this one.

I would like to be able to switch environments from Firebase and any other node environment. I have achieved this by abstracting executeFlow and the Agent class as follows:

./index.ts

export const startFlow = functions.https.onCall(async (data, context) => {
    const userId = context.auth?.uid;
    if (!userId) {
        return { status: "FAIL2", message: "User not logged in: unauthorized user", data: {} };
    }

    const { response, agent_chat_id } = data;

    return await executeFlow(userId, response, agent_chat_id);
});

./agentService.ts

export async function executeFlow(userId: string, response: string, agent_chat_id: number) {
    try {
        const database = new FirestoreDatabase();
        const intent3nsquestionnaire = await prompt('intent3nsquestionnaire');
        const dotPrompts = [intent3nsquestionnaire];

        const agent = new AgentMultiPromptSequencer(
            userId,
            agent_chat_id,
            database,
            dotPrompts,
            generateChatTitlePrompt
        );

        await agent.init();
        const agentRes = await agent.handle_response(response);

        return { status: "SUCCESS", message: "", data: { result: agentRes } };
    } catch (error) {
        console.error("CATCH ERROR executeFlow: ", error); 
    }
}

See questions 5 and 6 below....

Now let's have a look at ./AgentMultiPromptSequencer.ts class and our dynamic tool:

const dynamicTools = createDynamicTool(this._database, `${this._owner_id}_${this._agent_chat_id}`);
dotPrompt.tools = [dynamicTools.saveName];

let input = {
    isRetryCountZeroOrLess: retryCount <= 0,
    userResponse: response, retryCount: retryCount, questionId: this._current_prompt_step, history 
};

let promptResult =  await dotPrompt.generate({input});

Where createDynamicTool is defined as:

export const createDynamicTool = (database: IDatabase, agentDocId: string) => {
    return {
        saveName: {
            name: 'SaveName',
            description: 'Call after response to the question like: can you tell me your first and last name',
            inputSchema: z.object({
                firstName: z.string().optional(),
                lastName: z.string().optional(),
            }),
            handler: async (input: { firstName?: string; lastName?: string }) => {
                const userId = agentDocId.split('_')[0];

                const updateData: any = {};
                if (input.firstName) {
                    updateData.firstName = input.firstName.trim();
                }
                if (input.lastName) {
                    updateData.lastName = input.lastName.trim();
                }

                await database.set('userProfile', userId, updateData, true);

                return { success: true };
            }
        }
    };
};

Ive set out question 4 below on the above

This brings us to the .prompt and handlebars. It appears that custom handlers are not supported by GenKit Handlebars. Examine the following .prompt file especially the knownHelpersOnly: false and the logic keywords

---
model: openai/gpt-4
options:
  knownHelpersOnly: false
config:
  temperature: 0.6
  maxRetryCount:
    0: 3
    1: 5
    2: 2
    3: 2
    4: 2
    5: 2
    6: 3
    7: 2
input:
  schema:
    type: object
    properties:
      userResponse:
        type: string
        default: ""
      retryCount:
        type: number
      questionId:
        type: number
      history:
        type: array
        items:
          type: object
          properties:
            content:
              type: array
              items:
                type: string
            role:
              type: string
      domainName:
        type: string
        default: ""
output:
  format: text
---

{{role "system"}}
You are an expert question answering gathering assistant, your goal is to..

{{#each history}}
  {{#if (eq this.role "user")}}
    {{role "user"}}
    {{this.content.[0]}}
    {{/role}}
  {{else if (eq this.role "model")}}
    {{role "model"}}
    {{this.content.[0]}}
    {{/role}}
  {{/if}}
{{/each}}

{{#switch questionId}}
  {{#case 0}}
    {{#if (lte retryCount 0)}}
      {{role "system"}}
      Greetings, "To get started, could you please provide your first and last name so I know how to address you?"
    {{else}}
      {{role "system"}}
      We asked the user to provide their first and last name, and they responded: "{{userResponse}}". Please acknowledge their response logically and politely, and try to encourage them to answer the question we raised.
    {{/if}}
  {{/case}}

  {{#case 1}}
    {{#if (lte retryCount 0)}}
      {{role "system"}}
      In a beautifully reworded, concise, and natural way, ask the user the following question and any relevant follow-up questions to gather their intent. Question: "Please tell me your main purpose...."
    {{else}}
      {{role "system"}}
      We asked the user: "Do you want me to sell something, prompt...?" They answered: "{{userResponse}}". Please respond logically to their answer and try to encourage them to clarify their intent further.
    {{/if}}
  {{/case}}

  {{#case 2}}
    etc...
{{/switch}}

This will throw parse errors on "eq" "lte" something like "You specified knownHelpersOnly, but used the unknown helper eq - 4:6"

So i thought I would define my own

const Handlebars = require('handlebars');

Handlebars.registerHelper('eq', function(a, b) {
     return a == b;
});

However they are just ignored even if we specify

options:
  knownHelpersOnly: false

in the .prompt file

I guess I can hack my way around this by:

1. pre-rendering the boolean logic eg {{#if (eq this.role "user")}} do all this logic outside of the .prompt template then pass it in a simple string. However if the history format changes then Ill be in some sort of version hell.

2. separating each prompt into it's own file that would get rid of the switch or if statements

Few questions:

1.) Is it not possible to define our own custom handlebar helpers?
2.) How do I pass in History ?
3.) How do I pass in the RAG context?
4.) Is my dynamic functions the correct approach? Given we do not want to re-register it globally for each request ,,,
5.) Currently I do not see a way to stream the response back to the client via the firebase cloud function. Is streaming the response back not supported via Firebase Cloud Function hosting?
6.) And is this the correct approach to abstract the implementation from the hosting nodejs environment? Fyi note my agent classes are used by LangChain for ChainOfThought and other things

I would very much appreciate any guidance you might have. Thanks again!

1. It's not possible at the moment, but I've filed [Dotprompt] Support custom helpers #416 because I think it should be.
2. At the moment Dotprompt doesn't support history properly, I'm working on [Dotprompt] Support history and context when passed in. #418 to solve that.
3. [Dotprompt] Support history and context when passed in. #418 should also hopefully address that 😄

Re: (5) HTTP Cloud Functions do support streaming but we haven't yet added it to the Callable Functions protocol. It's something we're interested in pursuing.

@mbleigh @MichaelDoyle

Thanks for the help, I am losing quite a bit of time investigating and trying to work around these issues it would be really helpful if you could, if at all possible:

1. Understood thanks

2. Re history to get around it for now I will need to convert history to a simple string and pass that in to the dotPrompt as a parameter. Do you have the format that is required for history as a string or better some code to convert the history object to a string in the correct format?

3. Same question with RAG context? What format is it required if I pass it in as a string...

4. Is this the right approach for dynamic functions, any suggestions?

5. Do you have a code example of streaming in any node environment? (non firebase functions if it isn't supported)

6. Do you have a code example to get the list of supported models versions from genkit? All OpenAI models versions, Gemini, ollama etc?

7. Could you provide a code example of how achieve the above .prompt using definePrompt rather than defineDotPrompt?

Many thanks

2, 3, 7 - Context and history Implemented in #421.

4 - I think you mostly have it. I would just change things around slightly so that you're returning an action. You'll want to come up with a technique to ensure the function name (action name) is always unique as well.

import { action } from '@genkit-ai/core';

export const createDynamicTool = (database: IDatabase, agentDocId: string) => {
  return action(
    {
      name: 'saveName', // give this a unique name however you'd like
      description:
        'Call after response to the question like: can you tell me your first and last name',
      inputSchema: z.object({
        firstName: z.string().optional(),
        lastName: z.string().optional(),
      }),
    },
    async (input) => {
      const userId = agentDocId.split('_')[0];

      const updateData: any = {};
      if (input.firstName) {
        updateData.firstName = input.firstName.trim();
      }
      if (input.lastName) {
        updateData.lastName = input.lastName.trim();
      }

      await database.set('userProfile', userId, updateData, true);

      return { success: true };
    }
  );
};

5 - Let me check in and see if there is an expert on Firebase functions that can weigh in on that one.

6 - You can use the registry to do this.

import { listActions } from '@genkit-ai/core/registry';

Object.keys(await listActions())
      .filter((k) => k.startsWith('/model/'))
      .map((k) => k.substring(7, k.length));

Example output (depends on what plugin(s) you have installed):

[
  "googleai/gemini-1.5-pro-latest",
  "googleai/gemini-1.5-flash-latest",
  "googleai/gemini-pro",
  "googleai/gemini-pro-vision",
  "ollama/llama2",
  "ollama/llama3",
  "ollama/gemma",
  "vertexai/imagen2",
  "vertexai/gemini-1.0-pro",
  "vertexai/gemini-1.0-pro-vision",
  "vertexai/gemini-1.5-pro",
  "vertexai/gemini-1.5-flash",
  "vertexai/gemini-1.5-pro-preview",
  "vertexai/gemini-1.5-flash-preview",
  "vertexai/claude-3-haiku",
  "vertexai/claude-3-sonnet",
  "vertexai/claude-3-opus"
]

Hi @MichaelDoyle @mbleigh

Thanks for the help. The latest bug occurs when setting

renderedPrompt.returnToolRequests = false;

CATCH ERROR executeFlow: Error: running outside step context
at getCurrentSpan (\node_modules@genkit-ai\core\lib\tracing\instrumentation.js:197:11)
at setCustomMetadataAttributes (\node_modules@genkit-ai\core\lib\tracing\instrumentation.js:179:23)
at fn (\node_modules@genkit-ai\ai\lib\tool.js:74:52)
at \node_modules@genkit-ai\ai\lib\generate.js:611:27
at Generator.next ()
at \node_modules@genkit-ai\ai\lib\generate.js:66:61
at new Promise ()
at __async (node_modules@genkit-ai\ai\lib\generate.js:50:10)
at \node_modules@genkit-ai\ai\lib\generate.js:591:31
at Array.map ()

Calling code

let input = {
     userResponse: response,
     retryCount: retryCount,
     questionId: this._current_prompt_step,
     history,
     argTools: [saveName, checkDomainName, userNotLikelyToBuyTool],
   };

   let renderedPrompt = await renderPrompt({
     prompt: web3SmartAgentPrompt,
     input: input,
     model: "openai/gpt-4o",
   });

   let toolsR = renderedPrompt.returnToolRequests;

   if (!toolsR) {  << toolsR  is  always undefined even though it is passed out of the definePrompt definition
     renderedPrompt.returnToolRequests = false;   << the EXCEPTION OCCURS when setting this to false if it is set to true then the history return the call to the function but doesn't actually call the function 
   }

   if (!renderedPrompt.tools) {  <<< renderedPrompt.tools  is also always undefined even though it is passed in and out of definePrompt
     renderedPrompt.tools = [
       saveName,
       checkDomainName,
       userNotLikelyToBuyTool,
     ];
   }

   let promptResult = await generate(renderedPrompt);

   // Save the chat history.
   const responseHistory = promptResult.toHistory();
   await this.saveChatHistory(responseHistory);

The tools are defined as, note I had to define the output schema otherwise it throws an error:

    
export const createUserNotLikelyToBuyTool = (
  database,
  agentChatId,
  ownerId,
  agentType
) => {
  return action(
    {
      name: "userNotLikelyToBuyContinueToNextPage",
      description:
        "Handles the scenario when a user is not likely to buy a domain",
      inputSchema: z.object({
        notLikelyToContinueToPurchase: z.boolean(),
      }),
      outputSchema: z.object({
        success: z.boolean(),
      }),
    },
    async (input) => {
      if (input.notLikelyToContinueToPurchase) {
        const data = {
          agent_chat_id: agentChatId,
          agent_type: agentType,
          content: [{ text: "EndConversation" }],
          dateCreated: new Date(),
          dateDeleted: null,
          ownerId: ownerId,
          role: "frontend",
        };
        await database.add("agent_chat_history", data);
      }
      return { success: true };
    }
  );
};

export const createCheckDomainTool = (database: IDatabase) => {
  return action(
    {
      name: "checkDomainNameIsAvailable", // Unique name for the tool
      description: "Checks if a given .web3 domain name is available",
      inputSchema: z.object({
        domainName: z.string().default(""),
      }),
      outputSchema: z.object({
        success: z.boolean(),
        isAvailable: z.boolean(),
      }),
    },
    async (input: { domainName: string }) => {
      const isAvailable = true; // Assuming this function exists in your database module
      return { success: true, isAvailable };
    }
  );
};

export const createDynamicTool = (database: IDatabase, agentDocId: string) => {
  return action(
    {
      name: "saveName", // give this a unique name however you'd like
      description:
        "Call after the user has provided their first and/or last name e.g. in response to the question like: can you tell me your first and last name",
      inputSchema: z.object({
        firstName: z.string().optional(),
        lastName: z.string().optional(),
      }),
      outputSchema: z.object({
        success: z.boolean(),
      }),
    },
    async (input: { firstName?: string; lastName?: string }) => {
      const userId = agentDocId.split("_")[0];

      const updateData: any = {};
      if (input.firstName) {
        updateData.firstName = input.firstName.trim();
      }
      if (input.lastName) {
        updateData.lastName = input.lastName.trim();
      }

      await database.set("userProfile", userId, updateData, true);

      return { success: true };
    }
  );
};

and the prompt as:

   import { definePrompt } from "@genkit-ai/ai";
const z = require("zod");

// Define the schema for the input
const inputSchema = z.object({
  userResponse: z.string().default(""),
  retryCount: z.number(),
  questionId: z.number(),
  argTools: z.array(z.any()),
  history: z.array(
    z
      .object({
        content: z.array(z.union([z.string(), z.object({ text: z.string() })])),
        role: z.string(),
      })
      .passthrough() // Allow additional properties
  ),
});

// Define the prompt template as a function
const promptFunction = async (input) => {
  let { userResponse, retryCount, questionId, history, argTools } = input;

  if (retryCount > 0) {
    if (questionId > 0) {
      questionId = 0;
    }
  }

  // Function to generate role-based messages
  const generateRoleMessage = (role, content) => {
    return { role, content: [{ text: content }] };
  };

  // Create the history part of the messages
  // Create the history part of the messages
  const historyMessages = (history || [])
    .map((entry) =>
      entry.content.map((contentItem) => {
        if (typeof contentItem === "string") {
          return generateRoleMessage(entry.role, contentItem);
        } else if (
          contentItem &&
          typeof contentItem === "object" &&
          contentItem.text
        ) {
          return generateRoleMessage(entry.role, contentItem.text);
        }
        return null;
      })
    )
    .flat()
    .filter(Boolean);

  // Define the system message
  let systemMessage = `

When the user provides their first and/or last name, call the saveName tool using this format:
<tool_call>
{
  "name": "saveName",
  "arguments": {
    "firstName": "user's first name",
    "lastName": "user's last name"
  }
}
</tool_call>

When the user provides a desired domain name, call the checkDomainNameIsAvailable tool using this format:
<tool_call>
{
  "name": "checkDomainNameIsAvailable",
  "arguments": {
    "domainName": "user's desired domain name"
  }
}
</tool_call>

If the user is not likely to buy, call the userNotLikelyToBuyContinueToNextPage tool using this format:
<tool_call>
{
  "name": "userNotLikelyToBuyContinueToNextPage",
  "arguments": {
    "notLikelyToContinueToPurchase": true
  }
}
</tool_call>


  You are a highly skilled blah blah
  `;

  const systemMessages = [generateRoleMessage("system", systemMessage)];

  if (userResponse) {
    systemMessages.push(generateRoleMessage("user", userResponse));
  }

  return {
    messages: systemMessages,
    config: {
      temperature: 0.6,
      maxRetryCount: {
        0: 3,
        1: 5,
        2: 2,
        3: 2,
        4: 2,
        5: 2,
        6: 3,
        7: 2,
      },
    },
    history: historyMessages,
    tools: argTools,
    returnToolRequests: true,
    model: "openai/gpt-4o",
  };
};

// Define the prompt using definePrompt
const web3SmartAgentPrompt = definePrompt(
  {
    name: "web3SmartAgentPrompt",
    inputSchema,
  },
  promptFunction
);

export default web3SmartAgentPrompt; 

I must admit I am pretty close to giving up on genkit, I do have a working version with my own rolled code but had hoped GenKit would save on the manual implementation of each API.

Questions:

1. Anyhow, I would really appreciated if you could provide a fully functional example using definePrompt in code specifically with context, history, dynamic functions?

1a. (and, if it is now possible, using defineDotPrompt using code and through .prompt with some custom handlebars extensions) ?

2. Please could you clarify "name: 'saveName', // give this a unique name however you'd like" does this mean a unique name globally or per request or per session or per user?

thank you.

1. We'll take a look and see what gaps we have documentation and sample wise and fill these in.
2. If you are rendering a new prompt per request, that is sufficient. You just don't want to have a single prompt where you have multiple tools all called saveName.

1. We'll take a look and see what gaps we have documentation and sample wise and fill these in.

2. If you are rendering a new prompt per request, that is sufficient. You just don't want to have a single prompt where you have multiple tools all called saveName.

Great thanks @MichaelDoyle @mbleigh

Do you have a timeline on fixing the bug thrown?

Only when
renderedPrompt.returnToolRequests = false;

If it is true it works as expected and the toolrequest call is in history

CATCH ERROR executeFlow: Error: running outside step context
at getCurrentSpan (\node_modules@genkit-ai\core\lib\tracing\instrumentation.js:197:11)
at setCustomMetadataAttributes (\node_modules@genkit-ai\core\lib\tracing\instrumentation.js:179:23)
at fn (\node_modules@genkit-ai\ai\lib\tool.js:74:52)
at \node_modules@genkit-ai\ai\lib\generate.js:611:27
at Generator.next ()
at \node_modules@genkit-ai\ai\lib\generate.js:66:61

I opened #574, or else I am afraid it will get lost here.

Heads up, this is still causing some confusion: #723.

It looks like Genkit's developed quite a bit even over the last 3 weeks though, so my experience working with defineDotPrompt has been smooth so far now that I have the proper context 👍

I do see some overlap though between some parts of this discussion and some of my own high-level questions about Genkit's architectural/design philosophy: #731.

@MichaelDoyle

Acknowledged! There are some efforts underway to revamp the documentation. I'll check in to make sure this is part of it.

@i2amsam @MichaelDoyle docs have been updated to remove definePrompt in favor of defineDotprompt. Any additional work needed here?

@i2amsam @MichaelDoyle docs have been updated to remove definePrompt in favor of defineDotprompt. Any additional work needed here?

There is additional work in progress on prompt documentation but I think you can close this particular one

@kevinthecheung much better well done - I'd say add a small table on when to use what and what each provides at the end of the page to save people time

Agreed - I'll close this out, because the fundamental issue is addressed. We can look at including a comparison of different prompt management styles as part of what @kevinthecheung is working on next with the prompt documentation.