@knocklabs/agent-toolkit 0.1.9 → 0.1.11

package/dist/{chunk-6UHXLKAV.js → chunk-URQB3FDZ.js}

@@ -248,98 +248,48 @@ var createOrUpdateMessageType = KnockTool({
   method: "create_or_update_message_type",
   name: "Create or update message type",
   description: `
-  Create or update a message type. A message type is a schema that defines fields available to an editor within Knock. Message types always have at least one variant, that MUST be named "default".
-  
-  Use this tool when you need to create a new message type, or update an existing message type. You must pass the FULL message type to this tool if you're going to update an existing message type.
+  Create or update a message type. A message type is a schema that defines fields available to an editor within Knock. Message types always have at least one variant, that MUST be named "default". Use this tool when you need to create a new message type, or update an existing message type.
+
+  ## Schema and fields
+
+  The schema defines the fields available to an editor within Knock. A variant should have at least one field. Fields can be of different types, including: text, markdown, select, multi-select, image, and button.
 
-  The preview is a string of HTML that will be rendered in the Knock UI as a representation of the message type. It is shared across all variants. It supports liquid, where the field name is available as a variable, so a field named "text" will be rendered as {{ text }}.
+  Each field must have a key, label, and type. Some fields like \`select\` and \`multi_select\` have additional settings that can be used to configure the field.
 
   <example>
-   <description>
-    Create a new message type for a banner component that has a text and an action URL.
-   </description>
-   <input>
-    {
-      "messageTypeKey": "banner",
-      "name": "Banner",
-      "description": "A banner component that has a text and an action URL.",
-      "preview": "<div>{{ text }}</div>",
-      "variants": [
-        {
-          "key": "default",
-          "name": "Default",
-          "fields": [
-            {
-              "key": "text",
-              "type": "text",
-              "label": "Text",
-              "settings": {
-                "max_length": 100,
-              },
-            },
-            {
-              "key": "action_url",
-              "type": "text",
-              "label": "Action URL",
-              "settings": {
-                "placeholder": "https://example.com",
-              },
-            }
-          ]
-        }
-      ]
-    }
-   </input>
+  {
+    "key": "text",
+    "label": "Text",
+    "type": "text",
   </example>
+
   <example>
-   <description>
-    Create a message type for a card component that has an icon type, title, body, and a single action button.
-   </description>
-   <input>
-    {
-      "messageTypeKey": "card",
-      "name": "Card",
-      "description": "A single-action card component.",
-      "preview": "
-        <div>
-          <h2>{{ title }}</h2>
-          <p>{{ body }}</p>
-          <button>Action</button>
-        </div>
-      ",
-      "variants": [
+  {
+    "key": "select",
+    "label": "Select",
+    "type": "select",
+    "settings": {
+      "options": [
         {
-          "key": "default",
-          "name": "Default",
-          "fields": [
-            {
-              "key": "icon_type",
-              "type": "select",
-              "label": "Icon type",
-              "settings": {
-                "options": [
-                  {
-                    "value": "warning",
-                    "label": "Warning",
-                  },
-                ]
-              },
-            },
-            {
-              "key": "description",
-              "type": "markdown",
-              "label": "Description",
-            },
-            {
-              "key": "action_button",
-              "type": "button",
-              "label": "Action button",
-            },
-          ]
-        }
-      ]
-    }
-   </input>
+          "value": "option1",
+          "label": "Option 1",
+        },
+      ],
+    },
+  }
+  </example>
+
+  ## Preview templates
+
+  The preview is a string of HTML that will be rendered in the Knock UI as a representation of the message type. It is shared across all variants. It supports liquid, where the field name is available as a variable, so a field named "text" will be rendered as {{ text }}. All fields should be included in the preview.
+
+  You can make an educated guess as to what the preview template should look like based on the name of the message type and the fields. You can use plain CSS to style the preview by supplying a style tag in the preview. Use simple selectors like .class-name to style elements.
+
+  <example>
+  {
+    "preview": "<style>div { color: red; }</style>
+<div>Hello there, {{ text }}</div>"
+  }
   </example>
   `,
   parameters: z5.object({
@@ -578,11 +528,77 @@ var listPartials = KnockTool({
     return allPartials;
   }
 });
+var getPartial = KnockTool({
+  method: "get_partial",
+  name: "Get partial",
+  description: `
+  Get a partial by its key. Use this tool when you need to know if a specific partial exists by key.
+  `,
+  parameters: z8.object({
+    environment: z8.string().optional().describe(
+      "(string): The environment to get the partial for. Defaults to `development`."
+    ),
+    key: z8.string().describe("(string): The key of the partial to get.")
+  }),
+  execute: (knockClient, config) => async (params) => {
+    const partial = await knockClient.partials.retrieve(params.key, {
+      environment: params.environment ?? config.environment ?? "development"
+    });
+    return serializePartial(partial);
+  }
+});
+var createOrUpdatePartial = KnockTool({
+  method: "upsert_partial",
+  name: "Upsert partial",
+  description: `
+  Create or update a partial. A partial is a reusable piece of content that can be used in a template. Use this tool when you need to create a new partial or update an existing one.
+
+  When working with a partial you must chose the type of the partial. The type determines the format of the content. If you're working with an email template, you should use the "html" or "markdown" type.
+
+  If you need to work with dynamic content in your partial you can use liquid syntax. Liquid is a templating language that is supported in Knock. You can supply a variable like {{ some_variable }} in the content and it will be replaced with the actual value when the partial is used in a template.
+
+  <example>
+  {
+    "name": "Greeting",
+    "key": "greeting",
+    "type": "html",
+    "content": "<div>Hello, {{ recipient_name }}</div>"
+  }
+  </example>
+
+  Changes to a partial MUST be committed before they can be used in a template.
+  `,
+  parameters: z8.object({
+    environment: z8.string().optional().describe(
+      "(string): The environment to upsert the partial for. Defaults to `development`."
+    ),
+    key: z8.string().describe("(string): The key of the partial to upsert."),
+    name: z8.string().describe("(string): The name of the partial."),
+    description: z8.string().optional().describe("(string): The description of the partial."),
+    content: z8.string().describe("(string): The content of the partial."),
+    type: z8.enum(["html", "text", "json", "markdown"]).describe("(string): The type of the partial.")
+  }),
+  execute: (knockClient, config) => async (params) => {
+    const partial = await knockClient.partials.upsert(params.key, {
+      environment: params.environment ?? config.environment ?? "development",
+      partial: {
+        name: params.name,
+        description: params.description,
+        content: params.content,
+        type: params.type
+      }
+    });
+    return serializePartial(partial.partial);
+  }
+});
 var partials = {
-  listPartials
+  getPartial,
+  listPartials,
+  createOrUpdatePartial
 };
 var permissions9 = {
-  read: ["listPartials"]
+  read: ["getPartial", "listPartials"],
+  manage: ["createOrUpdatePartial"]
 };
 
 // src/lib/tools/tenants.ts
@@ -1015,7 +1031,488 @@ var permissions11 = {
 };
 
 // src/lib/tools/workflows.ts
+import { z as z14 } from "zod";
+
+// src/lib/tools/workflow-steps.ts
 import { z as z13 } from "zod";
+function generateStepRef(stepType) {
+  const randomString = Math.random().toString(36).substring(2, 7).toUpperCase();
+  return `${stepType}_${randomString}`;
+}
+async function updateWorkflowWithStep(knockClient, workflow2, step, environment) {
+  const workflowParams = {
+    environment,
+    workflow: {
+      ...workflow2,
+      steps: [...workflow2.steps, step]
+    }
+  };
+  const result = await knockClient.workflows.upsert(
+    workflow2.key,
+    workflowParams
+  );
+  return serializeWorkflowResponse(result.workflow);
+}
+var SHARED_PROMPTS = {
+  workflow: `
+  To use this tool, you MUST first create a workflow using the \`createWorkflow\` tool, or get an existing workflow using the \`getWorkflow\` tool. You ONLY need to pass the workflow key to this tool and the sms step will be added to the end of the workflow's steps array.
+  `,
+  liquid: `
+  ## Personalization
+
+  If you need to include personalization, you can use liquid to include dynamic content in the email and the subject line.
+  The following variables are always available to use in liquid:
+
+  - \`recipient.id\`: The ID of the recipient.  
+  - \`recipient.name\`: The name of the recipient.
+  - \`recipient.email\`: The email of the recipient.
+  - \`recipient.phone_number\`: The phone number of the recipient.
+
+  You can supply **any** other dynamic variables you think are needed by referencing them under the \`data\` key. You add those like \`{{ data.variable_name }}\`.
+
+  <example>
+  # Hello, {{ recipient.name }}
+
+  This is a dynamic message: 
+  
+  > {{ data.message }}
+  </example>
+
+  ## Liquid helpers
+
+  You have access to a full suite of liquid helpers to help you perform common templating tasks. The full list of helper is available here: https://docs.knock.app/designing-workflows/template-editor/reference-liquid-helpers.
+
+  <example>
+  Hello, {{ recipient.name | split: " " | first | default: "there" }}
+  </example>
+  `
+};
+var createEmailStepInWorkflow = KnockTool({
+  method: "create_email_step_in_workflow",
+  name: "Create email step in workflow",
+  description: `
+  Creates an email step in a workflow. Use this tool when you're asked to create an email notification and you need to specify the content of the email.
+
+  ${SHARED_PROMPTS.workflow}
+
+  ## Blocks
+
+  The content of the email is supplied as an array of "blocks". The simplest block is a "markdown" block, which supports content in a markdown format. That should always be your default block type. 
+
+  The following block types are supported:
+
+  - \`markdown\`: A block that supports markdown content.
+  - \`html\`: A block that supports markdown content.
+  - \`image\`: A block that supports an image.
+  - \`button_set\`: A block that adds one or more buttons.
+  - \`divider\`: A block that supports a divider.
+  - \`partial\`: A block that supports rendering a shared content partial.
+
+  <example>
+  {
+    "blocks": [
+      {
+        "type": "markdown",
+        "content": "# Greetings from Knock!
+Hello, {{ recipient.name }}."
+      },
+      {
+        "type": "divider"
+      },
+      {
+        "type": "button_set",
+        "buttons": [
+          {
+            "label": "Approve",
+            "action": "{{ data.primary_action_url }}",
+            "variant": "solid"
+          }
+        ]
+      }
+    ]
+  }
+  </example>
+
+  ### Markdown
+
+  When using the \`markdown\` block, you must supply a \`content\` key. The \`content\` key supports markdown.
+
+  <example>
+  {
+    "type": "markdown",
+    "content": "Hello, world!"
+  }
+  </example>
+
+  ### HTML 
+
+  The \`html\` block supports raw HTML content. This should be used sparingly, and only when you need to include custom HTML content that markdown doesn't support. When using the \`html\` block, you must supply a \`content\` key. HTML content can include liquid personalization.
+
+  ### Button sets
+
+  Button sets are a special type of block that allows you to add one or more buttons to the email. They're useful for directing users to take specific actions. Button sets support one or more buttons. You must always include at least one button in a button set.
+
+  Buttons are specified in a button set under the \`buttons\` key. Each button requires a \`label\`, \`action\`, and \`variant\`. The ONLY valid variants are \`solid\` and \`outline\`. The label and action can allowed be dynamic variables using liquid.
+
+  <example>
+  {
+    "type": "button_set",
+    "buttons": [
+      {
+        "label": "Approve",
+        "action": "https://example.com",
+        "variant": "solid"
+      }
+    ]
+  }
+  </example>
+
+  ### Image
+
+  Images are a special type of block that allows you to add an image to the email. When using the \`image\` block, you must supply a \`url\` key. The \`url\` key supports a URL to an image.
+
+  <example>
+  {
+    "type": "image",
+    "url": "https://example.com/image.png"
+  }
+  </example>
+
+  ${SHARED_PROMPTS.liquid}
+
+  ## Partials
+
+  If you need to reuse content across multiple emails, you can create or reference an existing partial and reference it in the email. You should only use partials if you're instructed to do so.
+
+  When you do need to use a partial in an email, you can use the \`partial\` block and then set the \`key\` to the key of the partial you want to use. If the partial requires any variables, you pass those in the \`attrs\` key.
+
+  ## Writing style
+
+  Unless asked otherwise, you should write content for the email in a concise and formal writing style. Do NOT use complex language or try to over explain. Keep the subject line to 8 words or less.
+  `,
+  parameters: z13.object({
+    workflowKey: z13.string().describe("(string): The key of the workflow to add the step to."),
+    blocks: z13.array(z13.any()).describe("(array): The blocks for the email step."),
+    subject: z13.string().describe("(string): The subject of the email step.")
+  }),
+  execute: (knockClient, config) => async (params) => {
+    const workflow2 = await knockClient.workflows.retrieve(params.workflowKey, {
+      environment: config.environment ?? "development"
+    });
+    const emailChannelsPage = await knockClient.channels.list();
+    const emailChannels = emailChannelsPage.entries.filter(
+      (channel) => channel.type === "email"
+    );
+    if (emailChannels.length === 0) {
+      throw new Error("No email channels found");
+    }
+    return await updateWorkflowWithStep(
+      knockClient,
+      workflow2,
+      // @ts-expect-error
+      {
+        type: "channel",
+        channel_key: emailChannels[0].key,
+        template: {
+          settings: {
+            layout_key: "default"
+          },
+          subject: params.subject,
+          visual_blocks: params.blocks
+        },
+        ref: generateStepRef("email")
+      },
+      config.environment ?? "development"
+    );
+  }
+});
+var createSmsStepInWorkflow = KnockTool({
+  method: "create_sms_step_in_workflow",
+  name: "Create sms step in workflow",
+  description: `
+  Creates an SMS step in a workflow. Use this tool when you're asked to create an SMS notification and you need to specify the content of the SMS. 
+  
+  ${SHARED_PROMPTS.workflow}
+
+  ${SHARED_PROMPTS.liquid}
+  `,
+  parameters: z13.object({
+    workflowKey: z13.string().describe("(string): The key of the workflow to add the step to."),
+    content: z13.string().describe("(string): The content of the SMS.")
+  }),
+  execute: (knockClient, config) => async (params) => {
+    const workflow2 = await knockClient.workflows.retrieve(params.workflowKey, {
+      environment: config.environment ?? "development"
+    });
+    const smsChannelsPage = await knockClient.channels.list();
+    const smsChannels = smsChannelsPage.entries.filter(
+      (channel) => channel.type === "sms"
+    );
+    if (smsChannels.length === 0) {
+      throw new Error("No SMS channels found");
+    }
+    return await updateWorkflowWithStep(
+      knockClient,
+      workflow2,
+      // @ts-expect-error
+      {
+        type: "channel",
+        channel_key: smsChannels[0].key,
+        template: {
+          text_body: params.content
+        },
+        ref: generateStepRef("sms")
+      },
+      config.environment ?? "development"
+    );
+  }
+});
+var createPushStepInWorkflow = KnockTool({
+  method: "create_push_step_in_workflow",
+  name: "Create push step in workflow",
+  description: `
+  Creates a push step in a workflow. Use this tool when you're asked to create a push notification and you need to specify the content of the push notification.
+
+  ${SHARED_PROMPTS.workflow}
+
+  ${SHARED_PROMPTS.liquid}
+
+  Be terse in your writing as this is a push notification and should be direct and to the point.
+  `,
+  parameters: z13.object({
+    workflowKey: z13.string().describe("(string): The key of the workflow to add the step to."),
+    title: z13.string().describe("(string): The title of the push notification."),
+    content: z13.string().describe("(string): The content (body) of the push notification.")
+  }),
+  execute: (knockClient, config) => async (params) => {
+    const workflow2 = await knockClient.workflows.retrieve(params.workflowKey, {
+      environment: config.environment ?? "development"
+    });
+    const pushChannelsPage = await knockClient.channels.list();
+    const pushChannels = pushChannelsPage.entries.filter(
+      (channel) => channel.type === "push"
+    );
+    if (pushChannels.length === 0) {
+      throw new Error("No push channels found");
+    }
+    return await updateWorkflowWithStep(
+      knockClient,
+      workflow2,
+      // @ts-expect-error
+      {
+        type: "channel",
+        channel_key: pushChannels[0].key,
+        template: {
+          title: params.title,
+          text_body: params.content
+        },
+        ref: generateStepRef("push")
+      },
+      config.environment ?? "development"
+    );
+  }
+});
+var createInAppFeedStepInWorkflow = KnockTool({
+  method: "create_in_app_feed_step_in_workflow",
+  name: "Create in app feed step in workflow",
+  description: `
+  Creates an in app feed step in a workflow. Use this tool when you're asked to create an in app feed notification and you need to specify the content of the in app feed notification.  
+
+  ${SHARED_PROMPTS.workflow}
+
+  ${SHARED_PROMPTS.liquid}
+  `,
+  parameters: z13.object({
+    workflowKey: z13.string().describe("(string): The key of the workflow to add the step to."),
+    actionUrl: z13.string().describe(
+      "(string): The URL to navigate to when the in app feed is tapped."
+    ),
+    body: z13.string().describe("(string): The markdown content of the in app feed.")
+  }),
+  execute: (knockClient, config) => async (params) => {
+    const workflow2 = await knockClient.workflows.retrieve(params.workflowKey, {
+      environment: config.environment ?? "development"
+    });
+    const inAppChannelsPage = await knockClient.channels.list();
+    const inAppChannels = inAppChannelsPage.entries.filter(
+      (channel) => channel.type === "in_app_feed"
+    );
+    if (inAppChannels.length === 0) {
+      throw new Error("No in app channels found");
+    }
+    return await updateWorkflowWithStep(
+      knockClient,
+      workflow2,
+      // @ts-expect-error
+      {
+        type: "channel",
+        channel_key: inAppChannels[0].key,
+        template: {
+          action_url: params.actionUrl,
+          markdown_body: params.body
+        },
+        ref: generateStepRef("in_app_feed")
+      },
+      config.environment ?? "development"
+    );
+  }
+});
+var createChatStepInWorkflow = KnockTool({
+  method: "create_chat_step_in_workflow",
+  name: "Create chat step in workflow",
+  description: `
+  Creates a chat step in a workflow. Use this tool when you're asked to create a chat, Slack, Discord, or Microsoft Teams notification and you need to specify the content of the chat notification.
+
+  ${SHARED_PROMPTS.workflow}
+
+  ${SHARED_PROMPTS.liquid}
+  `,
+  parameters: z13.object({
+    workflowKey: z13.string().describe("(string): The key of the workflow to add the step to."),
+    body: z13.string().describe("(string): The markdown content of the notification.")
+  }),
+  execute: (knockClient, config) => async (params) => {
+    const workflow2 = await knockClient.workflows.retrieve(params.workflowKey, {
+      environment: config.environment ?? "development"
+    });
+    const chatChannelsPage = await knockClient.channels.list();
+    const chatChannels = chatChannelsPage.entries.filter(
+      (channel) => channel.type === "chat"
+    );
+    if (chatChannels.length === 0) {
+      throw new Error("No chat channels found");
+    }
+    return await updateWorkflowWithStep(
+      knockClient,
+      workflow2,
+      // @ts-expect-error
+      {
+        type: "channel",
+        channel_key: chatChannels[0].key,
+        template: {
+          markdown_body: params.body
+        },
+        ref: generateStepRef("chat")
+      },
+      config.environment ?? "development"
+    );
+  }
+});
+var createDelayStepInWorkflow = KnockTool({
+  method: "create_delay_step_in_workflow",
+  name: "Create delay step in workflow",
+  description: `
+  Creates a delay step in a workflow. Use this tool when you're asked to add a delay to the workflow that pauses, or waits for a period of time before continuing.
+
+  ${SHARED_PROMPTS.workflow}
+  
+  Delays are specified in "unit" and "value" pairs. The only valid units are "seconds", "minutes", "hours", and "days".
+
+  <example>
+  {
+    "delayValue": 5,
+    "delayUnit": "minutes"
+  }
+  </example>
+  `,
+  parameters: z13.object({
+    workflowKey: z13.string().describe("(string): The key of the workflow to add the step to."),
+    delayValue: z13.number().describe("(number): The value of the delay."),
+    delayUnit: z13.enum(["seconds", "minutes", "hours", "days"]).describe("(enum): The unit of the delay.")
+  }),
+  execute: (knockClient, config) => async (params) => {
+    const workflow2 = await knockClient.workflows.retrieve(params.workflowKey, {
+      environment: config.environment ?? "development"
+    });
+    const workflowParams = {
+      environment: config.environment ?? "development",
+      workflow: {
+        ...workflow2,
+        steps: [
+          // @ts-expect-error
+          ...workflow2.steps,
+          // @ts-expect-error
+          {
+            type: "delay",
+            settings: {
+              delay_for: {
+                value: params.delayValue,
+                unit: params.delayUnit
+              }
+            },
+            ref: generateStepRef("delay")
+          }
+        ]
+      }
+    };
+    const result = await knockClient.workflows.upsert(
+      params.workflowKey,
+      workflowParams
+    );
+    return serializeWorkflowResponse(result.workflow);
+  }
+});
+var createBatchStepInWorkflow = KnockTool({
+  method: "create_batch_step_in_workflow",
+  name: "Create batch step in workflow",
+  description: `
+  Creates a batch step in a workflow. Use this tool when you're asked to create a batch step or asked to add digesting behavior to a workflow. The batch step collects multiple workflow triggers for a single recipient over a period of time and then flushes the content to the next step.
+
+  ${SHARED_PROMPTS.workflow}
+
+  Batch windows are specified in "unit" and "value" pairs. The only valid units are "seconds", "minutes", "hours", and "days".
+
+  <example>
+  {
+    "batchWindow": {
+      "value": 5,
+      "unit": "minutes"
+    }
+  }
+  </example>
+  `,
+  parameters: z13.object({
+    workflowKey: z13.string().describe("(string): The key of the workflow to add the step to."),
+    batchWindow: z13.object({
+      value: z13.number().describe("(number): The value of the batch window."),
+      unit: z13.enum(["seconds", "minutes", "hours", "days"]).describe("(enum): The unit of the batch window.")
+    })
+  }),
+  execute: (knockClient, config) => async (params) => {
+    const workflow2 = await knockClient.workflows.retrieve(params.workflowKey, {
+      environment: config.environment ?? "development"
+    });
+    return await updateWorkflowWithStep(
+      knockClient,
+      workflow2,
+      // @ts-expect-error
+      {
+        type: "batch",
+        settings: {
+          batch_window: {
+            value: params.batchWindow.value,
+            unit: params.batchWindow.unit
+          }
+        },
+        ref: generateStepRef("batch")
+      },
+      config.environment ?? "development"
+    );
+  }
+});
+var workflowStepTools = {
+  // Channel steps
+  createEmailStepInWorkflow,
+  createSmsStepInWorkflow,
+  createPushStepInWorkflow,
+  createInAppFeedStepInWorkflow,
+  createChatStepInWorkflow,
+  // Function steps
+  createDelayStepInWorkflow,
+  createBatchStepInWorkflow
+};
+
+// src/lib/tools/workflows.ts
 function serializeWorkflowResponse(workflow2) {
   return {
     key: workflow2.key,
@@ -1033,8 +1530,8 @@ var listWorkflows = KnockTool({
 
   Use this tool when you need to understand which workflows are available to be called.
   `,
-  parameters: z13.object({
-    environment: z13.string().optional().describe(
+  parameters: z14.object({
+    environment: z14.string().optional().describe(
       "(string): The environment to list workflows for. Defaults to `development`."
     )
   }),
@@ -1055,11 +1552,11 @@ var getWorkflow = KnockTool({
   description: `
   Get a workflow by key. Returns structural information about the workflow, including the key, name, description, and categories.
   `,
-  parameters: z13.object({
-    environment: z13.string().optional().describe(
+  parameters: z14.object({
+    environment: z14.string().optional().describe(
       "(string): The environment to get the workflow for. Defaults to `development`."
     ),
-    workflowKey: z13.string().describe("(string): The key of the workflow to get.")
+    workflowKey: z14.string().describe("(string): The key of the workflow to get.")
   }),
   execute: (knockClient, config) => async (params) => {
     const workflow2 = await knockClient.workflows.retrieve(params.workflowKey, {
@@ -1080,16 +1577,16 @@ var triggerWorkflow = KnockTool({
 
   Returns the workflow run ID, which can be used to lookup messages produced by the workflow.
   `,
-  parameters: z13.object({
-    environment: z13.string().optional().describe(
+  parameters: z14.object({
+    environment: z14.string().optional().describe(
       "(string): The environment to trigger the workflow in. Defaults to `development`."
     ),
-    workflowKey: z13.string().describe("(string): The key of the workflow to trigger."),
-    recipients: z13.array(z13.string()).optional().describe(
+    workflowKey: z14.string().describe("(string): The key of the workflow to trigger."),
+    recipients: z14.array(z14.string()).optional().describe(
       "(array): The recipients to trigger the workflow for. This is an array of user IDs."
     ),
-    data: z13.record(z13.string(), z13.any()).optional().describe("(object): Data to pass to the workflow."),
-    tenant: z13.record(z13.string(), z13.any()).optional().describe(
+    data: z14.record(z14.string(), z14.any()).optional().describe("(object): Data to pass to the workflow."),
+    tenant: z14.record(z14.string(), z14.any()).optional().describe(
       "(object): The tenant to trigger the workflow for. Must contain an id if being sent."
     )
   }),
@@ -1103,80 +1600,30 @@ var triggerWorkflow = KnockTool({
     return result.workflow_run_id;
   }
 });
-var createEmailWorkflow = KnockTool({
-  method: "create_email_workflow",
-  name: "Create email workflow",
+var createWorkflow = KnockTool({
+  method: "create_workflow",
+  name: "Create workflow",
   description: `
-  Creates a simple email workflow with a single step that sends an email to the recipient. Use this tool when you need to need to create an email notification, and you don't need to specify any additional steps. You can only create workflows in the development environment.
-
-  The content of the email you supply should ONLY ever be in markdown format for simplicity. You can supply dynamic variables to the subject and body of the email using the liquid template language.
-
-  When writing markdown, be sure to use headings (##) to separate sections of the email. Use an informal writing style, and avoid using complex language.
-
-  The following variables are available to use in the email subject and body:
-
-  - \`recipient.name\`: The name of the recipient.
-  - \`recipient.email\`: The email of the recipient.
-  - \`recipient.phone_number\`: The phone number of the recipient.
-  - \`tenant.id\`: The id of the tenant.
-  - \`tenant.name\`: The name of the tenant.
-
-  You can supply any other dynamic variables by referencing them under the \`data\` key in the \`data\` parameter when triggering the workflow. You add those like \`{{ data.variable_name }}\`.
-
-  You can also supply a list of categories to the workflow. These are used to categorize workflows for notification preferences. Categories should be supplied as lowercase strings in kebab case.
-
-  Once you've created the workflow, you should ask if you should commit the changes to the environment.
+  Create a new workflow, which is used to control the flow of notifications. Use this tool when you're asked to create a new workflow, or you need to create a new workflow before adding a step to it.
   `,
-  parameters: z13.object({
-    environment: z13.string().optional().describe(
+  parameters: z14.object({
+    environment: z14.string().optional().describe(
       "(string): The environment to create the workflow in. Defaults to `development`."
     ),
-    workflowKey: z13.string().describe("(string): The key of the workflow."),
-    name: z13.string().describe("(string): The name of the workflow."),
-    categories: z13.array(z13.string()).optional().describe("(array): The categories to add to the workflow."),
-    subject: z13.string().describe("(string): The subject of the email."),
-    body: z13.string().describe("(string): The body of the email.")
+    name: z14.string().describe("(string): The name of the workflow."),
+    description: z14.string().describe("(string): The description of the workflow."),
+    categories: z14.array(z14.string()).describe("(array): The categories to add to the workflow.")
   }),
   execute: (knockClient, config) => async (params) => {
-    const emailChannelsPage = await knockClient.channels.list();
-    const emailChannels = emailChannelsPage.entries.filter(
-      (channel) => channel.type === "email"
-    );
-    if (emailChannels.length === 0) {
-      throw new Error("No email channels found");
-    }
-    const workflowParams = {
-      environment: params.environment ?? config.environment ?? "development",
+    const result = await knockClient.workflows.upsert(params.workflowKey, {
+      environment: config.environment ?? "development",
       workflow: {
         name: params.name,
+        description: params.description,
         categories: params.categories ?? [],
-        steps: [
-          {
-            type: "channel",
-            channel_key: emailChannels[0].key,
-            template: {
-              settings: {
-                layout_key: "default"
-              },
-              subject: params.subject,
-              visual_blocks: [
-                // @ts-ignore
-                {
-                  type: "markdown",
-                  content: params.body
-                }
-              ]
-            },
-            name: "Email",
-            ref: "email_1"
-          }
-        ]
+        steps: []
       }
-    };
-    const result = await knockClient.workflows.upsert(
-      params.workflowKey,
-      workflowParams
-    );
+    });
     return serializeWorkflowResponse(result.workflow);
   }
 });
@@ -1194,18 +1641,18 @@ var createOneOffWorkflowSchedule = KnockTool({
   - In one hour, send a password reset email to a user
   - In two weeks, send a survey to a user
   `,
-  parameters: z13.object({
-    environment: z13.string().optional().describe(
+  parameters: z14.object({
+    environment: z14.string().optional().describe(
       "(string): The environment to create the workflow in. Defaults to `development`."
     ),
-    workflowKey: z13.string().describe("(string): The key of the workflow to schedule."),
-    userId: z13.string().describe(
+    workflowKey: z14.string().describe("(string): The key of the workflow to schedule."),
+    userId: z14.string().describe(
       "(string): The userId of the user to schedule the workflow for."
     ),
-    scheduledAt: z13.string().describe(
+    scheduledAt: z14.string().describe(
       "(string): The date and time to schedule the workflow for. Must be in ISO 8601 format."
     ),
-    data: z13.record(z13.string(), z13.any()).optional().describe("(object): Data to pass to the workflow.")
+    data: z14.record(z14.string(), z14.any()).optional().describe("(object): Data to pass to the workflow.")
   }),
   execute: (knockClient, config) => async (params) => {
     const publicClient = await knockClient.publicApi(params.environment);
@@ -1220,12 +1667,15 @@ var workflows = {
   listWorkflows,
   getWorkflow,
   triggerWorkflow,
-  createEmailWorkflow,
+  createWorkflow,
+  ...workflowStepTools,
   createOneOffWorkflowSchedule
 };
 var permissions12 = {
   read: ["listWorkflows", "getWorkflow"],
-  manage: ["createEmailWorkflow", "createOneOffWorkflowSchedule"],
+  manage: ["createWorkflow", "createOneOffWorkflowSchedule"].concat(
+    ...Object.keys(workflowStepTools)
+  ),
   run: ["triggerWorkflow"]
 };
 
@@ -1281,4 +1731,4 @@ export {
   getToolsByPermissionsInCategories,
   getToolMap
 };
-//# sourceMappingURL=chunk-6UHXLKAV.js.map
+//# sourceMappingURL=chunk-URQB3FDZ.js.map