@slates-integrations/attio 0.2.0-rc.5

package/src/tools/manage-notes.ts

@@ -0,0 +1,139 @@
+import { SlateTool } from 'slates';
+import { AttioClient } from '../lib/client';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+let noteOutputSchema = z.object({
+  noteId: z.string().describe('The note ID'),
+  parentObject: z.string().describe('Parent object slug'),
+  parentRecordId: z.string().describe('Parent record ID'),
+  title: z.string().describe('Note title'),
+  contentPlaintext: z.string().optional().describe('Plaintext content of the note'),
+  contentMarkdown: z.string().optional().describe('Markdown content of the note'),
+  createdAt: z.string().describe('When the note was created')
+});
+
+let mapNote = (n: any) => ({
+  noteId: n.id?.note_id ?? '',
+  parentObject: n.parent_object ?? '',
+  parentRecordId: n.parent_record_id ?? '',
+  title: n.title ?? '',
+  contentPlaintext: n.content_plaintext,
+  contentMarkdown: n.content_markdown,
+  createdAt: n.created_at ?? ''
+});
+
+export let listNotesTool = SlateTool.create(spec, {
+  name: 'List Notes',
+  key: 'list_notes',
+  description: `List notes, optionally filtered by a specific record. Returns note titles and content. Useful for retrieving all notes attached to a person, company, or other record.`,
+  tags: {
+    readOnly: true
+  }
+})
+  .input(
+    z.object({
+      parentObject: z
+        .string()
+        .optional()
+        .describe('Filter by parent object slug (e.g. "people", "companies")'),
+      parentRecordId: z.string().optional().describe('Filter by parent record ID'),
+      limit: z.number().optional().default(10).describe('Maximum notes to return (max 50)'),
+      offset: z.number().optional().default(0).describe('Number of notes to skip')
+    })
+  )
+  .output(
+    z.object({
+      notes: z.array(noteOutputSchema).describe('Notes'),
+      count: z.number().describe('Number of notes returned')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = new AttioClient({ token: ctx.auth.token });
+
+    let notes = await client.listNotes({
+      parentObject: ctx.input.parentObject,
+      parentRecordId: ctx.input.parentRecordId,
+      limit: ctx.input.limit,
+      offset: ctx.input.offset
+    });
+
+    let mapped = notes.map(mapNote);
+
+    return {
+      output: { notes: mapped, count: mapped.length },
+      message: `Found **${mapped.length}** note(s).`
+    };
+  })
+  .build();
+
+export let createNoteTool = SlateTool.create(spec, {
+  name: 'Create Note',
+  key: 'create_note',
+  description: `Create a new note attached to a record. Notes can contain markdown-formatted content. Specify the parent object and record to attach the note to.`,
+  tags: {
+    destructive: false
+  }
+})
+  .input(
+    z.object({
+      parentObject: z.string().describe('Parent object slug (e.g. "people", "companies")'),
+      parentRecordId: z.string().describe('Parent record ID to attach the note to'),
+      title: z.string().describe('Note title'),
+      content: z.string().optional().describe('Note body content'),
+      format: z
+        .enum(['plaintext', 'markdown'])
+        .optional()
+        .default('plaintext')
+        .describe('Content format')
+    })
+  )
+  .output(noteOutputSchema)
+  .handleInvocation(async ctx => {
+    let client = new AttioClient({ token: ctx.auth.token });
+
+    let note = await client.createNote({
+      parentObject: ctx.input.parentObject,
+      parentRecordId: ctx.input.parentRecordId,
+      title: ctx.input.title,
+      content: ctx.input.content,
+      format: ctx.input.format
+    });
+
+    let output = mapNote(note);
+
+    return {
+      output,
+      message: `Created note **"${output.title}"** on record **${ctx.input.parentRecordId}**.`
+    };
+  })
+  .build();
+
+export let deleteNoteTool = SlateTool.create(spec, {
+  name: 'Delete Note',
+  key: 'delete_note',
+  description: `Permanently delete a note. This action cannot be undone.`,
+  tags: {
+    destructive: true
+  }
+})
+  .input(
+    z.object({
+      noteId: z.string().describe('The note ID to delete')
+    })
+  )
+  .output(
+    z.object({
+      deleted: z.boolean().describe('Whether the note was deleted')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = new AttioClient({ token: ctx.auth.token });
+    await client.deleteNote(ctx.input.noteId);
+
+    return {
+      output: { deleted: true },
+      message: `Deleted note **${ctx.input.noteId}**.`
+    };
+  })
+  .build();

package/src/tools/manage-tasks.ts

@@ -0,0 +1,235 @@
+import { SlateTool } from 'slates';
+import { AttioClient } from '../lib/client';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+let linkedRecordObjectSchema = z.object({
+  targetObject: z.string().describe('Object slug (e.g. "people", "companies")'),
+  targetRecordId: z.string().describe('Record ID')
+});
+
+let linkedRecordSchema = z.union([
+  z
+    .string()
+    .describe('Record reference string accepted by Attio, such as a person email or company domain'),
+  linkedRecordObjectSchema
+]);
+
+let assigneeSchema = z.object({
+  referencedActorType: z.string().describe('Actor type, typically "workspace-member"'),
+  referencedActorId: z.string().describe('Actor ID')
+});
+
+let taskOutputSchema = z.object({
+  taskId: z.string().describe('The task ID'),
+  contentPlaintext: z.string().describe('Task content'),
+  deadlineAt: z.string().optional().nullable().describe('Task deadline date'),
+  isCompleted: z.boolean().describe('Whether the task is completed'),
+  linkedRecords: z
+    .array(
+      z.object({
+        targetObjectId: z.string().describe('Linked object ID'),
+        targetRecordId: z.string().describe('Linked record ID')
+      })
+    )
+    .describe('Records linked to this task'),
+  assignees: z
+    .array(
+      z.object({
+        referencedActorType: z.string().describe('Actor type'),
+        referencedActorId: z.string().describe('Actor ID')
+      })
+    )
+    .describe('Task assignees'),
+  createdAt: z.string().describe('When the task was created')
+});
+
+let mapTask = (t: any) => ({
+  taskId: t.id?.task_id ?? '',
+  contentPlaintext: t.content_plaintext ?? '',
+  deadlineAt: t.deadline_at ?? null,
+  isCompleted: t.is_completed ?? false,
+  linkedRecords: (t.linked_records ?? []).map((r: any) => ({
+    targetObjectId: r.target_object_id ?? '',
+    targetRecordId: r.target_record_id ?? ''
+  })),
+  assignees: (t.assignees ?? []).map((a: any) => ({
+    referencedActorType: a.referenced_actor_type ?? '',
+    referencedActorId: a.referenced_actor_id ?? ''
+  })),
+  createdAt: t.created_at ?? ''
+});
+
+export let listTasksTool = SlateTool.create(spec, {
+  name: 'List Tasks',
+  key: 'list_tasks',
+  description: `List tasks with optional filters for assignee, completion status, and linked records. Returns task content, deadlines, assignees, and linked records.`,
+  tags: {
+    readOnly: true
+  }
+})
+  .input(
+    z.object({
+      linkedObject: z.string().optional().describe('Filter by linked object slug'),
+      linkedRecordId: z.string().optional().describe('Filter by linked record ID'),
+      assignee: z
+        .string()
+        .optional()
+        .describe('Filter by assignee (email, workspace member ID, or null for unassigned)'),
+      isCompleted: z.boolean().optional().describe('Filter by completion status'),
+      sort: z.enum(['created_at:asc', 'created_at:desc']).optional().describe('Sort order'),
+      limit: z.number().optional().default(50).describe('Maximum tasks to return'),
+      offset: z.number().optional().default(0).describe('Number of tasks to skip')
+    })
+  )
+  .output(
+    z.object({
+      tasks: z.array(taskOutputSchema).describe('Tasks'),
+      count: z.number().describe('Number of tasks returned')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = new AttioClient({ token: ctx.auth.token });
+
+    let tasks = await client.listTasks({
+      linkedObject: ctx.input.linkedObject,
+      linkedRecordId: ctx.input.linkedRecordId,
+      assignee: ctx.input.assignee,
+      isCompleted: ctx.input.isCompleted,
+      sort: ctx.input.sort,
+      limit: ctx.input.limit,
+      offset: ctx.input.offset
+    });
+
+    let mapped = tasks.map(mapTask);
+
+    return {
+      output: { tasks: mapped, count: mapped.length },
+      message: `Found **${mapped.length}** task(s).`
+    };
+  })
+  .build();
+
+export let createTaskTool = SlateTool.create(spec, {
+  name: 'Create Task',
+  key: 'create_task',
+  description: `Create a new task in the workspace. Tasks can be assigned to workspace members and linked to records (people, companies, etc.).`,
+  tags: {
+    destructive: false
+  }
+})
+  .input(
+    z.object({
+      content: z.string().describe('Task description/content'),
+      format: z
+        .enum(['plaintext', 'markdown'])
+        .optional()
+        .default('plaintext')
+        .describe('Content format'),
+      deadlineAt: z.string().optional().describe('Deadline in ISO 8601 format or YYYY-MM-DD'),
+      isCompleted: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('Whether the task starts as completed'),
+      linkedRecords: z
+        .array(linkedRecordSchema)
+        .optional()
+        .describe('Record references to link to this task'),
+      assignees: z
+        .array(assigneeSchema)
+        .optional()
+        .describe('Workspace members to assign to this task')
+    })
+  )
+  .output(taskOutputSchema)
+  .handleInvocation(async ctx => {
+    let client = new AttioClient({ token: ctx.auth.token });
+
+    let task = await client.createTask({
+      content: ctx.input.content,
+      format: ctx.input.format,
+      deadlineAt: ctx.input.deadlineAt,
+      isCompleted: ctx.input.isCompleted,
+      linkedRecords: ctx.input.linkedRecords,
+      assignees: ctx.input.assignees
+    });
+
+    let output = mapTask(task);
+
+    return {
+      output,
+      message: `Created task **"${output.contentPlaintext}"**.`
+    };
+  })
+  .build();
+
+export let updateTaskTool = SlateTool.create(spec, {
+  name: 'Update Task',
+  key: 'update_task',
+  description: `Update an existing task's deadline, completion status, linked records, or assignees. Can be used to mark tasks as complete, reassign them, or change deadlines.`,
+  tags: {
+    destructive: false
+  }
+})
+  .input(
+    z.object({
+      taskId: z.string().describe('The task ID to update'),
+      deadlineAt: z
+        .string()
+        .optional()
+        .nullable()
+        .describe('New deadline (ISO 8601 or YYYY-MM-DD), or null to remove'),
+      isCompleted: z.boolean().optional().describe('Set completion status'),
+      linkedRecords: z.array(linkedRecordSchema).optional().describe('Replace linked records'),
+      assignees: z.array(assigneeSchema).optional().describe('Replace assignees')
+    })
+  )
+  .output(taskOutputSchema)
+  .handleInvocation(async ctx => {
+    let client = new AttioClient({ token: ctx.auth.token });
+
+    let task = await client.updateTask(ctx.input.taskId, {
+      deadlineAt: ctx.input.deadlineAt,
+      isCompleted: ctx.input.isCompleted,
+      linkedRecords: ctx.input.linkedRecords,
+      assignees: ctx.input.assignees
+    });
+
+    let output = mapTask(task);
+
+    return {
+      output,
+      message: `Updated task **${output.taskId}**${ctx.input.isCompleted !== undefined ? (ctx.input.isCompleted ? ' (marked complete)' : ' (marked incomplete)') : ''}.`
+    };
+  })
+  .build();
+
+export let deleteTaskTool = SlateTool.create(spec, {
+  name: 'Delete Task',
+  key: 'delete_task',
+  description: `Permanently delete a task. This action cannot be undone.`,
+  tags: {
+    destructive: true
+  }
+})
+  .input(
+    z.object({
+      taskId: z.string().describe('The task ID to delete')
+    })
+  )
+  .output(
+    z.object({
+      deleted: z.boolean().describe('Whether the task was deleted')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = new AttioClient({ token: ctx.auth.token });
+    await client.deleteTask(ctx.input.taskId);
+
+    return {
+      output: { deleted: true },
+      message: `Deleted task **${ctx.input.taskId}**.`
+    };
+  })
+  .build();

package/src/tools/query-records.ts

@@ -0,0 +1,79 @@
+import { SlateTool } from 'slates';
+import { AttioClient } from '../lib/client';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+export let queryRecordsTool = SlateTool.create(spec, {
+  name: 'Query Records',
+  key: 'query_records',
+  description: `Query and filter records from any Attio object using structured filters. Supports sorting, pagination, and complex filter expressions.
+
+Use the shorthand filter format for simple equality: \`{ "email_addresses": "john@example.com" }\`
+Or use the verbose format for complex conditions: \`{ "$and": [{ "name": { "full_name": { "$eq": "John" } } }] }\``,
+  instructions: [
+    'Filter operators include $eq, $contains, $starts_with, $ends_with, $lt, $lte, $gt, $gte, $in, $not_empty.',
+    'Sorts use the format: [{ "direction": "asc"|"desc", "attribute": "attribute_slug" }].'
+  ],
+  constraints: ['Maximum limit is 500 records per request.'],
+  tags: {
+    readOnly: true
+  }
+})
+  .input(
+    z.object({
+      objectSlug: z
+        .string()
+        .describe('Object type slug or ID (e.g. "people", "companies", "deals")'),
+      filter: z.any().optional().describe('Filter expression to match records'),
+      sorts: z.array(z.any()).optional().describe('Sort specification array'),
+      limit: z.number().optional().default(50).describe('Maximum records to return (max 500)'),
+      offset: z
+        .number()
+        .optional()
+        .default(0)
+        .describe('Number of records to skip for pagination')
+    })
+  )
+  .output(
+    z.object({
+      records: z
+        .array(
+          z.object({
+            recordId: z.string().describe('The record ID'),
+            objectId: z.string().describe('The object ID'),
+            createdAt: z.string().describe('When the record was created'),
+            webUrl: z.string().optional().describe('URL to view the record in Attio'),
+            values: z.record(z.string(), z.any()).describe('Record attribute values')
+          })
+        )
+        .describe('Matching records'),
+      count: z.number().describe('Number of records returned')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = new AttioClient({ token: ctx.auth.token });
+
+    let records = await client.queryRecords(ctx.input.objectSlug, {
+      filter: ctx.input.filter,
+      sorts: ctx.input.sorts,
+      limit: ctx.input.limit,
+      offset: ctx.input.offset
+    });
+
+    let mapped = records.map((r: any) => ({
+      recordId: r.id?.record_id ?? '',
+      objectId: r.id?.object_id ?? '',
+      createdAt: r.created_at ?? '',
+      webUrl: r.web_url,
+      values: r.values ?? {}
+    }));
+
+    return {
+      output: {
+        records: mapped,
+        count: mapped.length
+      },
+      message: `Found **${mapped.length}** record(s) in **${ctx.input.objectSlug}**.`
+    };
+  })
+  .build();

package/src/tools/search-records.ts

@@ -0,0 +1,68 @@
+import { SlateTool } from 'slates';
+import { AttioClient } from '../lib/client';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+export let searchRecordsTool = SlateTool.create(spec, {
+  name: 'Search Records',
+  key: 'search_records',
+  description: `Fuzzy search across records in one or more objects. Matches on names, domains, emails, phone numbers, social handles, and labels. Good for finding records when you have partial or approximate information.`,
+  constraints: [
+    'Results are eventually consistent and may not include very recently created records.',
+    'Maximum 25 results per search.'
+  ],
+  tags: {
+    readOnly: true
+  }
+})
+  .input(
+    z.object({
+      query: z.string().describe('Search query text'),
+      objects: z
+        .array(z.string())
+        .min(1)
+        .describe('Object slugs or IDs to search (e.g. ["people", "companies"])'),
+      limit: z.number().optional().default(25).describe('Maximum results (max 25)')
+    })
+  )
+  .output(
+    z.object({
+      records: z
+        .array(
+          z.object({
+            recordId: z.string().describe('The record ID'),
+            objectId: z.string().describe('The object ID'),
+            createdAt: z.string().describe('When the record was created'),
+            webUrl: z.string().optional().describe('URL to view the record in Attio'),
+            values: z.record(z.string(), z.any()).describe('Record attribute values')
+          })
+        )
+        .describe('Matching records'),
+      count: z.number().describe('Number of records returned')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = new AttioClient({ token: ctx.auth.token });
+
+    let records = await client.searchRecords(ctx.input.query, {
+      objects: ctx.input.objects,
+      limit: ctx.input.limit
+    });
+
+    let mapped = records.map((r: any) => ({
+      recordId: r.id?.record_id ?? '',
+      objectId: r.id?.object_id ?? '',
+      createdAt: r.created_at ?? '',
+      webUrl: r.web_url,
+      values: r.values ?? {}
+    }));
+
+    return {
+      output: {
+        records: mapped,
+        count: mapped.length
+      },
+      message: `Found **${mapped.length}** record(s) matching "${ctx.input.query}".`
+    };
+  })
+  .build();

package/src/tools/update-record.ts

@@ -0,0 +1,62 @@
+import { SlateTool } from 'slates';
+import { AttioClient } from '../lib/client';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+export let updateRecordTool = SlateTool.create(spec, {
+  name: 'Update Record',
+  key: 'update_record',
+  description: `Update an existing record's attribute values. By default, multi-select values are appended. Set **overwriteMultiselect** to true to replace multi-select values entirely.`,
+  tags: {
+    destructive: false
+  }
+})
+  .input(
+    z.object({
+      objectSlug: z
+        .string()
+        .describe('Object type slug or ID (e.g. "people", "companies", "deals")'),
+      recordId: z.string().describe('The record ID to update'),
+      values: 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({
+      recordId: z.string().describe('The record ID'),
+      objectId: z.string().describe('The object ID'),
+      createdAt: z.string().describe('When the record was created'),
+      webUrl: z.string().optional().describe('URL to view the record in Attio'),
+      values: z.record(z.string(), z.any()).describe('Updated record attribute values')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = new AttioClient({ token: ctx.auth.token });
+
+    let record = await client.updateRecord(
+      ctx.input.objectSlug,
+      ctx.input.recordId,
+      ctx.input.values,
+      ctx.input.overwriteMultiselect
+    );
+
+    let output = {
+      recordId: record.id?.record_id ?? '',
+      objectId: record.id?.object_id ?? '',
+      createdAt: record.created_at ?? '',
+      webUrl: record.web_url,
+      values: record.values ?? {}
+    };
+
+    return {
+      output,
+      message: `Updated record **${output.recordId}** in **${ctx.input.objectSlug}**.`
+    };
+  })
+  .build();

package/src/triggers/comment-events.ts

@@ -0,0 +1,104 @@
+import { SlateTrigger } from 'slates';
+import { AttioClient } from '../lib/client';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+let COMMENT_EVENT_TYPES = [
+  'comment.created',
+  'comment.resolved',
+  'comment.unresolved',
+  'comment.deleted'
+] as const;
+
+export let commentEventsTrigger = SlateTrigger.create(spec, {
+  name: 'Comment Events',
+  key: 'comment_events',
+  description: 'Triggers when comments are created, resolved, unresolved, or deleted.'
+})
+  .input(
+    z.object({
+      eventType: z.string().describe('Type of comment event'),
+      eventId: z.string().describe('Unique event identifier'),
+      commentId: z.string().describe('The comment ID'),
+      threadId: z.string().optional().describe('The thread ID'),
+      objectId: z.string().optional().describe('Object ID of the record'),
+      recordId: z.string().optional().describe('Record ID the comment is on'),
+      listId: z.string().optional().describe('List ID (for entry-level comments)'),
+      entryId: z.string().optional().describe('Entry ID (for entry-level comments)'),
+      actorType: z.string().optional().describe('Type of actor that triggered the event'),
+      actorId: z.string().optional().describe('ID of the actor that triggered the event')
+    })
+  )
+  .output(
+    z.object({
+      commentId: z.string().describe('The comment ID'),
+      threadId: z.string().optional().describe('The thread ID'),
+      objectId: z.string().optional().describe('Object ID of the record'),
+      recordId: z.string().optional().describe('Record ID the comment is on'),
+      listId: z.string().optional().describe('List ID (for entry-level comments)'),
+      entryId: z.string().optional().describe('Entry ID (for entry-level comments)'),
+      actorType: z.string().optional().describe('Type of actor that triggered the event'),
+      actorId: z.string().optional().describe('ID of the actor that triggered the event')
+    })
+  )
+  .webhook({
+    autoRegisterWebhook: async ctx => {
+      let client = new AttioClient({ token: ctx.auth.token });
+
+      let webhook = await client.createWebhook(
+        ctx.input.webhookBaseUrl,
+        COMMENT_EVENT_TYPES.map(eventType => ({ eventType }))
+      );
+
+      return {
+        registrationDetails: {
+          webhookId: webhook.id?.webhook_id ?? webhook.webhook_id
+        }
+      };
+    },
+
+    autoUnregisterWebhook: async ctx => {
+      let client = new AttioClient({ token: ctx.auth.token });
+      await client.deleteWebhook(ctx.input.registrationDetails.webhookId);
+    },
+
+    handleRequest: async ctx => {
+      let body = (await ctx.request.json()) as any;
+      let events = body.events ?? [];
+
+      let inputs = events
+        .filter((e: any) => COMMENT_EVENT_TYPES.includes(e.event_type))
+        .map((e: any) => ({
+          eventType: e.event_type,
+          eventId: e.id?.event_id ?? `${e.event_type}-${e.id?.comment_id}-${Date.now()}`,
+          commentId: e.id?.comment_id ?? '',
+          threadId: e.id?.thread_id,
+          objectId: e.id?.object_id,
+          recordId: e.id?.record_id,
+          listId: e.id?.list_id,
+          entryId: e.id?.entry_id,
+          actorType: e.actor?.type,
+          actorId: e.actor?.id
+        }));
+
+      return { inputs };
+    },
+
+    handleEvent: async ctx => {
+      return {
+        type: ctx.input.eventType,
+        id: ctx.input.eventId,
+        output: {
+          commentId: ctx.input.commentId,
+          threadId: ctx.input.threadId,
+          objectId: ctx.input.objectId,
+          recordId: ctx.input.recordId,
+          listId: ctx.input.listId,
+          entryId: ctx.input.entryId,
+          actorType: ctx.input.actorType,
+          actorId: ctx.input.actorId
+        }
+      };
+    }
+  })
+  .build();

package/src/triggers/index.ts

@@ -0,0 +1,5 @@
+export * from './record-events';
+export * from './list-entry-events';
+export * from './note-events';
+export * from './task-events';
+export * from './comment-events';