@clerk/agent-toolkit 0.0.6-canary.v20250306110334

package/dist/chunk-K5TBM24J.js

@@ -0,0 +1,648 @@
+// src/lib/clerk-client.ts
+import { createClerkClient } from "@clerk/backend";
+import { apiUrlFromPublishableKey } from "@clerk/shared/apiUrlFromPublishableKey";
+import { getEnvVariable } from "@clerk/shared/getEnvVariable";
+var API_VERSION = getEnvVariable("CLERK_API_VERSION") || "v1";
+var SECRET_KEY = getEnvVariable("CLERK_SECRET_KEY") || "";
+var PUBLISHABLE_KEY = getEnvVariable("CLERK_PUBLISHABLE_KEY") || "";
+var API_URL = getEnvVariable("CLERK_API_URL") || apiUrlFromPublishableKey(PUBLISHABLE_KEY);
+var JWT_KEY = getEnvVariable("CLERK_JWT_KEY") || "";
+var SDK_METADATA = {
+  name: "@clerk/agent-toolkit",
+  version: "0.0.6-canary.v20250306110334",
+  environment: getEnvVariable("NODE_ENV")
+};
+var clerkClient = createClerkClient({
+  secretKey: SECRET_KEY,
+  apiUrl: API_URL,
+  apiVersion: API_VERSION,
+  jwtKey: JWT_KEY,
+  userAgent: `${"@clerk/agent-toolkit"}@${"0.0.6-canary.v20250306110334"}`,
+  sdkMetadata: SDK_METADATA
+});
+
+// src/lib/constants.ts
+var defaultToolkitContext = {
+  allowPrivateMetadata: false
+};
+
+// src/lib/inject-session-claims.ts
+var injectSessionClaims = (context) => (prompt) => {
+  if (!context.sessionClaims && !context.userId) {
+    return prompt;
+  }
+  const lines = [];
+  lines.push(`# Signed-in user info:`);
+  lines.push(
+    context.sessionClaims?.sub || context.userId ? `Your userId is ${context.sessionClaims?.sub || context.userId}` : ""
+  );
+  lines.push(context.sessionClaims?.sid ? `Your sessionId is ${context.sessionClaims?.sid}` : "");
+  lines.push(prompt);
+  return lines.filter(Boolean).join("\n");
+};
+
+// src/lib/utils.ts
+function shallowTransform(input, transformFn) {
+  const result = {};
+  for (const key in input) {
+    if (Object.prototype.hasOwnProperty.call(input, key)) {
+      const typedKey = key;
+      result[typedKey] = transformFn(input[typedKey]);
+    }
+  }
+  return result;
+}
+var prunePrivateData = (context, o) => {
+  if (context.allowPrivateMetadata) {
+    return o;
+  }
+  if (o && o.private_metadata) {
+    delete o.private_metadata;
+  }
+  return o;
+};
+
+// src/lib/tools/invitations.ts
+import { z } from "zod";
+
+// src/lib/clerk-tool.ts
+var trimLines = (text) => text.split("\n").map((l) => l.trim()).filter(Boolean).join("\n");
+var ClerkTool = (params) => {
+  const schemaEntries = Object.entries(params.parameters.shape);
+  const args = schemaEntries.length === 0 ? "Takes no arguments" : Object.entries(params.parameters.shape).map(([key, value]) => {
+    return `- ${key}: ${value.description || ""}`;
+  }).join("\n");
+  const description = trimLines(`
+  Tool name:
+  ${params.name}
+  Description:
+  ${params.description}.
+  Arguments:
+  ${args}
+  `);
+  return { ...params, description };
+};
+
+// src/lib/tools/invitations.ts
+var createInvitation = ClerkTool({
+  name: "createInvitation",
+  description: `
+    Creates a new invitation for a specified email address to join your application.
+    Use this tool when you need to send invitation emails to new users.
+
+    The invited email will receive an email with a sign-up link.
+    You can customize the redirect URL and attach public metadata to the invitation.
+
+    Example use cases:
+    1. Implementing a user invitation system for a private beta
+    2. Creating a closed registration system where only invited users can join
+    3. Pre-configuring user attributes via publicMetadata before they sign up
+  `,
+  parameters: z.object({
+    emailAddress: z.string().describe("(string): Email address to send the invitation to. Required."),
+    redirectUrl: z.string().optional().describe("(string, optional): URL to redirect users to after they accept the invitation."),
+    publicMetadata: z.record(z.string(), z.any()).optional().describe("(Record<string,any>, optional): Public metadata for the invitation."),
+    notify: z.boolean().optional().describe("(boolean, optional): Whether to send an email notification. Defaults to true."),
+    ignoreExisting: z.boolean().optional().describe("(boolean, optional): Whether to ignore if an invitation already exists. Defaults to false.")
+  }),
+  bindRunnable: (clerkClient2, context) => async (params) => {
+    const res = await clerkClient2.invitations.createInvitation(params);
+    return prunePrivateData(context, res.raw);
+  }
+});
+var revokeInvitation = ClerkTool({
+  name: "revokeInvitation",
+  description: `
+    Revokes a pending invitation, preventing the recipient from using it to sign up.
+    Use this tool when you need to cancel an invitation before it's accepted.
+
+    This immediately invalidates the invitation link sent to the user.
+    Once revoked, an invitation cannot be un-revoked; you would need to create a new invitation.
+
+    Example use cases:
+    1. Canceling invitations sent by mistake
+    2. Revoking access when a prospective user should no longer be invited
+    3. Implementing invitation management controls for administrators
+  `,
+  parameters: z.object({
+    invitationId: z.string().describe("(string): The ID of the invitation to revoke. Required.")
+  }),
+  bindRunnable: (clerkClient2, context) => async (params) => {
+    const res = await clerkClient2.invitations.revokeInvitation(params.invitationId);
+    return prunePrivateData(context, res.raw);
+  }
+});
+var invitations = {
+  createInvitation,
+  revokeInvitation
+};
+
+// src/lib/tools/organizations.ts
+import { z as z2 } from "zod";
+var getOrganization = ClerkTool({
+  name: "getOrganization",
+  description: `
+    Retrieves a single organization by ID or slug.
+    Use this tool when you need detailed information about a specific organization.
+
+    You must provide either an organizationId OR a slug to identify the organization.
+
+    Example use cases:
+    1. Displaying organization details on a profile page
+    2. Checking if an organization exists before performing operations on it
+    3. Retrieving organization metadata for application-specific functionality
+  `,
+  parameters: z2.object({
+    organizationId: z2.string().optional().describe("(string, optional): The ID of the organization to retrieve. Required if slug is not provided."),
+    slug: z2.string().optional().describe(
+      "(string, optional): The slug of the organization to retrieve. Required if organizationId is not provided."
+    ),
+    includeMembersCount: z2.boolean().optional().describe("(boolean, optional): Whether to include the members count for the organization.")
+  }),
+  bindRunnable: (clerkClient2, context) => async (params) => {
+    if (!params.organizationId && !params.slug) {
+      throw new Error("Either organizationId or slug must be provided");
+    }
+    const res = await clerkClient2.organizations.getOrganization({
+      ...params,
+      organizationId: context.organizationId || params.organizationId
+    });
+    return prunePrivateData(context, res.raw);
+  }
+});
+var createOrganization = ClerkTool({
+  name: "createOrganization",
+  description: `
+    Creates a new organization in your Clerk instance.
+    Use this tool when you need to programmatically create organizations.
+
+    A name is required to create an organization. Other fields like slug,
+    maxAllowedMemberships, and metadata are optional.
+
+    Example use cases:
+    1. Creating organizations during user onboarding
+    2. Building a self-service organization creation flow
+    3. Migrating organizations from another system
+  `,
+  parameters: z2.object({
+    name: z2.string().describe("(string): The name of the new organization. Required."),
+    slug: z2.string().optional().describe(
+      "(string, optional): A URL-friendly identifier for the organization. If not provided, created from the name."
+    ),
+    createdBy: z2.string().optional().describe(
+      "(string, optional): The user ID of the user creating the organization. Defaults to the current authenticated user."
+    ),
+    maxAllowedMemberships: z2.number().optional().describe("(number, optional): Maximum number of members allowed in the organization."),
+    publicMetadata: z2.record(z2.string(), z2.any()).optional().describe("(Record<string,any>, optional): Public metadata for the organization."),
+    privateMetadata: z2.record(z2.string(), z2.any()).optional().describe("(Record<string,any>, optional): Private metadata for the organization (backend-only).")
+  }),
+  bindRunnable: (clerkClient2, context) => async (params) => {
+    const { createdBy, ...createParams } = params;
+    const createParamsWithUser = createdBy || context.userId ? { ...createParams, createdBy: createdBy || context.userId } : createParams;
+    const res = await clerkClient2.organizations.createOrganization(createParamsWithUser);
+    return prunePrivateData(context, res.raw);
+  }
+});
+var updateOrganization = ClerkTool({
+  name: "updateOrganization",
+  description: `
+    Updates an existing organization's attributes.
+    Use this tool when you need to modify core organization information (NOT metadata).
+
+    Only the fields you provide will be updated; others remain unchanged.
+    For updating just metadata, consider using updateOrganizationMetadata instead.
+
+    Example use cases:
+    1. Updating an organization's name or slug
+    2. Changing the maximum allowed memberships
+    3. Updating multiple organization attributes at once
+  `,
+  parameters: z2.object({
+    organizationId: z2.string().describe("(string): The ID of the organization to update. Required."),
+    name: z2.string().optional().describe("(string, optional): New name for the organization."),
+    slug: z2.string().optional().describe("(string, optional): New slug for the organization."),
+    maxAllowedMemberships: z2.number().optional().describe("(number, optional): New maximum number of members allowed."),
+    publicMetadata: z2.record(z2.string(), z2.any()).optional().describe("(Record<string,any>, optional): New public metadata for the organization."),
+    privateMetadata: z2.record(z2.string(), z2.any()).optional().describe("(Record<string,any>, optional): New private metadata for the organization (backend-only).")
+  }),
+  bindRunnable: (clerkClient2, context) => async (params) => {
+    const { organizationId, ...updateParams } = params;
+    const res = await clerkClient2.organizations.updateOrganization(
+      context.organizationId || organizationId,
+      updateParams
+    );
+    return prunePrivateData(context, res.raw);
+  }
+});
+var updateOrganizationMetadata = ClerkTool({
+  name: "updateOrganizationMetadata",
+  description: `
+    Updates the metadata associated with an organization by merging existing values with the provided parameters.
+    Use this tool when you need to store or update organization-specific data without changing other attributes.
+
+    Important characteristics:
+    1. A "deep" merge is performed - any nested JSON objects will be merged recursively
+    2. You can remove metadata keys at any level by setting their value to null
+    3. Public metadata is visible to the frontend
+    4. Private metadata is only accessible on the backend
+
+    Example use cases:
+    1. Storing organization preferences or settings
+    2. Keeping track of organization-specific application state
+    3. Adding custom attributes to organizations
+  `,
+  parameters: z2.object({
+    organizationId: z2.string().describe("(string): The ID of the organization to update. Required."),
+    publicMetadata: z2.record(z2.string(), z2.any()).optional().describe(
+      "(Record<string,any>, optional): The public metadata to set or update. Use null values to remove specific keys."
+    ),
+    privateMetadata: z2.record(z2.string(), z2.any()).optional().describe(
+      "(Record<string,any>, optional): The private metadata to set or update. Backend-only data. Use null values to remove specific keys."
+    )
+  }),
+  bindRunnable: (clerkClient2, context) => async (params) => {
+    const { organizationId, ...metadataParams } = params;
+    const res = await clerkClient2.organizations.updateOrganizationMetadata(
+      context.organizationId || organizationId,
+      metadataParams
+    );
+    return prunePrivateData(context, res.raw);
+  }
+});
+var deleteOrganization = ClerkTool({
+  name: "deleteOrganization",
+  description: `
+    Permanently deletes an organization from your Clerk instance.
+    Use this tool when you need to remove an organization completely.
+
+    WARNING: This action is irreversible. All organization data, memberships,
+    and invitations will be permanently deleted.
+
+    Example use cases:
+    1. Implementing organization cleanup flows
+    2. Allowing users to delete their own organizations
+    3. Administrative operations to remove unwanted organizations
+  `,
+  parameters: z2.object({
+    organizationId: z2.string().describe("(string): The ID of the organization to delete. Required.")
+  }),
+  bindRunnable: (clerkClient2, context) => async (params) => {
+    const res = await clerkClient2.organizations.deleteOrganization(context.organizationId || params.organizationId);
+    return prunePrivateData(context, res.raw);
+  }
+});
+var createOrganizationMembership = ClerkTool({
+  name: "createOrganizationMembership",
+  description: `
+    Adds a user to an organization with a specified role.
+    Use this tool when you need to programmatically add members to an organization.
+
+    This creates an immediate membership without requiring an invitation process.
+    The specified role determines what permissions the user will have in the organization.
+
+    Example use cases:
+    1. Adding users to organizations during onboarding
+    2. Building administrative interfaces for member management
+    3. Migrating memberships from another system
+  `,
+  parameters: z2.object({
+    organizationId: z2.string().describe("(string): The ID of the organization to add the member to. Required."),
+    userId: z2.string().describe("(string): The ID of the user to add as a member. Required."),
+    role: z2.string().describe("(string): The role to assign to the user in the organization. Required.")
+  }),
+  bindRunnable: (clerkClient2, context) => async (params) => {
+    const res = await clerkClient2.organizations.createOrganizationMembership({
+      ...params,
+      organizationId: context.organizationId || params.organizationId,
+      userId: context.userId || params.userId
+    });
+    return prunePrivateData(context, res.raw);
+  }
+});
+var updateOrganizationMembership = ClerkTool({
+  name: "updateOrganizationMembership",
+  description: `
+    Updates a user's role within an organization.
+    Use this tool when you need to change a member's role or permissions.
+
+    This updates an existing membership relationship between a user and an organization.
+    The new role will replace the current role and change the user's permissions accordingly.
+
+    Example use cases:
+    1. Promoting or demoting users within an organization
+    2. Building role management interfaces
+    3. Implementing admin-level controls for organization management
+  `,
+  parameters: z2.object({
+    organizationId: z2.string().describe("(string): The ID of the organization containing the membership. Required."),
+    userId: z2.string().describe("(string): The ID of the user whose membership is being updated. Required."),
+    role: z2.string().describe("(string): The new role to assign to the user. Required.")
+  }),
+  bindRunnable: (clerkClient2, context) => async (params) => {
+    const res = await clerkClient2.organizations.updateOrganizationMembership({
+      ...params,
+      organizationId: context.organizationId || params.organizationId
+    });
+    return prunePrivateData(context, res.raw);
+  }
+});
+var updateOrganizationMembershipMetadata = ClerkTool({
+  name: "updateOrganizationMembershipMetadata",
+  description: `
+    Updates the metadata associated with a user's membership in an organization.
+    Use this tool when you need to store or update membership-specific data.
+
+    Important characteristics:
+    1. A "deep" merge is performed - any nested JSON objects will be merged recursively
+    2. You can remove metadata keys at any level by setting their value to null
+    3. Public metadata is visible to the frontend
+    4. Private metadata is only accessible on the backend
+
+    Example use cases:
+    1. Storing member-specific preferences or settings within an organization
+    2. Adding custom attributes to track member activity or status
+    3. Customizing a user's experience within a specific organization
+  `,
+  parameters: z2.object({
+    organizationId: z2.string().describe("(string): The ID of the organization containing the membership. Required."),
+    userId: z2.string().describe("(string): The ID of the user whose membership metadata is being updated. Required."),
+    publicMetadata: z2.record(z2.string(), z2.any()).optional().describe(
+      "(Record<string,any>, optional): The public metadata to set or update. Use null values to remove specific keys."
+    ),
+    privateMetadata: z2.record(z2.string(), z2.any()).optional().describe(
+      "(Record<string,any>, optional): The private metadata to set or update. Backend-only data. Use null values to remove specific keys."
+    )
+  }),
+  bindRunnable: (clerkClient2, context) => async (params) => {
+    const res = await clerkClient2.organizations.updateOrganizationMembershipMetadata({
+      ...params,
+      organizationId: context.organizationId || params.organizationId
+    });
+    return prunePrivateData(context, res.raw);
+  }
+});
+var deleteOrganizationMembership = ClerkTool({
+  name: "deleteOrganizationMembership",
+  description: `
+    Removes a user from an organization.
+    Use this tool when you need to revoke a user's membership in an organization.
+
+    This permanently breaks the membership relationship between the user and organization.
+    The user will immediately lose access to organization resources.
+
+    Example use cases:
+    1. Removing users who have left the organization
+    2. Building membership management interfaces with removal capability
+    3. Implementing self-service leave organization functionality
+  `,
+  parameters: z2.object({
+    organizationId: z2.string().describe("(string): The ID of the organization to remove the member from. Required."),
+    userId: z2.string().describe("(string): The ID of the user to remove from the organization. Required.")
+  }),
+  bindRunnable: (clerkClient2, context) => async (params) => {
+    const res = await clerkClient2.organizations.deleteOrganizationMembership({
+      ...params,
+      userId: context.userId || params.userId
+    });
+    return prunePrivateData(context, res.raw);
+  }
+});
+var createOrganizationInvitation = ClerkTool({
+  name: "createOrganizationInvitation",
+  description: `
+    Creates an invitation to join an organization for a specified email address.
+    Use this tool when you need to invite new members to an organization.
+
+    The invited email will receive an email invitation to join the organization.
+    You can specify the role the user will have upon accepting the invitation.
+
+    Example use cases:
+    1. Building invite flows for organization member management
+    2. Implementing team expansion functionality
+    3. Creating administrative tools for organization growth
+  `,
+  parameters: z2.object({
+    organizationId: z2.string().describe("(string): The ID of the organization to create an invitation for. Required."),
+    emailAddress: z2.string().describe("(string): Email address to send the invitation to. Required."),
+    role: z2.string().describe("(string): Role to assign to the user upon accepting the invitation. Required."),
+    inviterUserId: z2.string().optional().describe(
+      "(string, optional): User ID of the person sending the invitation. Defaults to the current authenticated user."
+    ),
+    redirectUrl: z2.string().optional().describe("(string, optional): URL to redirect users to after they accept the invitation."),
+    publicMetadata: z2.record(z2.string(), z2.any()).optional().describe("(Record<string,any>, optional): Public metadata for the invitation.")
+  }),
+  bindRunnable: (clerkClient2, context) => async (params) => {
+    const { inviterUserId, ...inviteParams } = params;
+    const inviteParamsWithUser = inviterUserId || context.userId ? { ...inviteParams, inviterUserId: inviterUserId || context.userId } : inviteParams;
+    const res = await clerkClient2.organizations.createOrganizationInvitation(inviteParamsWithUser);
+    return prunePrivateData(context, res.raw);
+  }
+});
+var revokeOrganizationInvitation = ClerkTool({
+  name: "revokeOrganizationInvitation",
+  description: `
+    Revokes a pending invitation to an organization.
+    Use this tool when you need to cancel an invitation before it's accepted.
+
+    This immediately invalidates the invitation, preventing the recipient
+    from using it to join the organization.
+
+    Example use cases:
+    1. Canceling invitations sent by mistake
+    2. Building invitation management interfaces with revocation capability
+    3. Implementing security measures to quickly revoke access
+  `,
+  parameters: z2.object({
+    organizationId: z2.string().describe("(string): The ID of the organization containing the invitation. Required."),
+    invitationId: z2.string().describe("(string): The ID of the invitation to revoke. Required."),
+    requestingUserId: z2.string().optional().describe(
+      "(string, optional): User ID of the person revoking the invitation. Defaults to the current authenticated user."
+    )
+  }),
+  bindRunnable: (clerkClient2, context) => async (params) => {
+    const { requestingUserId, ...revokeParams } = params;
+    const revokeParamsWithUser = requestingUserId || context.userId ? { ...revokeParams, requestingUserId: requestingUserId || context.userId } : revokeParams;
+    const res = await clerkClient2.organizations.revokeOrganizationInvitation(revokeParamsWithUser);
+    return prunePrivateData(context, res.raw);
+  }
+});
+var organizations = {
+  getOrganization,
+  createOrganization,
+  updateOrganization,
+  updateOrganizationMetadata,
+  deleteOrganization,
+  createOrganizationMembership,
+  updateOrganizationMembership,
+  updateOrganizationMembershipMetadata,
+  deleteOrganizationMembership,
+  createOrganizationInvitation,
+  revokeOrganizationInvitation
+};
+
+// src/lib/tools/user.ts
+import { z as z3 } from "zod";
+var getUserId = ClerkTool({
+  name: "getUserId",
+  description: `
+    Get the userId of the current authenticated user if signed in, otherwise return null.
+    Use this tool when you need to identify the current user but don't need their profile details.
+    This tool takes no parameters and is the quickest way to check if a user is authenticated.
+    Example use case: When you need to verify if a user is logged in before performing user-specific operations.
+  `,
+  parameters: z3.object({}),
+  bindRunnable: (clerkClient2, context) => () => {
+    return Promise.resolve(context.userId || null);
+  }
+});
+var getUser = ClerkTool({
+  name: "getUser",
+  description: `
+    Retrieves detailed information about a user by their userId, including email addresses,
+    username, profile image, created/updated timestamps, and public metadata.
+    Use this tool when you need comprehensive user information beyond just their ID.
+    If the userId parameter is not provided, it will use the current authenticated user's ID.
+    Example use case: When you need to display user profile information or check user attributes.
+  `,
+  parameters: z3.object({
+    userId: z3.string().describe("(string): The userId of the User to retrieve.")
+  }),
+  bindRunnable: (clerkClient2, context) => async (params) => {
+    const res = await clerkClient2.users.getUser(context.userId || params.userId);
+    return prunePrivateData(context, res.raw);
+  }
+});
+var getUserCount = ClerkTool({
+  name: "getUserCount",
+  description: `
+    Retrieves the total count of users in your Clerk instance.
+    Use this tool when you need to know the total number of users in the system.
+    This tool takes no parameters and is an efficient way to get just the count without retrieving user details.
+  `,
+  parameters: z3.object({}),
+  bindRunnable: (clerkClient2, _) => async () => {
+    return await clerkClient2.users.getCount();
+  }
+});
+var updateUserPublicMetadata = ClerkTool({
+  name: "updateUserPublicMetadata",
+  description: `
+    Updates the public metadata associated with a user by merging existing values with the provided parameters.
+    Use this tool when you need to store or update user preferences, settings, or other non-sensitive information.
+
+    Important characteristics:
+    1. A "deep" merge is performed - any nested JSON objects will be merged recursively.
+    2. You can remove metadata keys at any level by setting their value to null.
+    3. Public metadata is visible to the frontend and should NOT contain sensitive information.
+
+    Example use case: Storing user preferences, feature flags, or application-specific data that persists across sessions.
+  `,
+  parameters: z3.object({
+    userId: z3.string().describe("(string): The userId of the User to update."),
+    metadata: z3.record(z3.string(), z3.any()).describe("(Record<string,any>): The public metadata to set or update. Use null values to remove specific keys.")
+  }),
+  bindRunnable: (clerkClient2, context) => async (params) => {
+    const { userId, metadata } = params;
+    const res = await clerkClient2.users.updateUserMetadata(context.userId || userId, { publicMetadata: metadata });
+    return prunePrivateData(context, res.raw);
+  }
+});
+var updateUserUnsafeMetadata = ClerkTool({
+  name: "updateUserUnsafeMetadata",
+  description: `
+    Updates the unsafe metadata associated with a user by merging existing values with the provided parameters.
+    Use this tool when you need to store data that should be accessible both on the frontend and backend.
+
+    Important characteristics:
+    1. A "deep" merge is performed - any nested JSON objects will be merged recursively.
+    2. You can remove metadata keys at any level by setting their value to null.
+    3. Unsafe metadata is accessible from both frontend and backend code.
+    4. Unlike public metadata, unsafe metadata is NOT included in JWT tokens.
+
+    Example use case: Storing user data that should be modifiable from the frontend but not included in authentication tokens.
+  `,
+  parameters: z3.object({
+    userId: z3.string().describe("(string): The userId of the User to update."),
+    metadata: z3.record(z3.string(), z3.any()).describe("(Record<string,any>): The unsafe metadata to set or update. Use null values to remove specific keys.")
+  }),
+  bindRunnable: (clerkClient2, context) => async (params) => {
+    const { userId, metadata } = params;
+    const res = await clerkClient2.users.updateUserMetadata(context.userId || userId, { unsafeMetadata: metadata });
+    return prunePrivateData(context, res.raw);
+  }
+});
+var updateUser = ClerkTool({
+  name: "updateUser",
+  description: `
+    Updates an existing user's attributes in your Clerk instance.
+    Use this tool when you need to modify core user information (NOT metadata).
+
+    Important notes:
+    1. If the userId parameter is not provided, it will use the current authenticated user's ID
+    2. Only the provided fields will be updated, other fields remain unchanged
+    3. For updating metadata, use the specialized metadata update tools instead
+    4. Email and phone verification status cannot be changed with this tool
+
+    Example use cases:
+    1. Updating a user's name, username, or other profile information
+    2. Enabling or disabling a user account
+    3. Setting a user's primary contact information
+  `,
+  parameters: z3.object({
+    userId: z3.string().describe("(string): The userId of the User to update."),
+    firstName: z3.string().optional().describe("(string): New first name for the user"),
+    lastName: z3.string().optional().describe("(string): New last name for the user"),
+    username: z3.string().optional().describe("(string): New username for the user"),
+    profileImageUrl: z3.string().optional().describe("(string): URL for the user profile image")
+  }),
+  bindRunnable: (clerkClient2, context) => async (params) => {
+    const { userId, ...updateParams } = params;
+    const res = await clerkClient2.users.updateUser(context.userId || userId, updateParams);
+    return prunePrivateData(context, res.raw);
+  }
+});
+var users = {
+  getUserId,
+  getUser,
+  getUserCount,
+  updateUser,
+  updateUserPublicMetadata,
+  updateUserUnsafeMetadata
+};
+
+// src/lib/tools/index.ts
+var tools = {
+  /**
+   * Tools for interacting with users.
+   * This is a wrapper around the `clerkClient.users` API.
+   * For more information, see the [Clerk API documentation](https://clerk.com/docs/reference/backend-api/tag/Users).
+   */
+  users,
+  /**
+   * Tools for interacting with organizations.
+   * This is a wrapper around the `clerkClient.organizations` API.
+   * For more information, see the [Clerk API documentation](https://clerk.com/docs/reference/backend-api/tag/Organizations).
+   */
+  organizations,
+  /**
+   * Tools for interacting with invitations.
+   * This is a wrapper around the `clerkClient.invitations` API.
+   * For more information, see the [Clerk API documentation](https://clerk.com/docs/reference/backend-api/tag/Invitations).
+   */
+  invitations
+};
+var flatTools = {
+  ...users,
+  ...organizations,
+  ...invitations
+};
+
+export {
+  clerkClient,
+  defaultToolkitContext,
+  injectSessionClaims,
+  shallowTransform,
+  tools,
+  flatTools
+};
+//# sourceMappingURL=chunk-K5TBM24J.js.map