@uniformdev/automations-sdk 20.72.3-alpha.25 → 20.72.3-alpha.45

package/dist/api/index.d.mts

@@ -393,6 +393,8 @@ interface paths {
                 query: {
                     /** @description The project ID. */
                     projectId: string;
+                    /** @description Comma-separated list of automation public IDs to return. Omit to return all. */
+                    automationIDs?: string;
                 };
                 header?: never;
                 path?: never;
@@ -415,6 +417,13 @@ interface paths {
                                 name: string;
                                 /** @description Optional description. */
                                 description: string | null;
+                                /**
+                                 * @description How the automation behaves: a bundled TypeScript handler, or Scout instructions.
+                                 * @enum {string}
+                                 */
+                                kind: "typescript" | "scout";
+                                /** @description The stored instructions for a `scout` automation; null for any other kind. */
+                                instructions: string | null;
                                 /** @description The triggers this automation subscribes to. */
                                 triggers: {
                                     /** @description How the automation is triggered. */
@@ -490,6 +499,8 @@ interface paths {
          * @deprecated
          * @description Deploys (creates or updates) an automation.
          *
+         *     Set `kind` to `typescript` to deploy a bundled handler module, or to `scout` to have the automation run the Scout agent against stored natural-language instructions on each trigger.
+         *
          *     This is experimental functionality that is subject to change without notice.
          */
         put: {
@@ -548,10 +559,69 @@ interface paths {
                                 [key: string]: string | string[];
                             };
                         };
+                        /**
+                         * @description Runs a bundled TypeScript handler module.
+                         * @enum {string}
+                         */
+                        kind: "typescript";
                         /** @description Bundled JavaScript module for the automation handler. */
                         code: string;
                         /** @description Target date for runtime compatibility. Runtime changes after this date may not apply to this automation. */
                         compatibilityDate?: string;
+                    } | {
+                        /** @description The project ID. */
+                        projectId: string;
+                        /** @description Stable public identifier for the automation. */
+                        publicId: string;
+                        /** @description Display name of the automation. */
+                        name: string;
+                        /** @description For automations triggered as an AI tool, this is used to determine when an LLM should call the automation. For other triggers, this is for your reference and optional. */
+                        description?: string;
+                        /** @description The triggers this automation subscribes to. */
+                        triggers: ({
+                            /**
+                             * @description The internal webhook event name that triggers this automation.
+                             * @enum {string}
+                             */
+                            type: "asset.deleted" | "asset.published" | "composition.changed" | "composition.deleted" | "composition.published" | "composition.release.changed" | "composition.release.deleted" | "composition.release.published" | "composition.release.restored" | "entry.changed" | "entry.deleted" | "entry.published" | "entry.release.changed" | "entry.release.deleted" | "entry.release.published" | "entry.release.restored" | "manifest.published" | "notification.created" | "projectmap.delete" | "projectmap.node.delete" | "projectmap.node.insert" | "projectmap.node.update" | "projectmap.update" | "redirect.delete" | "redirect.insert" | "redirect.update" | "release.changed" | "release.deleted" | "release.launch_started" | "release.launched" | "workflow.transition";
+                            /** @description Optional CEL boolean expression evaluated against { input, trigger }; the automation runs only when it is true. */
+                            filter?: string;
+                        } | {
+                            /** @enum {string} */
+                            type: "schedule";
+                            /** @description RFC 5545 recurrence rule for when the automation runs. */
+                            rrule: string;
+                            /** @description IANA timezone used to evaluate the recurrence rule. */
+                            timezone: string;
+                        } | {
+                            /** @enum {string} */
+                            type: "incomingWebhook";
+                            /** @description Optional CEL boolean expression evaluated against { input, trigger }; the automation runs only when it is true. */
+                            filter?: string;
+                        } | {
+                            /** @enum {string} */
+                            type: "aiTool";
+                            /** @description JSON Schema describing the AI tool arguments. */
+                            inputSchema: {
+                                [key: string]: unknown;
+                            };
+                        })[];
+                        /** @description Role grants for the automation identity. The caller must hold each requested role (or be a team admin). Required: a Scout automation acts solely through its machine identity, so without a role grant it has no authority to act. */
+                        permissions: {
+                            /** @description Role grant(s) on the project the automation is deployed to. */
+                            role: string | string[];
+                            /** @description Additional project role grants keyed by project ID for cross-project access within the same team. */
+                            projects?: {
+                                [key: string]: string | string[];
+                            };
+                        };
+                        /**
+                         * @description Runs the Scout agent headlessly against stored instructions.
+                         * @enum {string}
+                         */
+                        kind: "scout";
+                        /** @description The instructions Scout runs on each trigger. */
+                        instructions: string;
                     };
                 };
             };
@@ -747,8 +817,21 @@ type AutomationSummary = AutomationsListResponse['automations'][number];
 type AutomationTrigger = AutomationSummary['triggers'][number];
 type AutomationTriggerType = AutomationTrigger['config']['type'];
 type AutomationsDeployBody = paths['/api/v1/automations']['put']['requestBody']['content']['application/json'];
+/**
+ * `Omit` over each member of a union separately, so the `kind` discriminant still narrows the
+ * result. Plain `Omit` would flatten the union into one object type and lose that.
+ */
+type DistributiveOmit<T, K extends keyof never> = T extends unknown ? Omit<T, K> : never;
 /** Deploy input without the project ID, which the client injects from its options. */
-type AutomationsDeployInput = Omit<AutomationsDeployBody, 'projectId'>;
+type AutomationsDeployInput = DistributiveOmit<AutomationsDeployBody, 'projectId'>;
+/** The `typescript` member of the deploy input — an automation with a bundled handler module. */
+type TypeScriptAutomationDeployInput = Extract<AutomationsDeployInput, {
+    kind: 'typescript';
+}>;
+/** The `scout` member of the deploy input — an automation Scout runs from stored instructions. */
+type ScoutAutomationDeployInput = Extract<AutomationsDeployInput, {
+    kind: 'scout';
+}>;
 type AutomationRunsListResponse = paths$1['/api/v1/automation-runs']['get']['responses']['200']['content']['application/json'];
 type AutomationRunSummary = AutomationRunsListResponse['runs'][number];
 type AutomationRunStatus = AutomationRunSummary['status'];
@@ -764,14 +847,19 @@ type AutomationsClientOptions = Omit<ClientOptions, 'projectId'> & {
  */
 declare class AutomationsClient extends ApiClient<AutomationsClientOptions> {
     #private;
+    /**
+     * Fetches a single automation by public ID.
+     *
+     * @param publicId - The automation public ID.
+     * @throws ApiClientError with status 404 when no such automation exists.
+     */
+    get(publicId: string): Promise<AutomationSummary>;
     /**
      * Lists the automations configured for a project.
      */
     list(): Promise<AutomationsListResponse>;
     /**
      * Deploys (creates or updates) a single automation.
-     *
-     * @param input - The automation definition + bundled code.
      */
     deploy(input: AutomationsDeployInput): Promise<void>;
     /**
@@ -813,4 +901,4 @@ declare class AutomationsClient extends ApiClient<AutomationsClientOptions> {
     listRunLogs(runId: string): Promise<AutomationRunLogEntry[]>;
 }
 
-export { type AutomationRunLogEntry, type AutomationRunStatus, type AutomationRunSummary, type AutomationRunTriggerResponse, type AutomationRunsListResponse, type AutomationSummary, type AutomationTrigger, type AutomationTriggerType, AutomationsClient, type AutomationsClientOptions, type AutomationsDeployBody, type AutomationsDeployInput, type AutomationsListResponse };
+export { type AutomationRunLogEntry, type AutomationRunStatus, type AutomationRunSummary, type AutomationRunTriggerResponse, type AutomationRunsListResponse, type AutomationSummary, type AutomationTrigger, type AutomationTriggerType, AutomationsClient, type AutomationsClientOptions, type AutomationsDeployBody, type AutomationsDeployInput, type AutomationsListResponse, type ScoutAutomationDeployInput, type TypeScriptAutomationDeployInput };

package/dist/api/index.mjs

@@ -7,9 +7,28 @@ import {
 } from "../chunk-I6KKUHEY.mjs";
 
 // src/api/AutomationsClient.ts
-import { ApiClient } from "@uniformdev/context/api";
+import { ApiClient, ApiClientError } from "@uniformdev/context/api";
 var _automationsUrl, _runsUrl, _logsUrl;
 var _AutomationsClient = class _AutomationsClient extends ApiClient {
+  /**
+   * Fetches a single automation by public ID.
+   *
+   * @param publicId - The automation public ID.
+   * @throws ApiClientError with status 404 when no such automation exists.
+   */
+  async get(publicId) {
+    const { projectId } = this.options;
+    const url = this.createUrl(__privateGet(_AutomationsClient, _automationsUrl), {
+      projectId,
+      automationIDs: [publicId]
+    });
+    const { automations } = await this.apiClient(url);
+    const automation = automations[0];
+    if (!automation) {
+      throw new ApiClientError("Automation not found", "GET", url.toString(), 404, "Not Found");
+    }
+    return automation;
+  }
   /**
    * Lists the automations configured for a project.
    */
@@ -21,8 +40,6 @@ var _AutomationsClient = class _AutomationsClient extends ApiClient {
   }
   /**
    * Deploys (creates or updates) a single automation.
-   *
-   * @param input - The automation definition + bundled code.
    */
   async deploy(input) {
     const { projectId } = this.options;

package/dist/index.d.mts

@@ -2,6 +2,7 @@ import { StandardSchemaV1 } from '@standard-schema/spec';
 import { WebhookEventName, WebhookPayloadFor } from '@uniformdev/webhooks';
 import { AutomationResult, AutomationLogEntry } from './schemas/index.mjs';
 export { f as formatAutomationWebhookUrl } from './formatAutomationWebhookUrl-CD1HQmu6.mjs';
+import { ApiClient, ClientOptions } from '@uniformdev/context/api';
 import 'zod';
 
 /**
@@ -74,6 +75,16 @@ type JsonSchemaObject = Record<string, unknown>;
  * Note: non-zod standard schema providers are not supported.
  */
 type AiToolInputSchema = StandardSchemaV1 | JsonSchemaObject;
+/**
+ * Maximum length of a Scout automation's instructions, in UTF-16 code units (what `String.length`
+ * counts, and what the deploy API's `z.string().max()` measures).
+ *
+ * The instructions travel in the run's Cloudflare Queues message, which is hard-capped at 128 KB and
+ * already carries up to 64 KB of captured input plus credentials. 16 K is far more than authored
+ * instructions need and leaves the envelope with ample headroom. Like any ingress cap this can be
+ * raised later but never lowered.
+ */
+declare const AUTOMATION_INSTRUCTIONS_MAX_LENGTH: number;
 /**
  * Role grants for the automation's identity.
  */
@@ -130,6 +141,28 @@ type AiToolAutomationMetadata = AutomationMetadataBase & {
 };
 /** Authored metadata declared via {@link defineAutomation}. */
 type AutomationMetadata = ComposedAutomationMetadata | AiToolAutomationMetadata;
+/**
+ * Authored metadata for a Scout automation — one with no handler, whose behavior is the instructions
+ * the agent runs on each trigger.
+ *
+ * Two fields differ from a handler automation, both because the automation has no code of its own:
+ * - `permissions` is **required**. A Scout automation's only actions are the agent's tool calls, and
+ *   every one of them acts as the automation's machine identity. With no role grant there is no
+ *   identity, so the run has no authority to do anything at all.
+ * - there is no `compatibilityDate`. The runtime the agent runs on is Uniform's, not yours.
+ *
+ * `aiTool` is also absent from the trigger union: an `aiTool` automation *is* a tool the agent calls,
+ * so an agent-driven one would be circular.
+ */
+type ScoutAutomationMetadata = {
+    /** Display name surfaced in the dashboard and run history. */
+    name: string;
+    description?: string;
+    /** One or more triggers this automation subscribes to. */
+    triggers: [ComposableTriggerConfig, ...ComposableTriggerConfig[]];
+    /** Role grants for the automation's identity. Required — see {@link ScoutAutomationMetadata}. */
+    permissions: AutomationPermissions;
+};
 
 /**
  * Per-run Uniform API connection parameters.
@@ -331,6 +364,8 @@ type TriggersOf<M extends AutomationMetadata> = M extends {
 type HandlerFromAutomationMetadata<M extends AutomationMetadata> = AutomationHandler<InputFromAutomationMetadata<M>, TriggerFromAutomationMetadata<M>, CredentialsFromAutomationMetadata<M>>;
 /** A fully defined automation module: a callable invoke function with authored metadata attached. */
 type AutomationDefinition<M extends AutomationMetadata = AutomationMetadata> = AutomationInvoker & {
+    /** Discriminates a handler automation module from a Scout one (see `defineScoutAutomation`). */
+    kind: 'typescript';
     metadata: M;
 };
 /**
@@ -370,4 +405,411 @@ declare function defineAutomation<const M extends AutomationMetadata>(config: {
     handler: HandlerFromAutomationMetadata<M>;
 }): AutomationDefinition<M>;
 
-export { type AiToolAutomationMetadata, type AiToolInputSchema, type AiToolTriggerConfig, type AutomationContext, type AutomationDefinition, type AutomationHandler, type AutomationInvokePayload, type AutomationInvoker, AutomationLogEntry, type AutomationLogLevel, type AutomationLogger, type AutomationMetadata, type AutomationPermissions, AutomationResult, type ComposableTriggerConfig, type ComposedAutomationMetadata, type CredentialsFromAutomationMetadata, type EventTriggerConfig, type HandlerFromAutomationMetadata, type IncomingWebhookInput, type IncomingWebhookTriggerConfig, type InputFromAutomationMetadata, type JsonSchemaObject, type ScheduleRunInput, type ScheduleTriggerConfig, type TriggerConfig, type TriggerFromAutomationMetadata, type UniformConnectionParams, defineAutomation };
+/**
+ * A fully defined Scout automation module: authored metadata plus the instructions the agent runs.
+ *
+ * Unlike {@link AutomationDefinition} this is *not* callable — a Scout automation has no local
+ * handler to invoke. The deploy API generates the runner from the instructions, so the module exists
+ * only to declare them.
+ */
+type ScoutAutomationDefinition<M extends ScoutAutomationMetadata = ScoutAutomationMetadata> = {
+    /** Discriminates a Scout automation module from a handler one. */
+    kind: 'scout';
+    metadata: M;
+    /** The instructions the agent runs on each trigger. */
+    instructions: string;
+};
+/**
+ * Defines an automation that uses Scout to perform a task.
+ *
+ * @param metadata - Name, triggers, and the role grants the run acts under. `permissions` is required.
+ * @param instructions - What the agent should do on each trigger.
+ * @returns A default-exportable Scout automation definition.
+ */
+declare function defineScoutAutomation<const M extends ScoutAutomationMetadata>(metadata: M, instructions: string): ScoutAutomationDefinition<M>;
+
+interface paths {
+    "/api/v1/notifications": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * @deprecated
+         * @description Lists the current user's notifications. Results are cursor-paginated newest-first and may be scoped to the current team. Omit teamId to list every notification for the caller.
+         */
+        get: {
+            parameters: {
+                query?: {
+                    /** @description Opaque cursor returned by the previous response. Omit to read the newest page of notifications. */
+                    cursor?: string;
+                    /** @description When true, only unread notifications are returned. */
+                    unreadOnly?: boolean | null;
+                    /** @description Optional team scope. Use teamId to limit results to one team. */
+                    teamId?: string;
+                    /** @description Maximum number of notifications to return. Defaults to 50. */
+                    limit?: number;
+                };
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            notifications: {
+                                id: string;
+                                /**
+                                 * @description The notification content type. Currently, only text notifications are supported.
+                                 * @enum {string}
+                                 */
+                                type: "text";
+                                teamId: string;
+                                project: {
+                                    id: string;
+                                    name: string;
+                                } | null;
+                                author: {
+                                    subject: string;
+                                    name: string;
+                                } | null;
+                                summary: {
+                                    /** @enum {string} */
+                                    format: "markdown";
+                                    value: string;
+                                };
+                                entity?: {
+                                    entityId: string;
+                                    /** @enum {string} */
+                                    type: "entry" | "composition";
+                                    releaseId?: string;
+                                    editionId?: string;
+                                } | {
+                                    entityId: string;
+                                    /** @enum {string} */
+                                    type: "entryPattern" | "componentPattern" | "compositionPattern";
+                                    releaseId?: string;
+                                } | {
+                                    entityId: string;
+                                    /** @enum {string} */
+                                    type: "component" | "contentType" | "blockType" | "asset" | "audience" | "intent" | "enrichment" | "signal" | "quirk" | "test" | "projectMapNode";
+                                } | {
+                                    /** @enum {string} */
+                                    type: "external";
+                                    /** Format: uri */
+                                    url: string;
+                                };
+                                /** Format: date-time */
+                                createdAt: string;
+                                /** Format: date-time */
+                                readAt?: string | null;
+                            }[];
+                            cursor?: string;
+                            unreadCount: number;
+                        };
+                    };
+                };
+                400: components["responses"]["BadRequestError"];
+                401: components["responses"]["UnauthorizedError"];
+                403: components["responses"]["ForbiddenError"];
+                429: components["responses"]["RateLimitError"];
+                500: components["responses"]["InternalServerError"];
+            };
+        };
+        put?: never;
+        /**
+         * @deprecated
+         * @description Creates a project-scoped notification for recipients who belong to the project's team. The caller must have access to the project. A missing or inaccessible project returns 404.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": {
+                        recipients: string[];
+                        /**
+                         * @description The notification content type. Currently, only text notifications are supported.
+                         * @default text
+                         * @enum {string}
+                         */
+                        type?: "text";
+                        summary: {
+                            /** @enum {string} */
+                            format: "markdown";
+                            value: string;
+                        };
+                        entity?: {
+                            entityId: string;
+                            /** @enum {string} */
+                            type: "entry" | "composition";
+                            releaseId?: string;
+                            editionId?: string;
+                        } | {
+                            entityId: string;
+                            /** @enum {string} */
+                            type: "entryPattern" | "componentPattern" | "compositionPattern";
+                            releaseId?: string;
+                        } | {
+                            entityId: string;
+                            /** @enum {string} */
+                            type: "component" | "contentType" | "blockType" | "asset" | "audience" | "intent" | "enrichment" | "signal" | "quirk" | "test" | "projectMapNode";
+                        } | {
+                            /** @enum {string} */
+                            type: "external";
+                            /** Format: uri */
+                            url: string;
+                        };
+                        projectId: string;
+                    };
+                };
+            };
+            responses: {
+                /** @description Created */
+                201: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            id: string;
+                            /**
+                             * @description The notification content type. Currently, only text notifications are supported.
+                             * @enum {string}
+                             */
+                            type: "text";
+                            teamId: string;
+                            project: {
+                                id: string;
+                                name: string;
+                            } | null;
+                            author: {
+                                subject: string;
+                                name: string;
+                            } | null;
+                            summary: {
+                                /** @enum {string} */
+                                format: "markdown";
+                                value: string;
+                            };
+                            entity?: {
+                                entityId: string;
+                                /** @enum {string} */
+                                type: "entry" | "composition";
+                                releaseId?: string;
+                                editionId?: string;
+                            } | {
+                                entityId: string;
+                                /** @enum {string} */
+                                type: "entryPattern" | "componentPattern" | "compositionPattern";
+                                releaseId?: string;
+                            } | {
+                                entityId: string;
+                                /** @enum {string} */
+                                type: "component" | "contentType" | "blockType" | "asset" | "audience" | "intent" | "enrichment" | "signal" | "quirk" | "test" | "projectMapNode";
+                            } | {
+                                /** @enum {string} */
+                                type: "external";
+                                /** Format: uri */
+                                url: string;
+                            };
+                            /** Format: date-time */
+                            createdAt: string;
+                            /** Format: date-time */
+                            readAt?: string | null;
+                        };
+                    };
+                };
+                400: components["responses"]["BadRequestError"];
+                401: components["responses"]["UnauthorizedError"];
+                403: components["responses"]["ForbiddenError"];
+                /** @description Project not found or inaccessible to the caller */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                429: components["responses"]["RateLimitError"];
+                500: components["responses"]["InternalServerError"];
+            };
+        };
+        delete?: never;
+        /** @description Handles preflight requests. This endpoint allows CORS. */
+        options: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description ok */
+                204: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        head?: never;
+        /**
+         * @deprecated
+         * @description Updates read state for the current user's notifications. Use target: ids to update specific notifications, or target: all to mark all notifications as read. Read-all may be scoped to a team.
+         */
+        patch: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": {
+                        /** @enum {string} */
+                        target: "ids";
+                        ids: string[];
+                        read: boolean;
+                    } | {
+                        /** @enum {string} */
+                        target: "all";
+                        teamId?: string;
+                    };
+                };
+            };
+            responses: {
+                /** @description No Content */
+                204: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": unknown;
+                    };
+                };
+                400: components["responses"]["BadRequestError"];
+                401: components["responses"]["UnauthorizedError"];
+                403: components["responses"]["ForbiddenError"];
+                429: components["responses"]["RateLimitError"];
+                500: components["responses"]["InternalServerError"];
+            };
+        };
+        trace?: never;
+    };
+}
+interface components {
+    schemas: {
+        Error: {
+            /** @description Error message(s) that occurred while processing the request */
+            errorMessage?: string[] | string;
+        };
+    };
+    responses: {
+        /** @description Request input validation failed */
+        BadRequestError: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["Error"];
+            };
+        };
+        /** @description API key or token was not valid */
+        UnauthorizedError: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["Error"];
+            };
+        };
+        /** @description Permission was denied */
+        ForbiddenError: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["Error"];
+            };
+        };
+        /** @description Too many requests in allowed time period */
+        RateLimitError: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content?: never;
+        };
+        /** @description Execution error occurred */
+        InternalServerError: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content?: never;
+        };
+    };
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+
+type NotificationsApi = paths['/api/v1/notifications'];
+/** Query parameters for listing the current user's notifications. */
+type NotificationsGetParameters = NonNullable<NotificationsApi['get']['parameters']['query']>;
+/** A page of notifications for the current user. */
+type NotificationsGetResponse = NotificationsApi['get']['responses']['200']['content']['application/json'];
+/** A notification returned by the Notifications API. */
+type Notification = NotificationsGetResponse['notifications'][number];
+/** An entity referenced by a notification. */
+type NotificationEntity = NonNullable<Notification['entity']>;
+/** Parameters for creating a notification. */
+type NotificationPostParameters = NotificationsApi['post']['requestBody']['content']['application/json'];
+/** The notification created by the Notifications API. */
+type NotificationPostResponse = NotificationsApi['post']['responses']['201']['content']['application/json'];
+/** Parameters for updating notification read state. */
+type NotificationPatchParameters = NotificationsApi['patch']['requestBody']['content']['application/json'];
+
+/**
+ * API client for listing, creating, and updating notifications.
+ *
+ * @deprecated This API is experimental and may change without notice.
+ */
+declare class NotificationsClient extends ApiClient {
+    #private;
+    constructor(options: ClientOptions);
+    /**
+     * Lists notifications for the current user.
+     *
+     * @deprecated This API is experimental and may change without notice.
+     */
+    list(options?: NotificationsGetParameters): Promise<NotificationsGetResponse>;
+    /**
+     * Creates a notification for one or more recipients.
+     *
+     * @deprecated This API is experimental and may change without notice.
+     */
+    create(body: NotificationPostParameters): Promise<NotificationPostResponse>;
+    /**
+     * Updates the read state of the current user's notifications.
+     *
+     * @deprecated This API is experimental and may change without notice.
+     */
+    setReadState(body: NotificationPatchParameters): Promise<void>;
+}
+
+export { AUTOMATION_INSTRUCTIONS_MAX_LENGTH, type AiToolAutomationMetadata, type AiToolInputSchema, type AiToolTriggerConfig, type AutomationContext, type AutomationDefinition, type AutomationHandler, type AutomationInvokePayload, type AutomationInvoker, AutomationLogEntry, type AutomationLogLevel, type AutomationLogger, type AutomationMetadata, type AutomationPermissions, AutomationResult, type ComposableTriggerConfig, type ComposedAutomationMetadata, type CredentialsFromAutomationMetadata, type EventTriggerConfig, type HandlerFromAutomationMetadata, type IncomingWebhookInput, type IncomingWebhookTriggerConfig, type InputFromAutomationMetadata, type JsonSchemaObject, type Notification, type NotificationEntity, type NotificationPatchParameters, type NotificationPostParameters, type NotificationPostResponse, NotificationsClient, type NotificationsGetParameters, type NotificationsGetResponse, type ScheduleRunInput, type ScheduleTriggerConfig, type ScoutAutomationDefinition, type ScoutAutomationMetadata, type TriggerConfig, type TriggerFromAutomationMetadata, type UniformConnectionParams, defineAutomation, defineScoutAutomation };

package/dist/index.mjs

@@ -1,7 +1,10 @@
 import {
   formatAutomationWebhookUrl
 } from "./chunk-TWKWPWN3.mjs";
-import "./chunk-I6KKUHEY.mjs";
+import {
+  __privateAdd,
+  __privateGet
+} from "./chunk-I6KKUHEY.mjs";
 
 // src/runtime.ts
 function captureLog(logs, level, message) {
@@ -63,9 +66,78 @@ function metadataRequiresUniformCredentials(metadata) {
 function defineAutomation(config) {
   const requireUniformCredentials = metadataRequiresUniformCredentials(config.metadata);
   const invoker = (payload) => runAutomationHandler(config.handler, payload, { requireUniformCredentials });
-  return Object.assign(invoker, { metadata: config.metadata });
+  return Object.assign(invoker, { kind: "typescript", metadata: config.metadata });
+}
+
+// src/defineScoutAutomation.ts
+function defineScoutAutomation(metadata, instructions) {
+  var _a;
+  if (!instructions.trim()) {
+    throw new Error("A Scout automation must be given instructions.");
+  }
+  if (!((_a = metadata.triggers) == null ? void 0 : _a.length)) {
+    throw new Error("A Scout automation must declare at least one trigger.");
+  }
+  if (metadata.triggers.some((trigger) => (trigger == null ? void 0 : trigger.type) === "aiTool")) {
+    throw new Error(
+      "A Scout automation cannot use an aiTool trigger: an aiTool automation is itself a tool the agent calls. Use defineAutomation for that."
+    );
+  }
+  return { kind: "scout", metadata, instructions };
 }
+
+// src/metadata.ts
+var AUTOMATION_INSTRUCTIONS_MAX_LENGTH = 16 * 1024;
+
+// src/NotificationsClient.ts
+import { ApiClient } from "@uniformdev/context/api";
+var _url;
+var _NotificationsClient = class _NotificationsClient extends ApiClient {
+  constructor(options) {
+    super(options);
+  }
+  /**
+   * Lists notifications for the current user.
+   *
+   * @deprecated This API is experimental and may change without notice.
+   */
+  async list(options) {
+    const fetchUri = this.createUrl(__privateGet(_NotificationsClient, _url), options);
+    return await this.apiClient(fetchUri);
+  }
+  /**
+   * Creates a notification for one or more recipients.
+   *
+   * @deprecated This API is experimental and may change without notice.
+   */
+  async create(body) {
+    const fetchUri = this.createUrl(__privateGet(_NotificationsClient, _url));
+    return await this.apiClient(fetchUri, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  /**
+   * Updates the read state of the current user's notifications.
+   *
+   * @deprecated This API is experimental and may change without notice.
+   */
+  async setReadState(body) {
+    const fetchUri = this.createUrl(__privateGet(_NotificationsClient, _url));
+    await this.apiClient(fetchUri, {
+      method: "PATCH",
+      body: JSON.stringify(body),
+      expectNoContent: true
+    });
+  }
+};
+_url = new WeakMap();
+__privateAdd(_NotificationsClient, _url, "/api/v1/notifications");
+var NotificationsClient = _NotificationsClient;
 export {
+  AUTOMATION_INSTRUCTIONS_MAX_LENGTH,
+  NotificationsClient,
   defineAutomation,
+  defineScoutAutomation,
   formatAutomationWebhookUrl
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniformdev/automations-sdk",
-  "version": "20.72.3-alpha.25+cd10fe6e1e",
+  "version": "20.72.3-alpha.45+2b8b05d58a",
   "description": "Uniform Automations SDK",
   "license": "SEE LICENSE IN LICENSE.txt",
   "exports": {
@@ -40,8 +40,8 @@
   ],
   "dependencies": {
     "@standard-schema/spec": "^1.1.0",
-    "@uniformdev/context": "20.72.3-alpha.25+cd10fe6e1e",
-    "@uniformdev/webhooks": "20.72.3-alpha.25+cd10fe6e1e"
+    "@uniformdev/context": "20.72.3-alpha.45+2b8b05d58a",
+    "@uniformdev/webhooks": "20.72.3-alpha.45+2b8b05d58a"
   },
   "peerDependencies": {
     "ai": "^6.0.0",
@@ -62,5 +62,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "cd10fe6e1e8877ed1ec45290d74ac160d597e84e"
+  "gitHead": "2b8b05d58ab275b4d29a9647feeaad47b0ab5cce"
 }