Merge pull request #1467 from jonathangus/dynamic-template

feat: Make templates in composeContext dynamic

Author: HashWarlock

docs/api/functions/composeContext.md

@@ -22,9 +22,9 @@ The parameters for composing the context.
 
 The state object containing values to replace the placeholders in the template.
 
-• **params.template**: `string`
+• **params.template**: `string` | `Function`
 
-The template string containing placeholders to be replaced with state values.
+The template string or function returning a string containing placeholders to be replaced with state values.
 
 • **params.templatingEngine?**: `"handlebars"`
 

docs/docs/api/functions/composeContext.md

@@ -10,11 +10,11 @@ Composes a context string by replacing placeholders in a template with values fr
 
 An object containing the following properties:
 
-- **state**: `State`  
+- **state**: `State`
   The state object containing key-value pairs for replacing placeholders in the template.
 
-- **template**: `string`  
-  A string containing placeholders in the format `{{placeholder}}`.
+- **template**: `string | Function`
+  A string or function returning a string containing placeholders in the format `{{placeholder}}`.
 
 - **templatingEngine**: `"handlebars" | undefined` _(optional)_  
   The templating engine to use. If set to `"handlebars"`, the Handlebars engine is used for template compilation. Defaults to `undefined` (simple string replacement).
@@ -51,7 +51,7 @@ const contextHandlebars = composeContext({
 ```javascript
 const advancedTemplate = `
   {{#if userAge}}
-    Hello, {{userName}}! 
+    Hello, {{userName}}!
     {{#if (gt userAge 18)}}You are an adult.{{else}}You are a minor.{{/if}}
   {{else}}
     Hello! We don't know your age.

packages/client-twitter/src/post.ts

@@ -6,7 +6,8 @@ import {
     IAgentRuntime,
     ModelClass,
     stringToUuid,
-    UUID,
+    TemplateType,
+    UUID
 } from "@elizaos/core";
 import { elizaLogger } from "@elizaos/core";
 import { ClientBase } from "./base.ts";
@@ -533,7 +534,7 @@ export class TwitterPostClient {
     private async generateTweetContent(
         tweetState: any,
         options?: {
-            template?: string;
+            template?: TemplateType;
             context?: string;
         }
     ): Promise<string> {

packages/core/src/context.ts

@@ -1,5 +1,5 @@
 import handlebars from "handlebars";
-import { type State } from "./types.ts";
+import { type State, type TemplateType } from "./types.ts";
 import { names, uniqueNamesGenerator } from "unique-names-generator";
 
 /**
@@ -13,7 +13,7 @@ import { names, uniqueNamesGenerator } from "unique-names-generator";
  *
  * @param {Object} params - The parameters for composing the context.
  * @param {State} params.state - The state object containing values to replace the placeholders in the template.
- * @param {string} params.template - The template string containing placeholders to be replaced with state values.
+ * @param {TemplateType} params.template - The template string or function containing placeholders to be replaced with state values.
  * @param {"handlebars" | undefined} [params.templatingEngine] - The templating engine to use for compiling and evaluating the template (optional, default: `undefined`).
  * @returns {string} The composed context string with placeholders replaced by corresponding state values.
  *
@@ -25,23 +25,34 @@ import { names, uniqueNamesGenerator } from "unique-names-generator";
  * // Composing the context with simple string replacement will result in:
  * // "Hello, Alice! You are 30 years old."
  * const contextSimple = composeContext({ state, template });
+ *
+ * // Using composeContext with a template function for dynamic template
+ * const template = ({ state }) => {
+ * const tone = Math.random() > 0.5 ? "kind" : "rude";
+ *   return `Hello, {{userName}}! You are {{userAge}} years old. Be ${tone}`;
+ * };
+ * const contextSimple = composeContext({ state, template });
  */
+
 export const composeContext = ({
     state,
     template,
     templatingEngine,
 }: {
     state: State;
-    template: string;
+    template: TemplateType;
     templatingEngine?: "handlebars";
 }) => {
+    const templateStr =
+        typeof template === "function" ? template({ state }) : template;
+
     if (templatingEngine === "handlebars") {
-        const templateFunction = handlebars.compile(template);
+        const templateFunction = handlebars.compile(templateStr);
         return templateFunction(state);
     }
 
     // @ts-expect-error match isn't working as expected
-    const out = template.replace(/{{\w+}}/g, (match) => {
+    const out = templateStr.replace(/{{\w+}}/g, (match) => {
         const key = match.replace(/{{|}}/g, "");
         return state[key] ?? "";
     });

packages/core/src/tests/context.test.ts

@@ -70,6 +70,96 @@ describe("composeContext", () => {
         });
     });
 
+    describe("dynamic templates", () => {
+        it("should handle function templates", () => {
+            const state: State = {
+                ...baseState,
+                userName: "Alice",
+                userAge: 30,
+            };
+            const template = () => {
+                return "Hello, {{userName}}! You are {{userAge}} years old.";
+            };
+
+            const result = composeContext({ state, template });
+
+            expect(result).toBe("Hello, Alice! You are 30 years old.");
+        });
+
+        it("should handle function templates with conditional logic", () => {
+            const state: State = {
+                ...baseState,
+                userName: "Alice",
+                userAge: 30,
+            };
+            const isEdgy = true;
+            const template = () => {
+                if (isEdgy) {
+                    return "Hello, {{userName}}! You are {{userAge}} years old... whatever";
+                }
+
+                return `Hello, {{userName}}! You are {{userAge}} years old`;
+            };
+
+            const result = composeContext({ state, template });
+
+            expect(result).toBe(
+                "Hello, Alice! You are 30 years old... whatever"
+            );
+        });
+
+        it("should handle function templates with conditional logic depending on state", () => {
+            const template = ({ state }: { state: State }) => {
+                if (state.userName) {
+                    return `Hello, {{userName}}! You are {{userAge}} years old.`;
+                }
+
+                return `Hello, anon! You are {{userAge}} years old.`;
+            };
+
+            const result = composeContext({
+                state: {
+                    ...baseState,
+                    userName: "Alice",
+                    userAge: 30,
+                },
+                template,
+            });
+
+            const resultWithoutUsername = composeContext({
+                state: {
+                    ...baseState,
+                    userAge: 30,
+                },
+                template,
+            });
+
+            expect(result).toBe("Hello, Alice! You are 30 years old.");
+            expect(resultWithoutUsername).toBe(
+                "Hello, anon! You are 30 years old."
+            );
+        });
+
+        it("should handle function templates with handlebars templating engine", () => {
+            const state: State = {
+                ...baseState,
+                userName: "Alice",
+                userAge: 30,
+            };
+            const template = () => {
+                return `{{#if userAge}}Hello, {{userName}}!{{else}}Hi there!{{/if}}`;
+            };
+
+            const result = composeContext({
+                state,
+                template,
+                templatingEngine: "handlebars",
+            });
+
+            expect(result).toBe("Hello, Alice!");
+        });
+    });
+
     // Test Handlebars templating
     describe("handlebars templating", () => {
         it("should process basic handlebars template", () => {

packages/core/src/types.ts

@@ -678,6 +678,8 @@ export interface ModelConfiguration {
     experimental_telemetry?: TelemetrySettings;
 }
 
+export type TemplateType = string | ((options: { state: State }) => string);
+
 /**
  * Configuration for an agent character
  */
@@ -708,30 +710,30 @@ export type Character = {
 
     /** Optional prompt templates */
     templates?: {
-        goalsTemplate?: string;
-        factsTemplate?: string;
-        messageHandlerTemplate?: string;
-        shouldRespondTemplate?: string;
-        continueMessageHandlerTemplate?: string;
-        evaluationTemplate?: string;
-        twitterSearchTemplate?: string;
-        twitterActionTemplate?: string;
-        twitterPostTemplate?: string;
-        twitterMessageHandlerTemplate?: string;
-        twitterShouldRespondTemplate?: string;
-        farcasterPostTemplate?: string;
-        lensPostTemplate?: string;
-        farcasterMessageHandlerTemplate?: string;
-        lensMessageHandlerTemplate?: string;
-        farcasterShouldRespondTemplate?: string;
-        lensShouldRespondTemplate?: string;
-        telegramMessageHandlerTemplate?: string;
-        telegramShouldRespondTemplate?: string;
-        discordVoiceHandlerTemplate?: string;
-        discordShouldRespondTemplate?: string;
-        discordMessageHandlerTemplate?: string;
-        slackMessageHandlerTemplate?: string;
-        slackShouldRespondTemplate?: string;
+        goalsTemplate?: TemplateType;
+        factsTemplate?: TemplateType;
+        messageHandlerTemplate?: TemplateType;
+        shouldRespondTemplate?: TemplateType;
+        continueMessageHandlerTemplate?: TemplateType;
+        evaluationTemplate?: TemplateType;
+        twitterSearchTemplate?: TemplateType;
+        twitterActionTemplate?: TemplateType;
+        twitterPostTemplate?: TemplateType;
+        twitterMessageHandlerTemplate?: TemplateType;
+        twitterShouldRespondTemplate?: TemplateType;
+        farcasterPostTemplate?: TemplateType;
+        lensPostTemplate?: TemplateType;
+        farcasterMessageHandlerTemplate?: TemplateType;
+        lensMessageHandlerTemplate?: TemplateType;
+        farcasterShouldRespondTemplate?: TemplateType;
+        lensShouldRespondTemplate?: TemplateType;
+        telegramMessageHandlerTemplate?: TemplateType;
+        telegramShouldRespondTemplate?: TemplateType;
+        discordVoiceHandlerTemplate?: TemplateType;
+        discordShouldRespondTemplate?: TemplateType;
+        discordMessageHandlerTemplate?: TemplateType;
+        slackMessageHandlerTemplate?: TemplateType;
+        slackShouldRespondTemplate?: TemplateType;
     };
 
     /** Character biography */