@knocklabs/agent-toolkit 0.1.6 → 0.1.8

package/dist/{chunk-3NU2K26A.js → chunk-JBEVT2QK.js}

@@ -25,6 +25,14 @@ var KnockTool = (args) => {
 };
 
 // src/lib/tools/channels.ts
+function serializeChannelResponse(channel) {
+  return {
+    key: channel.key,
+    name: channel.name,
+    type: channel.type,
+    provider: channel.provider
+  };
+}
 var listChannels = KnockTool({
   method: "list_channels",
   name: "List channels",
@@ -33,10 +41,10 @@ var listChannels = KnockTool({
 
   Use this tool when you need to know about the channels configured in the Knock account, like when configuring a workflow.
   `,
-  execute: (knockClient) => async (params) => {
+  execute: (knockClient) => async (_params) => {
     const allChannels = [];
     for await (const channel of knockClient.channels.list()) {
-      allChannels.push(channel);
+      allChannels.push(serializeChannelResponse(channel));
     }
     return allChannels;
   }
@@ -99,7 +107,7 @@ var promoteAllCommits = KnockTool({
   parameters: z2.object({
     toEnvironment: z2.string().describe("(string): The environment to promote all commits to.")
   }),
-  execute: (knockClient, config) => async (params) => {
+  execute: (knockClient, _config) => async (params) => {
     return await knockClient.put("/v1/commits/promote", {
       body: { to_environment: params.toEnvironment }
     });
@@ -115,16 +123,50 @@ var permissions2 = {
   manage: ["commitAllChanges", "promoteAllCommits"]
 };
 
-// src/lib/tools/email-layouts.ts
+// src/lib/tools/documentation.ts
 import { z as z3 } from "zod";
+var searchDocumentation = KnockTool({
+  method: "search_documentation",
+  name: "Search documentation",
+  description: "Search the Knock documentation for a given query",
+  parameters: z3.object({
+    query: z3.string().describe("The query to search the documentation for")
+  }),
+  execute: () => async (params) => {
+    const response = await fetch(`https://docs.knock.app/api/search`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ query: params.query })
+    });
+    const data = await response.json();
+    return data;
+  }
+});
+var documentation = {
+  searchDocumentation
+};
+var permissions3 = {
+  read: ["searchDocumentation"]
+};
+
+// src/lib/tools/email-layouts.ts
+import { z as z4 } from "zod";
+function serializeEmailLayoutResponse(emailLayout) {
+  return {
+    key: emailLayout.key,
+    name: emailLayout.name
+  };
+}
 var listEmailLayouts = KnockTool({
   method: "list_email_layouts",
   name: "List email layouts",
   description: `List all email layouts within the environment given. Returns information about the email layout, including the name and the key. 
   
   Use this tool when building a workflow that is building an email notification when you need to know the available email layouts.`,
-  parameters: z3.object({
-    environment: z3.string().optional().describe(
+  parameters: z4.object({
+    environment: z4.string().optional().describe(
       "(string): The environment to list email layouts for. Defaults to `development`."
     )
   }),
@@ -133,7 +175,7 @@ var listEmailLayouts = KnockTool({
     for await (const emailLayout of knockClient.emailLayouts.list({
       environment: params.environment ?? config.environment ?? "development"
     })) {
-      allEmailLayouts.push(emailLayout);
+      allEmailLayouts.push(serializeEmailLayoutResponse(emailLayout));
     }
     return allEmailLayouts;
   }
@@ -141,21 +183,27 @@ var listEmailLayouts = KnockTool({
 var emailLayouts = {
   listEmailLayouts
 };
-var permissions3 = {
+var permissions4 = {
   read: ["listEmailLayouts"]
 };
 
 // src/lib/tools/environments.ts
+function serializeEnvironmentResponse(environment) {
+  return {
+    slug: environment.slug,
+    name: environment.name
+  };
+}
 var listEnvironments = KnockTool({
   method: "list_environments",
   name: "List environments",
   description: `
-  Lists all environments available, returning the slug, name, and the order of each environment. Use this tool when you need to see what environments are available to deploy to.
+  Lists all environments available, returning the slug and name of each environment. Use this tool when you need to see what environments are available.
   `,
-  execute: (knockClient) => async (params) => {
+  execute: (knockClient) => async (_params) => {
     const allEnvironments = [];
     for await (const environment of knockClient.environments.list()) {
-      allEnvironments.push(environment);
+      allEnvironments.push(serializeEnvironmentResponse(environment));
     }
     return allEnvironments;
   }
@@ -163,38 +211,20 @@ var listEnvironments = KnockTool({
 var environments = {
   listEnvironments
 };
-var permissions4 = {
-  read: ["listEnvironments"]
-};
-
-// src/lib/tools/messages.ts
-import { z as z4 } from "zod";
-var getMessageContent = KnockTool({
-  method: "get_message_content",
-  name: "Get message content",
-  description: `
-  Retrieves the complete contents of a single message, specified by the messageId. The message contents includes the rendered template that was sent to the recipient. Use this tool when you want to surface information about the emails, SMS, and push notifications that were sent to a user.
-  `,
-  parameters: z4.object({
-    environment: z4.string().optional().describe(
-      "(string): The environment to retrieve the message from. Defaults to `development`."
-    ),
-    messageId: z4.string().describe("(string): The messageId of the message to retrieve.")
-  }),
-  execute: (knockClient) => async (params) => {
-    const publicClient = await knockClient.publicApi(params.environment);
-    return await publicClient.messages.getContent(params.messageId);
-  }
-});
-var messages = {
-  getMessageContent
-};
 var permissions5 = {
-  read: ["getMessageContent"]
+  read: ["listEnvironments"]
 };
 
 // src/lib/tools/message-types.ts
 import { z as z5 } from "zod";
+function serializeMessageTypeResponse(messageType) {
+  return {
+    key: messageType.key,
+    name: messageType.name,
+    description: messageType.description,
+    variants: messageType.variants.map((variant) => variant.key)
+  };
+}
 var listMessageTypes = KnockTool({
   method: "list_message_types",
   name: "List message types",
@@ -209,7 +239,7 @@ var listMessageTypes = KnockTool({
     for await (const messageType of knockClient.messageTypes.list({
       environment: params.environment ?? config.environment ?? "development"
     })) {
-      allMessageTypes.push(messageType);
+      allMessageTypes.push(serializeMessageTypeResponse(messageType));
     }
     return allMessageTypes;
   }
@@ -361,19 +391,45 @@ var permissions6 = {
   manage: ["createOrUpdateMessageType"]
 };
 
-// src/lib/tools/objects.ts
+// src/lib/tools/messages.ts
 import { z as z6 } from "zod";
+var getMessageContent = KnockTool({
+  method: "get_message_content",
+  name: "Get message content",
+  description: `
+  Retrieves the complete contents of a single message, specified by the messageId. The message contents includes the rendered template that was sent to the recipient. Use this tool when you want to surface information about the emails, SMS, and push notifications that were sent to a user.
+  `,
+  parameters: z6.object({
+    environment: z6.string().optional().describe(
+      "(string): The environment to retrieve the message from. Defaults to `development`."
+    ),
+    messageId: z6.string().describe("(string): The messageId of the message to retrieve.")
+  }),
+  execute: (knockClient) => async (params) => {
+    const publicClient = await knockClient.publicApi(params.environment);
+    return await publicClient.messages.getContent(params.messageId);
+  }
+});
+var messages = {
+  getMessageContent
+};
+var permissions7 = {
+  read: ["getMessageContent"]
+};
+
+// src/lib/tools/objects.ts
+import { z as z7 } from "zod";
 var listObjects = KnockTool({
   method: "list_objects",
   name: "List objects",
   description: "List all objects in a single collection. Objects are used to model custom collections in Knock that are NOT users or tenants. Use this tool when you need to return a paginated list of objects in a single collection.",
-  parameters: z6.object({
-    environment: z6.string().optional().describe(
+  parameters: z7.object({
+    environment: z7.string().optional().describe(
       "(string): The environment to list objects from. Defaults to `development`."
     ),
-    collection: z6.string().describe("(string): The collection to list objects from.")
+    collection: z7.string().describe("(string): The collection to list objects from.")
   }),
-  execute: (knockClient, config) => async (params) => {
+  execute: (knockClient, _config) => async (params) => {
     const publicClient = await knockClient.publicApi(params.environment);
     return await publicClient.objects.list(params.collection);
   }
@@ -382,14 +438,14 @@ var getObject = KnockTool({
   method: "get_object",
   name: "Get object",
   description: "Get an object wihin a collection. Returns information about the object including any custom properties. Use this tool when you need to retrieve an object to understand it's properties.",
-  parameters: z6.object({
-    environment: z6.string().optional().describe(
+  parameters: z7.object({
+    environment: z7.string().optional().describe(
       "(string): The environment to get the object from. Defaults to `development`."
     ),
-    collection: z6.string().describe("(string): The collection to get the object from."),
-    objectId: z6.string().describe("(string): The ID of the object to get.")
+    collection: z7.string().describe("(string): The collection to get the object from."),
+    objectId: z7.string().describe("(string): The ID of the object to get.")
   }),
-  execute: (knockClient, config) => async (params) => {
+  execute: (knockClient, _config) => async (params) => {
     const publicClient = await knockClient.publicApi(params.environment);
     return await publicClient.objects.get(params.collection, params.objectId);
   }
@@ -400,15 +456,15 @@ var createOrUpdateObject = KnockTool({
   description: `Create or update an object in a specific collection. Objects are used to model custom collections in Knock that are NOT users or tenants. If the object does not exist, it will be created. If the object exists, it will be updated with the provided properties. The update will always perform an upsert operation, so you do not need to provide the full properties each time.
   
   Use this tool when you need to create a new object, or update an existing custom-object. Custom objects can be used to subscribe users' to as lists, and also send non-user facing notifications to.`,
-  parameters: z6.object({
-    environment: z6.string().optional().describe(
+  parameters: z7.object({
+    environment: z7.string().optional().describe(
       "(string): The environment to create or update the object in. Defaults to `development`."
     ),
-    collection: z6.string().describe("(string): The collection to create or update the object in."),
-    objectId: z6.string().describe("(string): The ID of the object to create or update."),
-    properties: z6.record(z6.string(), z6.any()).optional().describe("(object): The properties to set on the object.")
+    collection: z7.string().describe("(string): The collection to create or update the object in."),
+    objectId: z7.string().describe("(string): The ID of the object to create or update."),
+    properties: z7.record(z7.string(), z7.any()).optional().describe("(object): The properties to set on the object.")
   }),
-  execute: (knockClient, config) => async (params) => {
+  execute: (knockClient, _config) => async (params) => {
     const publicClient = await knockClient.publicApi(params.environment);
     return await publicClient.objects.set(
       params.collection,
@@ -427,13 +483,13 @@ var subscribeUsersToObject = KnockTool({
 
   Before using this tool, you should create the object in the collection using the createOrUpdateObject tool.
   `,
-  parameters: z6.object({
-    environment: z6.string().optional().describe(
+  parameters: z7.object({
+    environment: z7.string().optional().describe(
       "(string): The environment to subscribe the user to. Defaults to `development`."
     ),
-    collection: z6.string().describe("(string): The collection to subscribe the user to."),
-    objectId: z6.string().describe("(string): The ID of the object to subscribe the user to."),
-    userIds: z6.array(z6.string()).describe(
+    collection: z7.string().describe("(string): The collection to subscribe the user to."),
+    objectId: z7.string().describe("(string): The ID of the object to subscribe the user to."),
+    userIds: z7.array(z7.string()).describe(
       "(array): The IDs of the users to subscribe to the object. If not provided, the current user will be subscribed."
     )
   }),
@@ -454,13 +510,13 @@ var unsubscribeUsersFromObject = KnockTool({
   description: `Unsubscribe a list of users from an object in a specific collection. We use this to model lists of users, for pub-sub use cases.
   
   Use this tool when you need to unsubscribe one or more users from an object where you will then trigger workflows for those lists of users to send notifications to.`,
-  parameters: z6.object({
-    environment: z6.string().optional().describe(
+  parameters: z7.object({
+    environment: z7.string().optional().describe(
       "(string): The environment to unsubscribe the user from. Defaults to `development`."
     ),
-    collection: z6.string().describe("(string): The collection to unsubscribe the user from."),
-    objectId: z6.string().describe("(string): The ID of the object to unsubscribe the user from."),
-    userIds: z6.array(z6.string()).describe(
+    collection: z7.string().describe("(string): The collection to unsubscribe the user from."),
+    objectId: z7.string().describe("(string): The ID of the object to unsubscribe the user from."),
+    userIds: z7.array(z7.string()).describe(
       "(array): The IDs of the users to unsubscribe from the object."
     )
   }),
@@ -482,7 +538,7 @@ var objects = {
   subscribeUsersToObject,
   unsubscribeUsersFromObject
 };
-var permissions7 = {
+var permissions8 = {
   read: ["listObjects", "getObject"],
   manage: [
     "createOrUpdateObject",
@@ -492,15 +548,23 @@ var permissions7 = {
 };
 
 // src/lib/tools/partials.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
+function serializePartial(partial) {
+  return {
+    key: partial.key,
+    type: partial.type,
+    name: partial.name,
+    description: partial.description
+  };
+}
 var listPartials = KnockTool({
   method: "list_partials",
   name: "List partials",
   description: `
   List all partials within the environment given. Partials provide common building blocks for notification templates. Returns information about the partial, including the name and the key.  
   Use this tool when you need to know the available partials for the environment, like when building a notification template and wanting to use a partial to build the template.`,
-  parameters: z7.object({
-    environment: z7.string().optional().describe(
+  parameters: z8.object({
+    environment: z8.string().optional().describe(
       "(string): The environment to list partials for. Defaults to `development`."
     )
   }),
@@ -509,7 +573,7 @@ var listPartials = KnockTool({
     for await (const partial of knockClient.partials.list({
       environment: params.environment ?? config.environment ?? "development"
     })) {
-      allPartials.push(partial);
+      allPartials.push(serializePartial(partial));
     }
     return allPartials;
   }
@@ -517,12 +581,12 @@ var listPartials = KnockTool({
 var partials = {
   listPartials
 };
-var permissions8 = {
+var permissions9 = {
   read: ["listPartials"]
 };
 
 // src/lib/tools/tenants.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var getTenant = KnockTool({
   method: "get_tenant",
   name: "Get tenant",
@@ -531,11 +595,11 @@ var getTenant = KnockTool({
   
   Use this tool when you need to lookup the information about a tenant, including name, and if there are any custom properties set.
   `,
-  parameters: z8.object({
-    environment: z8.string().optional().describe(
+  parameters: z9.object({
+    environment: z9.string().optional().describe(
       "(string): The environment to retrieve the tenant from. Defaults to `development`."
     ),
-    tenantId: z8.string().describe("(string): The ID of the tenant to retrieve.")
+    tenantId: z9.string().describe("(string): The ID of the tenant to retrieve.")
   }),
   execute: (knockClient) => async (params) => {
     const publicClient = await knockClient.publicApi(params.environment);
@@ -550,8 +614,8 @@ var listTenants = KnockTool({
   
   Use this tool when you need to list all tenants in an environment.
   `,
-  parameters: z8.object({
-    environment: z8.string().optional().describe(
+  parameters: z9.object({
+    environment: z9.string().optional().describe(
       "(string): The environment to retrieve the tenants from. Defaults to `development`."
     )
   }),
@@ -568,13 +632,13 @@ var setTenant = KnockTool({
   
   Use this tool when you need to create a new tenant, or update an existing tenant's properties.
   `,
-  parameters: z8.object({
-    environment: z8.string().optional().describe(
+  parameters: z9.object({
+    environment: z9.string().optional().describe(
       "(string): The environment to set the tenant in. Defaults to `development`."
     ),
-    tenantId: z8.string().describe("(string): The ID of the tenant to update."),
-    name: z8.string().optional().describe("(string): The name of the tenant."),
-    properties: z8.record(z8.string(), z8.any()).optional().describe("(object): The properties to set on the tenant.")
+    tenantId: z9.string().describe("(string): The ID of the tenant to update."),
+    name: z9.string().optional().describe("(string): The name of the tenant."),
+    properties: z9.record(z9.string(), z9.any()).optional().describe("(object): The properties to set on the tenant.")
   }),
   execute: (knockClient) => async (params) => {
     const publicClient = await knockClient.publicApi(params.environment);
@@ -589,13 +653,163 @@ var tenants = {
   listTenants,
   setTenant
 };
-var permissions9 = {
+var permissions10 = {
   read: ["getTenant", "listTenants"],
   manage: ["setTenant"]
 };
 
 // src/lib/tools/users.ts
-import { z as z9 } from "zod";
+import { z as z12 } from "zod";
+
+// src/lib/tools/workflows-as-tools.ts
+import jsonSchemaToZod from "json-schema-to-zod";
+import { z as z11 } from "zod";
+
+// src/lib/tools/shared.ts
+import { z as z10 } from "zod";
+var recipientSchema = z10.union([
+  z10.string().describe("A user ID (string)."),
+  z10.object({ id: z10.string(), collection: z10.string() }).describe("A reference to an object in a collection.")
+]).describe(
+  "A recipient can be a user ID or a reference to an object in a collection."
+);
+
+// src/lib/tools/workflows-as-tools.ts
+function workflowAsTool(workflow) {
+  return KnockTool({
+    method: `trigger_${workflow.key.replace("-", "_")}_workflow`,
+    name: `Trigger ${workflow.name} workflow`,
+    description: `Triggers the ${workflow.name} workflow. Use this tool when you're asked to notify, send, or trigger for ${workflow.name} or ${workflow.key}.
+
+    ${workflow.description ? `Additional information to consider on when to use this tool: ${workflow.description}` : ""}
+    
+    Returns the workflow run ID, which can be used to lookup messages produced by the workflow.`,
+    parameters: z11.object({
+      environment: z11.string().optional(),
+      actor: recipientSchema.optional().describe("An optional actor to trigger the workflow with."),
+      recipients: z11.array(recipientSchema).describe(
+        "An optional array of recipients to trigger the workflow with."
+      ).optional(),
+      // Here we dynamically generate a zod schema from the workflow's `trigger_data_json_schema`
+      // This allows us to validate the data passed to the workflow
+      data: workflow.trigger_data_json_schema ? eval(jsonSchemaToZod(workflow.trigger_data_json_schema)).describe(
+        "The data to pass to the workflow."
+      ) : z11.record(z11.string(), z11.any()).optional().describe("The data to pass to the workflow."),
+      tenant: z11.string().optional().describe("The tenant ID to trigger the workflow for.")
+    }),
+    execute: (knockClient, config) => async (params) => {
+      const publicClient = await knockClient.publicApi(params.environment);
+      const result = await publicClient.workflows.trigger(workflow.key, {
+        recipients: [params.userId ?? config.userId],
+        actor: params.actor,
+        data: params.data,
+        tenant: params.tenant ?? config.tenantId
+      });
+      return result.workflow_run_id;
+    }
+  });
+}
+async function createWorkflowTools(knockClient, config, workflowKeysToInclude) {
+  const workflows2 = [];
+  for await (const workflow2 of knockClient.workflows.list({
+    environment: config.environment ?? "development"
+  })) {
+    if (workflowKeysToInclude && !workflowKeysToInclude.includes(workflow2.key)) {
+      continue;
+    }
+    workflows2.push(workflow2);
+  }
+  return workflows2.map((workflow2) => workflowAsTool(workflow2));
+}
+
+// src/lib/utils.ts
+function filterTools(tools2, pattern) {
+  if (!pattern) {
+    throw new Error("No pattern provided");
+  }
+  if (pattern === "*") {
+    return Object.values(tools2).flatMap((category2) => Object.values(category2));
+  }
+  const [category, tool] = pattern.split(".");
+  if (category === "*" && tool === "*") {
+    return Object.values(tools2).flatMap((category2) => Object.values(category2));
+  }
+  if (category && !tools2[category]) {
+    throw new Error(`Tool category ${category} not found`);
+  }
+  if (category && tool === "*") {
+    return Object.values(tools2[category]);
+  }
+  if (category && tool && !tools2[category][tool]) {
+    throw new Error(`Tool ${pattern} not found`);
+  }
+  return [tools2[category][tool]];
+}
+function getToolsWithPermissions(category, categoryPermissions) {
+  const toolsInCategory = tools[category];
+  const toolPermissionsInCategory = toolPermissions[category];
+  return Object.entries(categoryPermissions).reduce(
+    (acc, [permissionType, hasPermission]) => {
+      if (Array.isArray(hasPermission) && hasPermission.length > 0 || hasPermission === true) {
+        return acc.concat(
+          toolPermissionsInCategory[permissionType].map(
+            (toolName) => toolsInCategory[toolName]
+          )
+        );
+      }
+      return acc;
+    },
+    []
+  );
+}
+async function getToolsByPermissionsInCategories(knockClient, config) {
+  const toolsByCategory = Object.keys(config.permissions).reduce(
+    (acc, category) => {
+      const categoryKey = category;
+      const categoryPermissions = config.permissions[categoryKey];
+      if (tools[categoryKey] && categoryPermissions) {
+        const tools2 = getToolsWithPermissions(categoryKey, categoryPermissions);
+        return { ...acc, [categoryKey]: tools2 };
+      }
+      return acc;
+    },
+    {}
+  );
+  if (config.permissions.workflows?.run) {
+    const workflowTools = await createWorkflowTools(knockClient, config);
+    toolsByCategory.workflows = [
+      ...toolsByCategory.workflows,
+      ...workflowTools
+    ];
+  }
+  return toolsByCategory;
+}
+function getToolMap(tools2) {
+  return tools2.reduce(
+    (acc, tool) => {
+      acc[tool.method] = tool;
+      return acc;
+    },
+    {}
+  );
+}
+function serializeMessageResponse(message) {
+  return {
+    id: message.id,
+    status: message.status,
+    engagement_statuses: message.engagement_statuses,
+    data: message.data,
+    metadata: message.metadata
+  };
+}
+
+// src/lib/tools/users.ts
+function maybeHideUserData(user, hideUserData = false) {
+  if (hideUserData) {
+    return { id: user.id };
+  }
+  return user;
+}
 var getUser = KnockTool({
   method: "get_user",
   name: "Get user",
@@ -604,15 +818,16 @@ var getUser = KnockTool({
 
    If the userId is not provided, it will use the userId from the config.
    `,
-  parameters: z9.object({
-    environment: z9.string().optional().describe(
+  parameters: z12.object({
+    environment: z12.string().optional().describe(
       "(string): The environment to retrieve the user from. Defaults to `development`."
     ),
-    userId: z9.string().optional().describe("(string): The userId of the User to retrieve.")
+    userId: z12.string().optional().describe("(string): The userId of the User to retrieve.")
   }),
   execute: (knockClient, config) => async (params) => {
     const publicClient = await knockClient.publicApi(params.environment);
-    return await publicClient.users.get(params.userId ?? config.userId);
+    const user = await publicClient.users.get(params.userId ?? config.userId);
+    return maybeHideUserData(user, config.hideUserData);
   }
 });
 var createOrUpdateUser = KnockTool({
@@ -625,26 +840,30 @@ var createOrUpdateUser = KnockTool({
 
   If the userId is not provided, it will use the userId from the config.
   `,
-  parameters: z9.object({
-    environment: z9.string().optional().describe(
+  parameters: z12.object({
+    environment: z12.string().optional().describe(
       "(string): The environment to create or update the user in. Defaults to `development`."
     ),
-    userId: z9.string().optional().describe("(string): The userId of the User to update."),
-    email: z9.string().optional().describe("(string): The email of the User to update."),
-    name: z9.string().optional().describe("(string): The name of the User to update."),
-    phoneNumber: z9.string().optional().describe("(string): The phone number of the User to update."),
-    customProperties: z9.record(z9.string(), z9.any()).optional().describe(
+    userId: z12.string().optional().describe("(string): The userId of the User to update."),
+    email: z12.string().optional().describe("(string): The email of the User to update."),
+    name: z12.string().optional().describe("(string): The name of the User to update."),
+    phoneNumber: z12.string().optional().describe("(string): The phone number of the User to update."),
+    customProperties: z12.record(z12.string(), z12.any()).optional().describe(
       "(object): A dictionary of custom properties to update for the User."
     )
   }),
   execute: (knockClient, config) => async (params) => {
     const publicClient = await knockClient.publicApi(params.environment);
-    return await publicClient.users.identify(params.userId ?? config.userId, {
-      email: params.email,
-      name: params.name,
-      phone_number: params.phoneNumber,
-      ...params.customProperties ?? {}
-    });
+    const user = await publicClient.users.identify(
+      params.userId ?? config.userId,
+      {
+        email: params.email,
+        name: params.name,
+        phone_number: params.phoneNumber,
+        ...params.customProperties ?? {}
+      }
+    );
+    return maybeHideUserData(user, config.hideUserData);
   }
 });
 var getUserPreferences = KnockTool({
@@ -655,14 +874,14 @@ var getUserPreferences = KnockTool({
 
   If the userId is not provided, it will use the userId from the config. 
   `,
-  parameters: z9.object({
-    environment: z9.string().optional().describe(
+  parameters: z12.object({
+    environment: z12.string().optional().describe(
       "(string): The environment to retrieve the user preferences from. Defaults to `development`."
     ),
-    userId: z9.string().optional().describe(
+    userId: z12.string().optional().describe(
       "(string): The userId of the User to retrieve Preferences for."
     ),
-    preferenceSetId: z9.string().optional().describe(
+    preferenceSetId: z12.string().optional().describe(
       "(string): The preferenceSetId of the User to retrieve preferences for. Defaults to `default`."
     )
   }),
@@ -711,18 +930,18 @@ var setUserPreferences = KnockTool({
     </example>
   </examples>
   `,
-  parameters: z9.object({
-    environment: z9.string().optional().describe(
+  parameters: z12.object({
+    environment: z12.string().optional().describe(
       "(string): The environment to set the user preferences in. Defaults to `development`."
     ),
-    userId: z9.string().optional().describe("(string): The userId of the User to update preferences for."),
-    workflows: z9.record(z9.string(), z9.any()).optional().describe(
+    userId: z12.string().optional().describe("(string): The userId of the User to update preferences for."),
+    workflows: z12.record(z12.string(), z12.any()).optional().describe(
       "(object): The workflows to update where the key is the workflow key, and the value of the object is an object that contains a `channel_types` key with a boolean value for each channel type."
     ),
-    categories: z9.record(z9.string(), z9.any()).optional().describe(
+    categories: z12.record(z12.string(), z12.any()).optional().describe(
       "(object): The categories to update where the key is the category key, and the value of the object is an object that contains a `channel_types` key with a boolean value for each channel type."
     ),
-    channel_types: z9.record(z9.string(), z9.boolean()).optional().describe(
+    channel_types: z12.record(z12.string(), z12.boolean()).optional().describe(
       "(object): The channel types to update where the key is the channel type, and the value of the object is a boolean value."
     )
   }),
@@ -763,23 +982,24 @@ var getUserMessages = KnockTool({
 
   If the userId is not provided, it will use the userId from the config.
   `,
-  parameters: z9.object({
-    environment: z9.string().optional().describe(
+  parameters: z12.object({
+    environment: z12.string().optional().describe(
       "(string): The environment to retrieve the user messages from. Defaults to `development`."
     ),
-    userId: z9.string().optional().describe("(string): The userId of the User to retrieve messages for."),
-    workflowRunId: z9.string().optional().describe(
+    userId: z12.string().optional().describe("(string): The userId of the User to retrieve messages for."),
+    workflowRunId: z12.string().optional().describe(
       "(string): The workflowRunId of the User to retrieve. Use this when you want to retrieve messages sent from a workflow trigger."
     )
   }),
   execute: (knockClient, config) => async (params) => {
     const publicClient = await knockClient.publicApi(params.environment);
-    return await publicClient.users.getMessages(
+    const messages2 = await publicClient.users.getMessages(
       params.userId ?? config.userId,
       {
         workflow_run_id: params.workflowRunId
       }
     );
+    return messages2.items.map(serializeMessageResponse);
   }
 });
 var users = {
@@ -789,23 +1009,32 @@ var users = {
   setUserPreferences,
   getUserMessages
 };
-var permissions10 = {
+var permissions11 = {
   read: ["getUser", "getUserMessages", "getUserPreferences"],
   manage: ["createOrUpdateUser", "setUserPreferences"]
 };
 
 // src/lib/tools/workflows.ts
-import { z as z10 } from "zod";
+import { z as z13 } from "zod";
+function serializeWorkflowResponse(workflow2) {
+  return {
+    key: workflow2.key,
+    name: workflow2.name,
+    description: workflow2.description,
+    categories: workflow2.categories,
+    schema: workflow2.trigger_data_json_schema
+  };
+}
 var listWorkflows = KnockTool({
   method: "list_workflows",
   name: "List workflows",
   description: `
-  List all workflows available for the given environment. Returns structural information about the workflows, including the key, name, description, and categories. Will also return the steps that make up the workflow. 
+  List all workflows available for the given environment. Returns structural information about the workflows, including the key, name, description, and categories.
 
-  Use this tool when you need to understand which workflows are available to be called. 
+  Use this tool when you need to understand which workflows are available to be called.
   `,
-  parameters: z10.object({
-    environment: z10.string().optional().describe(
+  parameters: z13.object({
+    environment: z13.string().optional().describe(
       "(string): The environment to list workflows for. Defaults to `development`."
     )
   }),
@@ -814,32 +1043,53 @@ var listWorkflows = KnockTool({
     const listParams = {
       environment: params.environment ?? config.environment ?? "development"
     };
-    for await (const workflow of knockClient.workflows.list(listParams)) {
-      allWorkflows.push(workflow);
+    for await (const workflow2 of knockClient.workflows.list(listParams)) {
+      allWorkflows.push(serializeWorkflowResponse(workflow2));
     }
     return allWorkflows;
   }
 });
+var getWorkflow = KnockTool({
+  method: "get_workflow",
+  name: "Get workflow",
+  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(
+      "(string): The environment to get the workflow for. Defaults to `development`."
+    ),
+    workflowKey: z13.string().describe("(string): The key of the workflow to get.")
+  }),
+  execute: (knockClient, config) => async (params) => {
+    const workflow2 = await knockClient.workflows.retrieve(params.workflowKey, {
+      environment: params.environment ?? config.environment ?? "development"
+    });
+    return serializeWorkflowResponse(workflow2);
+  }
+});
 var triggerWorkflow = KnockTool({
   method: "trigger_workflow",
   name: "Trigger workflow",
   description: `
   Trigger a workflow for one or more recipients, which may produce one or more messages for each recipient depending on the workflow's steps.
 
-  Use this tool when you need to trigger a workflow to send a notification across the channels configured for the workflow. The workflow must be committed in the environment for you to trigger it.
+  Use this tool when you need to trigger a workflow to send a notification across the channels configured for the workflow. 
 
   When recipients aren't provided, the workflow will be triggered for the current user specified in the config.
+
+  Returns the workflow run ID, which can be used to lookup messages produced by the workflow.
   `,
-  parameters: z10.object({
-    environment: z10.string().optional().describe(
+  parameters: z13.object({
+    environment: z13.string().optional().describe(
       "(string): The environment to trigger the workflow in. Defaults to `development`."
     ),
-    workflowKey: z10.string().describe("(string): The key of the workflow to trigger."),
-    recipients: z10.array(z10.string()).optional().describe(
+    workflowKey: z13.string().describe("(string): The key of the workflow to trigger."),
+    recipients: z13.array(z13.string()).optional().describe(
       "(array): The recipients to trigger the workflow for. This is an array of user IDs."
     ),
-    data: z10.record(z10.string(), z10.any()).optional().describe("(object): Data to pass to the workflow."),
-    tenant: z10.record(z10.string(), z10.any()).optional().describe(
+    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(
       "(object): The tenant to trigger the workflow for. Must contain an id if being sent."
     )
   }),
@@ -877,15 +1127,15 @@ var createEmailWorkflow = KnockTool({
 
   Once you've created the workflow, you should ask if you should commit the changes to the environment.
   `,
-  parameters: z10.object({
-    environment: z10.string().optional().describe(
+  parameters: z13.object({
+    environment: z13.string().optional().describe(
       "(string): The environment to create the workflow in. Defaults to `development`."
     ),
-    workflowKey: z10.string().describe("(string): The key of the workflow."),
-    name: z10.string().describe("(string): The name of the workflow."),
-    categories: z10.array(z10.string()).optional().describe("(array): The categories to add to the workflow."),
-    subject: z10.string().describe("(string): The subject of the email."),
-    body: z10.string().describe("(string): The body of the email.")
+    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.")
   }),
   execute: (knockClient, config) => async (params) => {
     const emailChannelsPage = await knockClient.channels.list();
@@ -923,10 +1173,11 @@ var createEmailWorkflow = KnockTool({
         ]
       }
     };
-    return await knockClient.workflows.upsert(
+    const result = await knockClient.workflows.upsert(
       params.workflowKey,
       workflowParams
     );
+    return serializeWorkflowResponse(result.workflow);
   }
 });
 var createOneOffWorkflowSchedule = KnockTool({
@@ -943,18 +1194,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: z10.object({
-    environment: z10.string().optional().describe(
+  parameters: z13.object({
+    environment: z13.string().optional().describe(
       "(string): The environment to create the workflow in. Defaults to `development`."
     ),
-    workflowKey: z10.string().describe("(string): The key of the workflow to schedule."),
-    userId: z10.string().describe(
+    workflowKey: z13.string().describe("(string): The key of the workflow to schedule."),
+    userId: z13.string().describe(
       "(string): The userId of the user to schedule the workflow for."
     ),
-    scheduledAt: z10.string().describe(
+    scheduledAt: z13.string().describe(
       "(string): The date and time to schedule the workflow for. Must be in ISO 8601 format."
     ),
-    data: z10.record(z10.string(), z10.any()).optional().describe("(object): Data to pass to the workflow.")
+    data: z13.record(z13.string(), z13.any()).optional().describe("(object): Data to pass to the workflow.")
   }),
   execute: (knockClient, config) => async (params) => {
     const publicClient = await knockClient.publicApi(params.environment);
@@ -967,12 +1218,13 @@ var createOneOffWorkflowSchedule = KnockTool({
 });
 var workflows = {
   listWorkflows,
+  getWorkflow,
   triggerWorkflow,
   createEmailWorkflow,
   createOneOffWorkflowSchedule
 };
-var permissions11 = {
-  read: ["listWorkflows"],
+var permissions12 = {
+  read: ["listWorkflows", "getWorkflow"],
   manage: ["createEmailWorkflow", "createOneOffWorkflowSchedule"],
   run: ["triggerWorkflow"]
 };
@@ -981,6 +1233,7 @@ var permissions11 = {
 var tools = {
   channels,
   commits,
+  documentation,
   emailLayouts,
   environments,
   messages,
@@ -994,6 +1247,7 @@ var tools = {
 var allTools = {
   ...channels,
   ...commits,
+  ...documentation,
   ...emailLayouts,
   ...environments,
   ...messageTypes,
@@ -1007,20 +1261,24 @@ var allTools = {
 var toolPermissions = {
   channels: permissions,
   commits: permissions2,
-  emailLayouts: permissions3,
-  environments: permissions4,
-  messages: permissions5,
+  documentation: permissions3,
+  emailLayouts: permissions4,
+  environments: permissions5,
+  messages: permissions7,
   messageTypes: permissions6,
-  objects: permissions7,
-  partials: permissions8,
-  tenants: permissions9,
-  users: permissions10,
-  workflows: permissions11
+  objects: permissions8,
+  partials: permissions9,
+  tenants: permissions10,
+  users: permissions11,
+  workflows: permissions12
 };
 
 export {
   tools,
   allTools,
-  toolPermissions
+  createWorkflowTools,
+  filterTools,
+  getToolsByPermissionsInCategories,
+  getToolMap
 };
-//# sourceMappingURL=chunk-3NU2K26A.js.map
+//# sourceMappingURL=chunk-JBEVT2QK.js.map