@slates-integrations/attio 0.2.0-rc.5

package/src/tools/list-attributes.ts

@@ -0,0 +1,66 @@
+import { SlateTool } from 'slates';
+import { AttioClient } from '../lib/client';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+export let listAttributesTool = SlateTool.create(spec, {
+  name: 'List Attributes',
+  key: 'list_attributes',
+  description: `List all attribute definitions for an object or list. Returns attribute metadata including title, slug, type, and configuration. Useful for understanding the data model before creating or querying records.`,
+  tags: {
+    readOnly: true
+  }
+})
+  .input(
+    z.object({
+      targetType: z
+        .enum(['object', 'list'])
+        .describe('Whether to list attributes on an object or a list'),
+      targetSlug: z.string().describe('Object or list slug/ID to list attributes for')
+    })
+  )
+  .output(
+    z.object({
+      attributes: z
+        .array(
+          z.object({
+            attributeId: z.string().describe('The attribute ID'),
+            apiSlug: z.string().describe('API slug for the attribute'),
+            title: z.string().describe('Display name'),
+            attributeType: z.string().describe('Attribute type (text, email, number, etc.)'),
+            isRequired: z.boolean().describe('Whether the attribute is required'),
+            isUnique: z.boolean().describe('Whether the attribute must be unique'),
+            isMultiselect: z.boolean().describe('Whether the attribute is multi-select'),
+            isArchived: z.boolean().describe('Whether the attribute is archived')
+          })
+        )
+        .describe('Available attributes')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = new AttioClient({ token: ctx.auth.token });
+
+    let attributes;
+    if (ctx.input.targetType === 'object') {
+      attributes = await client.listObjectAttributes(ctx.input.targetSlug);
+    } else {
+      attributes = await client.listListAttributes(ctx.input.targetSlug);
+    }
+
+    let mapped = attributes.map((a: any) => ({
+      attributeId: a.id?.attribute_id ?? '',
+      apiSlug: a.api_slug ?? '',
+      title: a.title ?? '',
+      attributeType: a.type ?? '',
+      isRequired: a.is_required ?? false,
+      isUnique: a.is_unique ?? false,
+      isMultiselect: a.is_multiselect ?? false,
+      isArchived: a.is_archived ?? false
+    }));
+
+    return {
+      output: { attributes: mapped },
+      message: `Found **${mapped.length}** attribute(s) on ${ctx.input.targetType} **${ctx.input.targetSlug}**.`
+    };
+  })
+  .build();

package/src/tools/list-objects.ts

@@ -0,0 +1,47 @@
+import { SlateTool } from 'slates';
+import { AttioClient } from '../lib/client';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+export let listObjectsTool = SlateTool.create(spec, {
+  name: 'List Objects',
+  key: 'list_objects',
+  description: `List all objects (data types) in the workspace, including built-in objects like People and Companies, and any custom objects. Useful for discovering available objects and their slugs before querying records.`,
+  tags: {
+    readOnly: true
+  }
+})
+  .input(z.object({}))
+  .output(
+    z.object({
+      objects: z
+        .array(
+          z.object({
+            objectId: z.string().describe('The object ID'),
+            apiSlug: z.string().describe('API slug for the object'),
+            singularNoun: z.string().describe('Singular display name'),
+            pluralNoun: z.string().describe('Plural display name'),
+            createdAt: z.string().describe('When the object was created')
+          })
+        )
+        .describe('Available objects')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = new AttioClient({ token: ctx.auth.token });
+    let objects = await client.listObjects();
+
+    let mapped = objects.map((o: any) => ({
+      objectId: o.id?.object_id ?? '',
+      apiSlug: o.api_slug ?? '',
+      singularNoun: o.singular_noun ?? '',
+      pluralNoun: o.plural_noun ?? '',
+      createdAt: o.created_at ?? ''
+    }));
+
+    return {
+      output: { objects: mapped },
+      message: `Found **${mapped.length}** object(s): ${mapped.map((o: any) => o.apiSlug).join(', ')}.`
+    };
+  })
+  .build();

package/src/tools/list-workspace-members.ts

@@ -0,0 +1,51 @@
+import { SlateTool } from 'slates';
+import { AttioClient } from '../lib/client';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+export let listWorkspaceMembersTool = SlateTool.create(spec, {
+  name: 'List Workspace Members',
+  key: 'list_workspace_members',
+  description: `List all members of the Attio workspace, including their names, emails, roles, and avatar URLs. Useful for finding assignees for tasks or identifying team members.`,
+  tags: {
+    readOnly: true
+  }
+})
+  .input(z.object({}))
+  .output(
+    z.object({
+      members: z
+        .array(
+          z.object({
+            workspaceMemberId: z.string().describe('The workspace member ID'),
+            firstName: z.string().describe('First name'),
+            lastName: z.string().describe('Last name'),
+            emailAddress: z.string().describe('Email address'),
+            avatarUrl: z.string().optional().nullable().describe('Avatar URL'),
+            accessLevel: z.string().describe('Access level (admin, member, suspended)'),
+            createdAt: z.string().describe('When the member was added')
+          })
+        )
+        .describe('Workspace members')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = new AttioClient({ token: ctx.auth.token });
+    let members = await client.listWorkspaceMembers();
+
+    let mapped = members.map((m: any) => ({
+      workspaceMemberId: m.id?.workspace_member_id ?? '',
+      firstName: m.first_name ?? '',
+      lastName: m.last_name ?? '',
+      emailAddress: m.email_address ?? '',
+      avatarUrl: m.avatar_url ?? null,
+      accessLevel: m.access_level ?? '',
+      createdAt: m.created_at ?? ''
+    }));
+
+    return {
+      output: { members: mapped },
+      message: `Found **${mapped.length}** workspace member(s).`
+    };
+  })
+  .build();

package/src/tools/manage-comments.ts

@@ -0,0 +1,167 @@
+import { SlateTool } from 'slates';
+import { AttioClient } from '../lib/client';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+export let createCommentTool = SlateTool.create(spec, {
+  name: 'Create Comment',
+  key: 'create_comment',
+  description: `Create a new comment on a record, list entry, or within an existing thread. Specify either a **threadId** to reply to an existing thread, a **record** to start a new thread on a record, or an **entry** to comment on a list entry.`,
+  tags: {
+    destructive: false
+  }
+})
+  .input(
+    z.object({
+      content: z.string().describe('Comment text'),
+      format: z
+        .enum(['plaintext', 'markdown'])
+        .optional()
+        .default('plaintext')
+        .describe('Content format'),
+      threadId: z
+        .string()
+        .optional()
+        .describe('Thread ID to reply to (mutually exclusive with record/entry)'),
+      recordObject: z.string().optional().describe('Object slug of the record to comment on'),
+      recordId: z.string().optional().describe('Record ID to comment on'),
+      listSlug: z.string().optional().describe('List slug for entry-level comment'),
+      entryId: z.string().optional().describe('Entry ID to comment on'),
+      authorType: z
+        .string()
+        .optional()
+        .default('workspace-member')
+        .describe('Author type, typically "workspace-member"'),
+      authorId: z.string().describe('Workspace member ID for the comment author')
+    })
+  )
+  .output(
+    z.object({
+      commentId: z.string().describe('The comment ID'),
+      threadId: z.string().describe('The thread ID'),
+      contentPlaintext: z.string().describe('Comment content'),
+      createdAt: z.string().describe('When the comment was created')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = new AttioClient({ token: ctx.auth.token });
+
+    let params: Parameters<typeof client.createComment>[0] = {
+      content: ctx.input.content,
+      format: ctx.input.format
+    };
+
+    if (ctx.input.threadId) {
+      params.threadId = ctx.input.threadId;
+    } else if (ctx.input.recordObject && ctx.input.recordId) {
+      params.record = {
+        object: ctx.input.recordObject,
+        recordId: ctx.input.recordId
+      };
+    } else if (ctx.input.listSlug && ctx.input.entryId) {
+      params.entry = {
+        list: ctx.input.listSlug,
+        entryId: ctx.input.entryId
+      };
+    }
+
+    params.author = {
+      type: ctx.input.authorType,
+      id: ctx.input.authorId
+    };
+
+    let comment = await client.createComment(params);
+
+    let output = {
+      commentId: comment.id?.comment_id ?? '',
+      threadId: comment.thread_id ?? '',
+      contentPlaintext: comment.content_plaintext ?? '',
+      createdAt: comment.created_at ?? ''
+    };
+
+    return {
+      output,
+      message: `Created comment **${output.commentId}** in thread **${output.threadId}**.`
+    };
+  })
+  .build();
+
+export let getThreadTool = SlateTool.create(spec, {
+  name: 'Get Thread',
+  key: 'get_thread',
+  description: `Retrieve a comment thread by its ID, including all comments in the thread.`,
+  tags: {
+    readOnly: true
+  }
+})
+  .input(
+    z.object({
+      threadId: z.string().describe('The thread ID to retrieve')
+    })
+  )
+  .output(
+    z.object({
+      threadId: z.string().describe('The thread ID'),
+      comments: z
+        .array(
+          z.object({
+            commentId: z.string().describe('The comment ID'),
+            contentPlaintext: z.string().describe('Comment content'),
+            authorType: z.string().optional().describe('Author type'),
+            authorId: z.string().optional().describe('Author ID'),
+            createdAt: z.string().describe('When the comment was created')
+          })
+        )
+        .describe('Comments in the thread')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = new AttioClient({ token: ctx.auth.token });
+    let thread = await client.getThread(ctx.input.threadId);
+
+    let comments = (thread.comments ?? []).map((c: any) => ({
+      commentId: c.id?.comment_id ?? '',
+      contentPlaintext: c.content_plaintext ?? '',
+      authorType: c.author?.type,
+      authorId: c.author?.id,
+      createdAt: c.created_at ?? ''
+    }));
+
+    return {
+      output: {
+        threadId: ctx.input.threadId,
+        comments
+      },
+      message: `Retrieved thread **${ctx.input.threadId}** with **${comments.length}** comment(s).`
+    };
+  })
+  .build();
+
+export let deleteCommentTool = SlateTool.create(spec, {
+  name: 'Delete Comment',
+  key: 'delete_comment',
+  description: `Delete a comment. If the comment is the head of a thread, the entire thread is deleted. This action cannot be undone.`,
+  tags: {
+    destructive: true
+  }
+})
+  .input(
+    z.object({
+      commentId: z.string().describe('The comment ID to delete')
+    })
+  )
+  .output(
+    z.object({
+      deleted: z.boolean().describe('Whether the comment was deleted')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = new AttioClient({ token: ctx.auth.token });
+    await client.deleteComment(ctx.input.commentId);
+
+    return {
+      output: { deleted: true },
+      message: `Deleted comment **${ctx.input.commentId}**.`
+    };
+  })
+  .build();

package/src/tools/manage-list-entries.ts

@@ -0,0 +1,289 @@
+import { SlateTool } from 'slates';
+import { AttioClient } from '../lib/client';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+export let getListsTool = SlateTool.create(spec, {
+  name: 'Get Lists',
+  key: 'get_lists',
+  description: `Retrieve all lists in the workspace, or get details for a specific list. Lists organize records into structured collections (e.g. sales pipelines, recruitment pipelines).`,
+  tags: {
+    readOnly: true
+  }
+})
+  .input(
+    z.object({
+      listSlug: z
+        .string()
+        .optional()
+        .describe('Specific list slug or ID. If omitted, returns all lists.')
+    })
+  )
+  .output(
+    z.object({
+      lists: z
+        .array(
+          z.object({
+            listId: z.string().describe('The list ID'),
+            apiSlug: z.string().describe('API slug for the list'),
+            name: z.string().describe('List display name'),
+            parentObject: z.array(z.string()).describe('Parent object slugs'),
+            createdAt: z.string().describe('When the list was created')
+          })
+        )
+        .describe('Lists in the workspace')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = new AttioClient({ token: ctx.auth.token });
+
+    if (ctx.input.listSlug) {
+      let list = await client.getList(ctx.input.listSlug);
+      let mapped = [
+        {
+          listId: list.id?.list_id ?? '',
+          apiSlug: list.api_slug ?? '',
+          name: list.name ?? '',
+          parentObject: list.parent_object ?? [],
+          createdAt: list.created_at ?? ''
+        }
+      ];
+      return {
+        output: { lists: mapped },
+        message: `Retrieved list **${mapped[0]!.name}**.`
+      };
+    }
+
+    let lists = await client.listLists();
+
+    let mapped = lists.map((l: any) => ({
+      listId: l.id?.list_id ?? '',
+      apiSlug: l.api_slug ?? '',
+      name: l.name ?? '',
+      parentObject: l.parent_object ?? [],
+      createdAt: l.created_at ?? ''
+    }));
+
+    return {
+      output: { lists: mapped },
+      message: `Found **${mapped.length}** list(s).`
+    };
+  })
+  .build();
+
+export let addListEntryTool = SlateTool.create(spec, {
+  name: 'Add List Entry',
+  key: 'add_list_entry',
+  description: `Add a record to a list as an entry, or update an existing entry using upsert. When **upsert** is true, creates the entry if the record isn't already in the list, or updates it if it is.`,
+  tags: {
+    destructive: false
+  }
+})
+  .input(
+    z.object({
+      listSlug: z.string().describe('List slug or ID to add the entry to'),
+      parentRecordId: z.string().describe('The record ID to add to the list'),
+      parentObject: z
+        .string()
+        .describe('The object slug the record belongs to (e.g. "people", "companies")'),
+      entryValues: z
+        .record(z.string(), z.any())
+        .optional()
+        .describe('Additional attribute values for the list entry'),
+      upsert: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('If true, creates or updates the entry based on the parent record')
+    })
+  )
+  .output(
+    z.object({
+      entryId: z.string().describe('The entry ID'),
+      listId: z.string().describe('The list ID'),
+      parentRecordId: z.string().describe('The parent record ID'),
+      createdAt: z.string().describe('When the entry was created'),
+      entryValues: z.record(z.string(), z.any()).describe('Entry attribute values')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = new AttioClient({ token: ctx.auth.token });
+
+    let entry;
+    if (ctx.input.upsert) {
+      entry = await client.assertListEntry(
+        ctx.input.listSlug,
+        ctx.input.parentRecordId,
+        ctx.input.parentObject,
+        ctx.input.entryValues
+      );
+    } else {
+      entry = await client.createListEntry(
+        ctx.input.listSlug,
+        ctx.input.parentRecordId,
+        ctx.input.parentObject,
+        ctx.input.entryValues
+      );
+    }
+
+    let output = {
+      entryId: entry.id?.entry_id ?? '',
+      listId: entry.id?.list_id ?? '',
+      parentRecordId: entry.parent_record_id ?? '',
+      createdAt: entry.created_at ?? '',
+      entryValues: entry.entry_values ?? {}
+    };
+
+    return {
+      output,
+      message: `Added record **${ctx.input.parentRecordId}** to list **${ctx.input.listSlug}** as entry **${output.entryId}**.`
+    };
+  })
+  .build();
+
+export let updateListEntryTool = SlateTool.create(spec, {
+  name: 'Update List Entry',
+  key: 'update_list_entry',
+  description: `Update attribute values on an existing list entry. By default multi-select values are appended; set **overwriteMultiselect** to replace them entirely.`,
+  tags: {
+    destructive: false
+  }
+})
+  .input(
+    z.object({
+      listSlug: z.string().describe('List slug or ID'),
+      entryId: z.string().describe('The entry ID to update'),
+      entryValues: z
+        .record(z.string(), z.any())
+        .describe('Attribute values to update, keyed by attribute slug'),
+      overwriteMultiselect: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('If true, replaces multi-select values instead of appending')
+    })
+  )
+  .output(
+    z.object({
+      entryId: z.string().describe('The entry ID'),
+      listId: z.string().describe('The list ID'),
+      parentRecordId: z.string().describe('The parent record ID'),
+      createdAt: z.string().describe('When the entry was created'),
+      entryValues: z.record(z.string(), z.any()).describe('Updated entry attribute values')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = new AttioClient({ token: ctx.auth.token });
+
+    let entry = await client.updateListEntry(
+      ctx.input.listSlug,
+      ctx.input.entryId,
+      ctx.input.entryValues,
+      ctx.input.overwriteMultiselect
+    );
+
+    let output = {
+      entryId: entry.id?.entry_id ?? '',
+      listId: entry.id?.list_id ?? '',
+      parentRecordId: entry.parent_record_id ?? '',
+      createdAt: entry.created_at ?? '',
+      entryValues: entry.entry_values ?? {}
+    };
+
+    return {
+      output,
+      message: `Updated entry **${output.entryId}** in list **${ctx.input.listSlug}**.`
+    };
+  })
+  .build();
+
+export let deleteListEntryTool = SlateTool.create(spec, {
+  name: 'Delete List Entry',
+  key: 'delete_list_entry',
+  description: `Remove a record from a list by deleting its entry. This does not delete the underlying record.`,
+  tags: {
+    destructive: true
+  }
+})
+  .input(
+    z.object({
+      listSlug: z.string().describe('List slug or ID'),
+      entryId: z.string().describe('The entry ID to delete')
+    })
+  )
+  .output(
+    z.object({
+      deleted: z.boolean().describe('Whether the entry was deleted')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = new AttioClient({ token: ctx.auth.token });
+    await client.deleteListEntry(ctx.input.listSlug, ctx.input.entryId);
+
+    return {
+      output: { deleted: true },
+      message: `Removed entry **${ctx.input.entryId}** from list **${ctx.input.listSlug}**.`
+    };
+  })
+  .build();
+
+export let queryListEntriesTool = SlateTool.create(spec, {
+  name: 'Query List Entries',
+  key: 'query_list_entries',
+  description: `Query and filter entries in a list. Supports the same filter and sort syntax as record queries. Useful for retrieving entries from sales pipelines, recruitment stages, etc.`,
+  tags: {
+    readOnly: true
+  }
+})
+  .input(
+    z.object({
+      listSlug: z.string().describe('List slug or ID'),
+      filter: z.any().optional().describe('Filter expression'),
+      sorts: z.array(z.any()).optional().describe('Sort specification array'),
+      limit: z.number().optional().default(50).describe('Maximum entries to return (max 500)'),
+      offset: z.number().optional().default(0).describe('Number of entries to skip')
+    })
+  )
+  .output(
+    z.object({
+      entries: z
+        .array(
+          z.object({
+            entryId: z.string().describe('The entry ID'),
+            listId: z.string().describe('The list ID'),
+            parentRecordId: z.string().describe('The parent record ID'),
+            createdAt: z.string().describe('When the entry was created'),
+            entryValues: z.record(z.string(), z.any()).describe('Entry attribute values')
+          })
+        )
+        .describe('Matching entries'),
+      count: z.number().describe('Number of entries returned')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = new AttioClient({ token: ctx.auth.token });
+
+    let entries = await client.queryListEntries(ctx.input.listSlug, {
+      filter: ctx.input.filter,
+      sorts: ctx.input.sorts,
+      limit: ctx.input.limit,
+      offset: ctx.input.offset
+    });
+
+    let mapped = entries.map((e: any) => ({
+      entryId: e.id?.entry_id ?? '',
+      listId: e.id?.list_id ?? '',
+      parentRecordId: e.parent_record_id ?? '',
+      createdAt: e.created_at ?? '',
+      entryValues: e.entry_values ?? {}
+    }));
+
+    return {
+      output: {
+        entries: mapped,
+        count: mapped.length
+      },
+      message: `Found **${mapped.length}** entry/entries in list **${ctx.input.listSlug}**.`
+    };
+  })
+  .build();