@uniformdev/automations-sdk 20.50.2-alpha.109

package/LICENSE.txt

@@ -0,0 +1,2 @@
+© 2026 Uniform Systems, Inc. All Rights Reserved.
+See details of Uniform Systems, Inc. Master Subscription Agreement here: https://uniform.dev/eula

package/dist/ai/index.d.mts

@@ -0,0 +1,108 @@
+import { ApiClient, ClientOptions } from '@uniformdev/context/api';
+import { UIMessage } from 'ai';
+
+/**
+ * Options for {@link ScoutClient}.
+ *
+ * Construct from an automation's `context.uniformCredentials`.
+ */
+interface ScoutClientOptions extends ClientOptions {
+    /** The Uniform project to invoke Scout in. */
+    projectId: string;
+    /**
+     * The Uniform AI API host where Scout runs.
+     *
+     * @default 'https://ai.uniform.global'
+     */
+    aiApiHost?: string;
+}
+/** Parameters for a Scout invocation. */
+interface ScoutInvokeParams {
+    /**
+     * Stable thread id this turn belongs to. The caller owns it: generate one (e.g. `crypto.randomUUID()`)
+     * for a one-shot invocation, or reuse the same id across calls to continue a multi-turn conversation
+     * (history is kept server-side per thread).
+     */
+    threadId: string;
+    /**
+     * Conversation messages in the Vercel AI SDK {@link UIMessage} shape. The server takes the
+     * trailing entry as the new user turn; prior history is kept server-side per thread, so
+     * multi-turn callers can send just the new message.
+     */
+    messages: UIMessage[];
+}
+/** Aggregated result of {@link ScoutClient.invoke}. */
+interface ScoutInvokeResult {
+    /** `completed` on success; `over-credit-limit` when the team is out of AI credits. */
+    outcome: 'completed' | 'skipped' | 'over-credit-limit';
+    /** The final assistant message text. */
+    text: string;
+    /** The full thread messages after the turn (UI message shape). */
+    messages: UIMessage[];
+}
+/**
+ * The raw HTTP request details for the headless Scout endpoint, for callers that want to drive
+ * the request themselves (e.g. hand to a streaming transport). See {@link ScoutClient.getRequest}.
+ */
+interface ScoutRequest {
+    /** The fully-qualified endpoint URL (thread id baked in). */
+    url: string;
+    /** Auth + content-type headers. Does not set `accept`; the caller chooses JSON vs SSE. */
+    headers: Record<string, string>;
+}
+/**
+ * Client for invoking Scout (Uniform's AI agent) headlessly from automation code or other
+ * non-interactive callers. Runs a turn against Scout's autonomous server-side toolset under
+ * the caller's identity, consuming AI credits.
+ *
+ * @example
+ * ```ts
+ * import { ScoutClient } from '@uniformdev/automations-sdk/ai';
+ *
+ * const scout = new ScoutClient(context.uniformCredentials);
+ * const { text } = await scout.invoke({
+ *   threadId: crypto.randomUUID(),
+ *   messages: [{ id: crypto.randomUUID(), role: 'user', parts: [{ type: 'text', text: 'Review this entry for brand tone.' }] }],
+ * });
+ * ```
+ */
+declare class ScoutClient extends ApiClient<ScoutClientOptions> {
+    #private;
+    constructor(options: ScoutClientOptions);
+    /**
+     * Invokes Scout and returns the aggregated result once the turn completes.
+     *
+     * This is the right fit for automations and other headless callers, where no user is watching
+     * output stream in. If you do need to forward incremental output to a chat surface (a Slack
+     * relay, a browser `useChat` app), don't reach for a bespoke client — the endpoint at
+     * `POST {aiApiHost}/projects/:projectId/threads/:threadId/messages` is a standard
+     * [Vercel AI SDK UI message stream](https://sdk.vercel.ai) backend when called with
+     * `Accept: text/event-stream`, so point the AI SDK's transport / `readUIMessageStream` at it.
+     *
+     * @param params - The thread id and the conversation messages for this turn.
+     */
+    invoke(params: ScoutInvokeParams): Promise<ScoutInvokeResult>;
+    /**
+     * Returns the endpoint URL + auth headers for a thread's headless Scout endpoint, so you can
+     * drive the request yourself.
+     *
+     * Use this to wire a streaming consumer without the SDK owning the transport: hand `url` and
+     * `headers` to the Vercel AI SDK's `DefaultChatTransport` and set `Accept:
+     * text/event-stream` on the request (the transport does not add it). The endpoint speaks the
+     * Vercel UI message stream protocol when called with that Accept header (otherwise it returns
+     * JSON, like {@link invoke}).
+     *
+     * @param threadId - The thread the request targets.
+     * @example
+     * ```ts
+     * const { url, headers } = scout.getRequest(threadId);
+     * const transport = new DefaultChatTransport({
+     *   api: url,
+     *   headers: { ...headers, accept: 'text/event-stream' },
+     * });
+     * ```
+     */
+    getRequest(threadId: string): ScoutRequest;
+}
+
+export { ScoutClient, type ScoutClientOptions, type ScoutInvokeParams, type ScoutInvokeResult, type ScoutRequest };

package/dist/ai/index.mjs

@@ -0,0 +1,78 @@
+import {
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet
+} from "../chunk-I6KKUHEY.mjs";
+
+// src/ai/ScoutClient.ts
+import { ApiClient } from "@uniformdev/context/api";
+var DEFAULT_AI_HOST = "https://ai.uniform.global";
+var _aiApiHost, _ScoutClient_instances, endpoint_fn;
+var ScoutClient = class extends ApiClient {
+  constructor(options) {
+    var _a;
+    super(options);
+    __privateAdd(this, _ScoutClient_instances);
+    __privateAdd(this, _aiApiHost);
+    __privateSet(this, _aiApiHost, ((_a = options.aiApiHost) != null ? _a : DEFAULT_AI_HOST).replace(/\/+$/, ""));
+  }
+  /**
+   * Invokes Scout and returns the aggregated result once the turn completes.
+   *
+   * This is the right fit for automations and other headless callers, where no user is watching
+   * output stream in. If you do need to forward incremental output to a chat surface (a Slack
+   * relay, a browser `useChat` app), don't reach for a bespoke client — the endpoint at
+   * `POST {aiApiHost}/projects/:projectId/threads/:threadId/messages` is a standard
+   * [Vercel AI SDK UI message stream](https://sdk.vercel.ai) backend when called with
+   * `Accept: text/event-stream`, so point the AI SDK's transport / `readUIMessageStream` at it.
+   *
+   * @param params - The thread id and the conversation messages for this turn.
+   */
+  async invoke(params) {
+    return this.apiClient(new URL(__privateMethod(this, _ScoutClient_instances, endpoint_fn).call(this, params.threadId)), {
+      method: "POST",
+      body: JSON.stringify({ messages: params.messages })
+    });
+  }
+  /**
+   * Returns the endpoint URL + auth headers for a thread's headless Scout endpoint, so you can
+   * drive the request yourself.
+   *
+   * Use this to wire a streaming consumer without the SDK owning the transport: hand `url` and
+   * `headers` to the Vercel AI SDK's `DefaultChatTransport` and set `Accept:
+   * text/event-stream` on the request (the transport does not add it). The endpoint speaks the
+   * Vercel UI message stream protocol when called with that Accept header (otherwise it returns
+   * JSON, like {@link invoke}).
+   *
+   * @param threadId - The thread the request targets.
+   * @example
+   * ```ts
+   * const { url, headers } = scout.getRequest(threadId);
+   * const transport = new DefaultChatTransport({
+   *   api: url,
+   *   headers: { ...headers, accept: 'text/event-stream' },
+   * });
+   * ```
+   */
+  getRequest(threadId) {
+    const headers = { "content-type": "application/json" };
+    if (this.options.apiKey) {
+      headers["x-api-key"] = this.options.apiKey;
+    } else if (this.options.bearerToken) {
+      headers["authorization"] = `Bearer ${this.options.bearerToken}`;
+    }
+    return { url: __privateMethod(this, _ScoutClient_instances, endpoint_fn).call(this, threadId), headers };
+  }
+};
+_aiApiHost = new WeakMap();
+_ScoutClient_instances = new WeakSet();
+endpoint_fn = function(threadId) {
+  return new URL(
+    `/projects/${this.options.projectId}/threads/${threadId}/messages`,
+    __privateGet(this, _aiApiHost)
+  ).toString();
+};
+export {
+  ScoutClient
+};