kleneway/vdotExample.ts

/**
 * This is a version of a tool-calling behavior that implements a "phased scenario" style prompt.
 * In the scenario prompt, we're trying to fulfill some objective that looks like "filling out a form".
 * The _phased_ version of the scenario prompt updates the instructions in the system prompt as we go
 * to guide the LLM toward more specific sub-goals.
 *
 * See tools.ts for a simplified version of this.
 */
import { defineTool } from "@pioneersquarelabs/language-barrier";
import { defineBehaviorModule } from "@pioneersquarelabs/vdot";
import { z } from "zod";

/**
 * This is our object where we keep track of the details we learn about the user that we're talking
 * with.  The LLM is effectively "filling this out".
 */
export type UserDetails = {
  name?: string;
  age?: string;
};

/**
 * This is the prompt that sets the overall tone for the LLM interaction.
 */
function basePrompt(): string {
  return "You are a friendly conversational agent whose goal is to learn about a user.  Pay close attention to the instructions section.";
}

/**
 * This prompt refines the objective of the LLM detpending on what we know so far.
 */
function phaseSpecificInstructions(details: Readonly<UserDetails>): string {
  if (details.age == null && details.name == null) {
    return "# Instructions\nYour current goal is to learn the name and age of the user.  Figure it out but without being overbearing or asking questions that are too direct.";
  }
  if (details.age == null) {
    const knowledge = `# Current knowledge\n User name: + ${details.name}`;
    return `${knowledge}\n# Instructions\nFocus on learning the age of the user.  Ask questions that aren't too direct to learn it.`;
  }
  if (details.name == null) {
    const knowledge = `# Current knowledge\nUser age: ${details.age}`;
    return `${knowledge}\n# Instructions\nFocus on learning the age of the user.  Ask questions that aren't too direct to learn it.`;
  }
  return `# Current knowledge\nUser age: ${details.age}\nUser name: ${details.name}\n# Instructions\nYou have finished learning about the user.  Now you should just converse with them - maybe find out about their day!`;
}

/**
 * This is the tool that the LLM can call to assert user information.  Note that this tool doesn't
 * have any knowledge of the current phase - it always stays the same.
 */
export const assertUserDetails = defineTool({
  name: "assertUserDetails",
  description: "Assert details that you have learned about the user",
  parameters: {
    name: z.string().describe("name of the user").optional(),
    age: z
      .string()
      .describe(
        "The age of the user in whatever units they have provided you with",
      )
      .optional(),
  },
});

/**
 * This is the behavior module where we bring it all together.
 */
export const toolUsingBehavior = defineBehaviorModule({
  // Note that here we have the tool definition.  This will always be here.
  toolbox: [assertUserDetails],
  initialize: () => {
    const initialUserData: UserDetails = {};
    return {
      systemPrompt: [
        basePrompt(),
        phaseSpecificInstructions(initialUserData),
      ].join("\n"),
      toolChoice: "auto",
      // The as cast is necessary here because we're doing everything inline.
      userData: initialUserData,
      options: {
        model: "claude-3-5-sonnet-20240620",
        tokenConstraints: { maxOutput: 1024 },
        temperature: 0.2,
      },
    };
  },
  /**
   * This is where we process the results when our tool gets called.  Note that here, our tool call
   * has already been parsed and has the correct type.  As we go, we update the system prompt so that
   * the model is appropriately focused.
   */
  onToolResult: async (state, toolCall) => {
    /**
     * Now we're dynamically changing the prompt based on what the current state of the world is.
     */
    if (toolCall.name === assertUserDetails.name) {
      if (toolCall.args.age) {
        state.userData.age = toolCall.args.age;
        state.systemPrompt = [
          basePrompt(),
          phaseSpecificInstructions(state.userData),
        ].join("\n");
      }
      if (toolCall.args.name) {
        state.userData.name = toolCall.args.name;
        state.systemPrompt = [
          basePrompt(),
          phaseSpecificInstructions(state.userData),
        ].join("\n");
      }
    }
  },
});