terse-types 0.0.71 → 0.0.72

package/dist/ApiRouteBuilder.d.ts

@@ -88,6 +88,7 @@ export declare const ApiRoutes: {
         INTEGRATIONS: string;
         OAUTH_CALLBACK: string;
         OBJECTS: string;
+        LISTS: string;
     };
     HEY_REACH: {
         INTEGRATIONS: string;

package/dist/ApiRoutes.json

@@ -87,7 +87,8 @@
     "ATTIO": {
         "INTEGRATIONS": "/attio/integrations",
         "OAUTH_CALLBACK": "/attio/oauth/callback",
-        "OBJECTS": "/attio/integrations/:integrationId/objects"
+        "OBJECTS": "/attio/integrations/:integrationId/objects",
+        "LISTS": "/attio/integrations/:integrationId/lists"
     },
     "HEY_REACH": {
         "INTEGRATIONS": "/heyreach/integrations",

package/dist/Events.d.ts

@@ -0,0 +1,112 @@
+import { z } from "zod";
+export declare const eventTypeSchema: z.ZodEnum<{
+    JOB_CREATED: "JOB_CREATED";
+    AUTOMATION_RAN: "AUTOMATION_RAN";
+}>;
+export type EventType = z.infer<typeof eventTypeSchema>;
+declare const jobCreatedEventSchema: z.ZodObject<{
+    eventType: z.ZodLiteral<"JOB_CREATED">;
+    jobId: z.ZodString;
+}, z.core.$strip>;
+export type JobCreatedEvent = z.infer<typeof jobCreatedEventSchema>;
+declare const automationSnapshotSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    organizationId: z.ZodString;
+    projectId: z.ZodString;
+    userId: z.ZodString;
+    requireApproval: z.ZodBoolean;
+}, z.core.$strip>;
+export type AutomationSnapshot = z.infer<typeof automationSnapshotSchema>;
+declare const runSnapshotSchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        readonly SUCCESS: "success";
+        readonly FAILED: "failed";
+        readonly CANCELLED: "cancelled";
+        readonly SKIPPED: "skipped";
+        readonly IN_PROGRESS: "in_progress";
+        readonly AWAITING_APPROVAL: "awaiting_approval";
+    }>;
+    isManuallyTriggered: z.ZodBoolean;
+    startedAt: z.ZodString;
+    trigger: z.ZodObject<{
+        event: z.ZodString;
+        integration: z.ZodEnum<typeof import("./Integrations.js").IntegrationType>;
+        source: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        subheader: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type RunSnapshot = z.infer<typeof runSnapshotSchema>;
+declare const automationRanEventSchema: z.ZodObject<{
+    eventType: z.ZodLiteral<"AUTOMATION_RAN">;
+    automation: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        organizationId: z.ZodString;
+        projectId: z.ZodString;
+        userId: z.ZodString;
+        requireApproval: z.ZodBoolean;
+    }, z.core.$strip>;
+    run: z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodEnum<{
+            readonly SUCCESS: "success";
+            readonly FAILED: "failed";
+            readonly CANCELLED: "cancelled";
+            readonly SKIPPED: "skipped";
+            readonly IN_PROGRESS: "in_progress";
+            readonly AWAITING_APPROVAL: "awaiting_approval";
+        }>;
+        isManuallyTriggered: z.ZodBoolean;
+        startedAt: z.ZodString;
+        trigger: z.ZodObject<{
+            event: z.ZodString;
+            integration: z.ZodEnum<typeof import("./Integrations.js").IntegrationType>;
+            source: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+            subheader: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type AutomationRanEvent = z.infer<typeof automationRanEventSchema>;
+export declare const domainEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    eventType: z.ZodLiteral<"JOB_CREATED">;
+    jobId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    eventType: z.ZodLiteral<"AUTOMATION_RAN">;
+    automation: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        organizationId: z.ZodString;
+        projectId: z.ZodString;
+        userId: z.ZodString;
+        requireApproval: z.ZodBoolean;
+    }, z.core.$strip>;
+    run: z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodEnum<{
+            readonly SUCCESS: "success";
+            readonly FAILED: "failed";
+            readonly CANCELLED: "cancelled";
+            readonly SKIPPED: "skipped";
+            readonly IN_PROGRESS: "in_progress";
+            readonly AWAITING_APPROVAL: "awaiting_approval";
+        }>;
+        isManuallyTriggered: z.ZodBoolean;
+        startedAt: z.ZodString;
+        trigger: z.ZodObject<{
+            event: z.ZodString;
+            integration: z.ZodEnum<typeof import("./Integrations.js").IntegrationType>;
+            source: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+            subheader: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>], "eventType">;
+export type DomainEvent = z.infer<typeof domainEventSchema>;
+export {};

package/dist/Events.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import { runHistoryStatusSchema } from "./RunHistoryTypes.js";
+import { runHistoryTriggerSchema } from "./types.js";
+export const eventTypeSchema = z.enum(["JOB_CREATED", "AUTOMATION_RAN"]);
+const baseEventSchema = z.object({
+    eventType: eventTypeSchema
+});
+const jobCreatedEventSchema = baseEventSchema.extend({
+    eventType: z.literal("JOB_CREATED"),
+    jobId: z.string()
+});
+const automationSnapshotSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    organizationId: z.string(),
+    projectId: z.string(),
+    userId: z.string(),
+    requireApproval: z.boolean()
+});
+const runSnapshotSchema = z.object({
+    id: z.string(),
+    status: runHistoryStatusSchema,
+    isManuallyTriggered: z.boolean(),
+    startedAt: z.string().datetime(),
+    trigger: runHistoryTriggerSchema
+});
+const automationRanEventSchema = baseEventSchema.extend({
+    eventType: z.literal("AUTOMATION_RAN"),
+    automation: automationSnapshotSchema,
+    run: runSnapshotSchema
+});
+export const domainEventSchema = z.discriminatedUnion("eventType", [jobCreatedEventSchema, automationRanEventSchema]);

package/dist/ToolDisplayUtils.js

@@ -40,6 +40,62 @@ function memoryLabel(command, done) {
             return done ? "Renamed memory file" : "Reorganizing memory";
     }
 }
+function safeParseCount(result) {
+    const parsed = safeParseResult(result);
+    return typeof parsed?.count === "number" ? parsed.count : undefined;
+}
+function attioActionLabel(params, noun, done, count) {
+    const request = params?.request;
+    const action = request?.action ?? "";
+    const verbByPrefix = [
+        ["list", ["Loading", "Loaded"]],
+        ["query", ["Loading", "Loaded"]],
+        ["get", ["Loading", "Loaded"]],
+        ["create", ["Creating", "Created"]],
+        ["add", ["Adding", "Added"]],
+        ["upsert", ["Saving", "Saved"]],
+        ["update", ["Updating", "Updated"]],
+        ["upload", ["Uploading", "Uploaded"]],
+        ["delete", ["Deleting", "Deleted"]],
+        ["remove", ["Removing", "Removed"]]
+    ];
+    const match = verbByPrefix.find(([prefix]) => action.startsWith(prefix));
+    const verb = match ? match[1][done ? 1 : 0] : done ? "Finished" : "Working with";
+    const plural = action.startsWith("list") || action.startsWith("query");
+    if (done && count !== undefined && plural)
+        return `${verb} ${count} ${noun}${count !== 1 ? "s" : ""}`;
+    return `${verb} ${noun}${plural ? "s" : ""}`;
+}
+function attioRecordsRequest(params) {
+    const request = params?.request;
+    return request && typeof request === "object" && "action" in request ? request : undefined;
+}
+function attioRecordsLabel(request, done, count) {
+    if (!request)
+        return done ? "Updated records" : "Working with records";
+    const target = `${request.objectSlug} record`;
+    switch (request.action) {
+        case "query":
+        case "search":
+            if (done && count !== undefined)
+                return `Found ${count} ${target}${count !== 1 ? "s" : ""}`;
+            return (done ? "Searched" : "Searching") + ` ${target}s`;
+        case "get":
+            return (done ? "Loaded" : "Loading") + ` ${target}`;
+        case "get_attribute_history":
+            return (done ? "Loaded" : "Loading") + ` ${target} history`;
+        case "create":
+            return (done ? "Created" : "Creating") + ` ${target}`;
+        case "update":
+            return (done ? "Updated" : "Updating") + ` ${target}`;
+        case "upsert":
+            if (done && count !== undefined && count !== 1)
+                return `Saved ${count} ${target}s`;
+            return (done ? "Saved" : "Saving") + ` ${target}`;
+        case "delete":
+            return (done ? "Deleted" : "Deleting") + ` ${target}`;
+    }
+}
 /**
  * Display configurations for all tools.
  * Each tool defines how it should be displayed in preparing, executing, and complete phases.
@@ -672,57 +728,69 @@ const TOOL_DISPLAY_CONFIG = {
     // ===================
     // Attio Tools
     // ===================
-    attio_upsert_record: {
-        preparing: "Getting your record ready",
-        executing: params => {
-            const objectSlug = params?.objectSlug;
-            return objectSlug ? `Saving ${objectSlug} record` : "Saving record";
-        },
+    attio_records: {
+        preparing: "Getting records ready",
+        executing: params => attioRecordsLabel(attioRecordsRequest(params), false),
         complete: (params, result) => {
             const parsed = safeParseResult(result);
-            const actions = parsed?.actions;
-            const target = actions?.[0]?.target;
-            const objectSlug = params?.objectSlug;
-            if (target)
-                return `Saved ${objectSlug || "record"}: ${truncate(target, 30)}`;
-            if (objectSlug)
-                return `Saved ${objectSlug} record`;
-            return "Record saved";
+            const count = parsed?.count;
+            return attioRecordsLabel(attioRecordsRequest(params), true, count);
         },
         approval: params => {
-            const objectSlug = params?.objectSlug;
-            return objectSlug ? `Save ${objectSlug} record?` : "Save this record?";
+            const request = attioRecordsRequest(params);
+            const target = request ? `${request.objectSlug} record` : "record";
+            return request?.action === "delete" ? `Delete this ${target}? This cannot be undone.` : `Save ${target}?`;
         }
     },
-    attio_query_records: {
-        preparing: "Looking up records",
+    attio_workspace_members: {
+        preparing: "Looking up workspace members",
         executing: params => {
-            const objectSlug = params?.objectSlug;
-            return objectSlug ? `Searching ${objectSlug} records` : "Searching records";
+            const request = params?.request;
+            return request?.action === "get" ? "Loading workspace member" : "Loading workspace members";
         },
         complete: (params, result) => {
             const parsed = safeParseResult(result);
             const count = parsed?.count;
-            const objectSlug = params?.objectSlug;
-            if (count !== undefined && objectSlug)
-                return `Found ${count} ${objectSlug} record${count !== 1 ? "s" : ""}`;
-            if (count !== undefined)
-                return `Found ${count} record${count !== 1 ? "s" : ""}`;
-            if (objectSlug)
-                return `Searched ${objectSlug} records`;
-            return "Search complete";
-        }
-    },
-    attio_list_objects: {
-        preparing: "Loading object types",
-        executing: () => "Loading object types",
-        complete: (_params, result) => {
-            const parsed = safeParseResult(result);
-            const count = parsed?.count;
-            if (count !== undefined)
-                return `Found ${count} object type${count !== 1 ? "s" : ""}`;
-            return "Object types loaded";
-        }
+            const request = params?.request;
+            if (request?.action === "get")
+                return "Loaded workspace member";
+            return count !== undefined ? `Found ${count} workspace member${count !== 1 ? "s" : ""}` : "Workspace members loaded";
+        }
+    },
+    attio_tasks: {
+        preparing: "Working with tasks",
+        executing: params => attioActionLabel(params, "task", false),
+        complete: (params, result) => attioActionLabel(params, "task", true, safeParseCount(result))
+    },
+    attio_notes: {
+        preparing: "Working with notes",
+        executing: params => attioActionLabel(params, "note", false),
+        complete: (params, result) => attioActionLabel(params, "note", true, safeParseCount(result))
+    },
+    attio_comments: {
+        preparing: "Working with comments",
+        executing: params => attioActionLabel(params, "comment", false),
+        complete: (params, result) => attioActionLabel(params, "comment", true, safeParseCount(result))
+    },
+    attio_lists: {
+        preparing: "Working with lists",
+        executing: params => attioActionLabel(params, "list entry", false),
+        complete: (params, result) => attioActionLabel(params, "list entry", true, safeParseCount(result))
+    },
+    attio_meetings: {
+        preparing: "Loading meetings",
+        executing: params => attioActionLabel(params, "meeting", false),
+        complete: (params, result) => attioActionLabel(params, "meeting", true, safeParseCount(result))
+    },
+    attio_files: {
+        preparing: "Working with files",
+        executing: params => attioActionLabel(params, "file", false),
+        complete: (params, result) => attioActionLabel(params, "file", true, safeParseCount(result))
+    },
+    attio_schema: {
+        preparing: "Loading workspace schema",
+        executing: params => attioActionLabel(params, "schema item", false),
+        complete: (params, result) => attioActionLabel(params, "schema item", true, safeParseCount(result))
     },
     // ===================
     // WorkOS Tools