terse-types 0.0.73 → 0.0.75

package/dist/AttioRecordFlatten.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Collapses a single Attio value entry (or nested structure) toward primitives /
+ * simple objects, matching the shape produced for generated Attio tool outputs.
+ */
+export declare function flattenAttioLeafValue(value: unknown): unknown;
+/**
+ * Flattens one attribute’s raw value (often an array of interaction rows from the REST API).
+ * @param preferArray When true, keep all entries as an array; when false, use the first entry only.
+ */
+export declare function flattenAttioAttributeValue(rawValue: unknown, preferArray: boolean): unknown;
+/**
+ * Flattens `record.values` from Attio’s GET record / webhook enrichment payload.
+ */
+export declare function flattenAttioRecordValues(values: Record<string, unknown>, isMultiValueAttribute: (attributeSlug: string) => boolean): Record<string, unknown>;
+/**
+ * Slug-only heuristic when object attribute metadata is unavailable (e.g. Attio webhook triggers).
+ * Prefer {@link flattenAttioRecordValues} with object-aware multi-value info from codegen when possible.
+ */
+export declare function isProbablyAttioMultiValueAttributeSlug(attributeSlug: string): boolean;

package/dist/AttioRecordFlatten.js

@@ -0,0 +1,71 @@
+/** Keys Attio nests on attribute timeline entries (not the semantic payload). */
+const ATTIO_VALUE_METADATA_KEYS = new Set([
+    "active_from",
+    "active_until",
+    "attribute_type",
+    "created_by_actor"
+]);
+/**
+ * Collapses a single Attio value entry (or nested structure) toward primitives /
+ * simple objects, matching the shape produced for generated Attio tool outputs.
+ */
+export function flattenAttioLeafValue(value) {
+    if (value === null || value === undefined)
+        return value;
+    if (Array.isArray(value))
+        return value.map(entry => flattenAttioLeafValue(entry));
+    if (typeof value !== "object")
+        return value;
+    const rawObject = value;
+    if (typeof rawObject.full_name === "string")
+        return rawObject.full_name;
+    if (typeof rawObject.email_address === "string")
+        return rawObject.email_address;
+    if (typeof rawObject.domain === "string")
+        return rawObject.domain;
+    if (typeof rawObject.phone_number === "string")
+        return rawObject.phone_number;
+    if ("value" in rawObject)
+        return flattenAttioLeafValue(rawObject.value);
+    const dataEntries = Object.entries(rawObject).filter(([key]) => !ATTIO_VALUE_METADATA_KEYS.has(key));
+    if (dataEntries.length === 0)
+        return rawObject;
+    if (dataEntries.length === 1)
+        return flattenAttioLeafValue(dataEntries[0][1]);
+    return Object.fromEntries(dataEntries.map(([key, entryValue]) => [key, flattenAttioLeafValue(entryValue)]));
+}
+/**
+ * Flattens one attribute’s raw value (often an array of interaction rows from the REST API).
+ * @param preferArray When true, keep all entries as an array; when false, use the first entry only.
+ */
+export function flattenAttioAttributeValue(rawValue, preferArray) {
+    if (!Array.isArray(rawValue))
+        return flattenAttioLeafValue(rawValue);
+    const flattened = rawValue.map(entry => flattenAttioLeafValue(entry)).filter(entry => entry !== undefined);
+    return preferArray ? flattened : flattened[0];
+}
+/**
+ * Flattens `record.values` from Attio’s GET record / webhook enrichment payload.
+ */
+export function flattenAttioRecordValues(values, isMultiValueAttribute) {
+    const flattenedValues = {};
+    for (const [attributeSlug, rawValue] of Object.entries(values)) {
+        flattenedValues[attributeSlug] = flattenAttioAttributeValue(rawValue, isMultiValueAttribute(attributeSlug));
+    }
+    return flattenedValues;
+}
+/**
+ * Slug-only heuristic when object attribute metadata is unavailable (e.g. Attio webhook triggers).
+ * Prefer {@link flattenAttioRecordValues} with object-aware multi-value info from codegen when possible.
+ */
+export function isProbablyAttioMultiValueAttributeSlug(attributeSlug) {
+    const slug = attributeSlug.toLowerCase();
+    return (slug === "email_addresses" ||
+        slug === "domains" ||
+        slug === "phone_numbers" ||
+        slug === "social_profiles" ||
+        slug === "links" ||
+        slug === "tags" ||
+        slug.endsWith("_addresses") ||
+        slug.endsWith("_ids"));
+}

package/dist/OrganizationMetadata.d.ts

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export declare const organizationMetadataSchema: z.ZodObject<{
+    stripeCustomerId: z.ZodString;
+    runExecutionBlocked: z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>, z.ZodTransform<boolean, string | boolean | undefined>>;
+}, z.core.$strip>;
+export type OrganizationMetadata = z.infer<typeof organizationMetadataSchema>;

package/dist/OrganizationMetadata.js

@@ -0,0 +1,10 @@
+import { z } from "zod";
+// Can be serialized a string, supports deserialization
+const booleanMetadataSchema = z
+    .union([z.boolean(), z.string()])
+    .optional()
+    .transform(value => value === true || value === "true");
+export const organizationMetadataSchema = z.object({
+    stripeCustomerId: z.string(),
+    runExecutionBlocked: booleanMetadataSchema
+});

package/dist/ToolDisplayUtils.js

@@ -66,13 +66,13 @@ function attioActionLabel(params, noun, done, count) {
         return `${verb} ${count} ${noun}${count !== 1 ? "s" : ""}`;
     return `${verb} ${noun}${plural ? "s" : ""}`;
 }
-function attioRecordsRequest(params) {
+function attioReadRecordsRequest(params) {
     const request = params?.request;
     return request && typeof request === "object" && "action" in request ? request : undefined;
 }
-function attioRecordsLabel(request, done, count) {
+function attioReadRecordsLabel(request, done, count) {
     if (!request)
-        return done ? "Updated records" : "Working with records";
+        return done ? "Loaded records" : "Loading records";
     const target = `${request.objectSlug} record`;
     switch (request.action) {
         case "query":
@@ -84,18 +84,15 @@ function attioRecordsLabel(request, done, count) {
             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}`;
     }
 }
+function attioRecordTarget(params) {
+    const request = params?.request;
+    return request?.objectSlug ? `${request.objectSlug} record` : "record";
+}
+function attioWriteDisplay(gerund, past, approvalPrompt) {
+    return { preparing: gerund, executing: () => gerund, complete: () => past, approval: () => approvalPrompt };
+}
 /**
  * Display configurations for all tools.
  * Each tool defines how it should be displayed in preparing, executing, and complete phases.
@@ -728,20 +725,44 @@ const TOOL_DISPLAY_CONFIG = {
     // ===================
     // Attio Tools
     // ===================
-    attio_records: {
-        preparing: "Getting records ready",
-        executing: params => attioRecordsLabel(attioRecordsRequest(params), false),
+    attio_read_records: {
+        preparing: "Loading records",
+        executing: params => attioReadRecordsLabel(attioReadRecordsRequest(params), false),
         complete: (params, result) => {
             const parsed = safeParseResult(result);
             const count = parsed?.count;
-            return attioRecordsLabel(attioRecordsRequest(params), true, count);
-        },
-        approval: params => {
-            const request = attioRecordsRequest(params);
-            const target = request ? `${request.objectSlug} record` : "record";
-            return request?.action === "delete" ? `Delete this ${target}? This cannot be undone.` : `Save ${target}?`;
+            return attioReadRecordsLabel(attioReadRecordsRequest(params), true, count);
         }
     },
+    attio_create_record: {
+        preparing: "Getting record ready",
+        executing: params => `Creating ${attioRecordTarget(params)}`,
+        complete: params => `Created ${attioRecordTarget(params)}`,
+        approval: params => `Create ${attioRecordTarget(params)}?`
+    },
+    attio_update_record: {
+        preparing: "Getting record updates ready",
+        executing: params => `Updating ${attioRecordTarget(params)}`,
+        complete: params => `Updated ${attioRecordTarget(params)}`,
+        approval: params => `Update ${attioRecordTarget(params)}?`
+    },
+    attio_upsert_record: {
+        preparing: "Getting records ready",
+        executing: params => `Saving ${attioRecordTarget(params)}`,
+        complete: (params, result) => {
+            const count = safeParseCount(result);
+            if (count !== undefined && count !== 1)
+                return `Saved ${count} ${attioRecordTarget(params)}s`;
+            return `Saved ${attioRecordTarget(params)}`;
+        },
+        approval: params => `Save ${attioRecordTarget(params)}?`
+    },
+    attio_delete_record: {
+        preparing: "Getting record ready",
+        executing: params => `Deleting ${attioRecordTarget(params)}`,
+        complete: params => `Deleted ${attioRecordTarget(params)}`,
+        approval: params => `Delete this ${attioRecordTarget(params)}? This cannot be undone.`
+    },
     attio_workspace_members: {
         preparing: "Looking up workspace members",
         executing: params => {
@@ -757,41 +778,67 @@ const TOOL_DISPLAY_CONFIG = {
             return count !== undefined ? `Found ${count} workspace member${count !== 1 ? "s" : ""}` : "Workspace members loaded";
         }
     },
-    attio_tasks: {
-        preparing: "Working with tasks",
+    attio_read_tasks: {
+        preparing: "Loading tasks",
         executing: params => attioActionLabel(params, "task", false),
         complete: (params, result) => attioActionLabel(params, "task", true, safeParseCount(result))
     },
-    attio_notes: {
-        preparing: "Working with notes",
+    attio_create_task: attioWriteDisplay("Creating task", "Created task", "Create this task?"),
+    attio_update_task: attioWriteDisplay("Updating task", "Updated task", "Update this task?"),
+    attio_delete_task: attioWriteDisplay("Deleting task", "Deleted task", "Delete this task? This cannot be undone."),
+    attio_read_notes: {
+        preparing: "Loading notes",
         executing: params => attioActionLabel(params, "note", false),
         complete: (params, result) => attioActionLabel(params, "note", true, safeParseCount(result))
     },
-    attio_comments: {
-        preparing: "Working with comments",
+    attio_create_note: attioWriteDisplay("Creating note", "Created note", "Create this note?"),
+    attio_delete_note: attioWriteDisplay("Deleting note", "Deleted note", "Delete this note? This cannot be undone."),
+    attio_read_comments: {
+        preparing: "Loading comments",
         executing: params => attioActionLabel(params, "comment", false),
         complete: (params, result) => attioActionLabel(params, "comment", true, safeParseCount(result))
     },
-    attio_lists: {
-        preparing: "Working with lists",
+    attio_create_comment: attioWriteDisplay("Creating comment", "Created comment", "Create this comment?"),
+    attio_delete_comment: attioWriteDisplay("Deleting comment", "Deleted comment", "Delete this comment? This cannot be undone."),
+    attio_read_lists: {
+        preparing: "Loading lists",
+        executing: params => attioActionLabel(params, "list", false),
+        complete: (params, result) => attioActionLabel(params, "list", true, safeParseCount(result))
+    },
+    attio_create_list: attioWriteDisplay("Creating list", "Created list", "Create this list?"),
+    attio_update_list: attioWriteDisplay("Updating list", "Updated list", "Update this list?"),
+    attio_read_list_entries: {
+        preparing: "Loading list entries",
         executing: params => attioActionLabel(params, "list entry", false),
         complete: (params, result) => attioActionLabel(params, "list entry", true, safeParseCount(result))
     },
+    attio_add_list_entry: attioWriteDisplay("Adding list entry", "Added list entry", "Add this list entry?"),
+    attio_upsert_list_entry: attioWriteDisplay("Saving list entry", "Saved list entry", "Save this list entry?"),
+    attio_update_list_entry: attioWriteDisplay("Updating list entry", "Updated list entry", "Update this list entry?"),
+    attio_remove_list_entry: attioWriteDisplay("Removing list entry", "Removed list entry", "Remove this list entry?"),
     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",
+    attio_read_files: {
+        preparing: "Loading files",
         executing: params => attioActionLabel(params, "file", false),
         complete: (params, result) => attioActionLabel(params, "file", true, safeParseCount(result))
     },
-    attio_schema: {
+    attio_upload_file: attioWriteDisplay("Uploading file", "Uploaded file", "Upload this file?"),
+    attio_delete_file: attioWriteDisplay("Deleting file", "Deleted file", "Delete this file? This cannot be undone."),
+    attio_read_schema: {
         preparing: "Loading workspace schema",
         executing: params => attioActionLabel(params, "schema item", false),
         complete: (params, result) => attioActionLabel(params, "schema item", true, safeParseCount(result))
     },
+    attio_modify_schema: {
+        preparing: "Updating workspace schema",
+        executing: params => attioActionLabel(params, "schema item", false),
+        complete: (params, result) => attioActionLabel(params, "schema item", true, safeParseCount(result)),
+        approval: () => "Change the workspace schema? This affects every user."
+    },
     // ===================
     // WorkOS Tools
     // ===================