assistant-cloud 0.2.1 → 0.2.3

package/dist/telemetry/index.d.ts

@@ -1,32 +1,29 @@
-import { ReadableSpan, SpanExporter, SpanProcessor } from "@opentelemetry/sdk-trace-base";
-//#region src/telemetry/index.d.ts
-type AssistantCloudTraceExportOptions = {
-  apiKey: string;
-  baseUrl?: string;
-  headers?: Record<string, string>;
+import { type ReadableSpan, type SpanExporter, type SpanProcessor } from "@opentelemetry/sdk-trace-base";
+export type AssistantCloudTraceExportOptions = {
+    apiKey: string;
+    baseUrl?: string;
+    headers?: Record<string, string>;
 };
-type AssistantCloudSpanProcessorOptions = {
-  filter?: (span: ReadableSpan) => boolean;
+export type AssistantCloudSpanProcessorOptions = {
+    filter?: (span: ReadableSpan) => boolean;
 };
-declare function assistantCloudTraceExportOptions({ apiKey, baseUrl, headers }: AssistantCloudTraceExportOptions): {
-  url: string;
-  headers: Record<string, string>;
+export declare function assistantCloudTraceExportOptions({ apiKey, baseUrl, headers, }: AssistantCloudTraceExportOptions): {
+    url: string;
+    headers: Record<string, string>;
 };
-declare function createAssistantCloudTraceExporter(options: AssistantCloudTraceExportOptions): SpanExporter;
-declare function isAssistantCloudSpan(span: ReadableSpan): boolean;
-declare function createAssistantCloudSpanProcessor(exporter: SpanExporter, options?: AssistantCloudSpanProcessorOptions): SpanProcessor;
-declare function assistantCloudTraceMetadata(): {
-  traceId?: string;
+export declare function createAssistantCloudTraceExporter(options: AssistantCloudTraceExportOptions): SpanExporter;
+export declare function isAssistantCloudSpan(span: ReadableSpan): boolean;
+export declare function createAssistantCloudSpanProcessor(exporter: SpanExporter, options?: AssistantCloudSpanProcessorOptions): SpanProcessor;
+export declare function assistantCloudTraceMetadata(): {
+    traceId?: string;
 };
-declare function withAssistantCloudTraceMetadata<Part extends {
-  type: string;
+export declare function withAssistantCloudTraceMetadata<Part extends {
+    type: string;
 } = {
-  type: string;
+    type: string;
 }>(messageMetadata?: (options: {
-  part: Part;
+    part: Part;
 }) => Record<string, unknown> | undefined): (options: {
-  part: Part;
+    part: Part;
 }) => Record<string, unknown> | undefined;
-//#endregion
-export { AssistantCloudSpanProcessorOptions, AssistantCloudTraceExportOptions, assistantCloudTraceExportOptions, assistantCloudTraceMetadata, createAssistantCloudSpanProcessor, createAssistantCloudTraceExporter, isAssistantCloudSpan, withAssistantCloudTraceMetadata };
 //# sourceMappingURL=index.d.ts.map

package/dist/telemetry/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/telemetry/index.ts"],"mappings":";;KAYY;EACV;EACA;EACA,UAAU;;KAGA;EACV,UAAU,MAAM;;iBAGF,mCACd,QACA,SACA,WACC;EACD;EACA,SAAS;;iBAmBK,kCACd,SAAS,mCACR;iBAIa,qBAAqB,MAAM;iBAO3B,kCACd,UAAU,cACV,UAAS,qCACR;iBAca;EAAiC;;iBAOjC,gCACd;EAAe;;EAAmB;GAElC,mBAAmB;EACjB,MAAM;MACF,uCACJ;EAAW,MAAM;MAAW"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/telemetry/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,aAAa,EACnB,MAAM,+BAA+B,CAAC;AAKvC,MAAM,MAAM,gCAAgC,GAAG;IAC7C,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,kCAAkC,GAAG;IAC/C,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,OAAO,CAAC;CAC1C,CAAC;AAEF,wBAAgB,gCAAgC,CAAC,EAC/C,MAAM,EACN,OAAkC,EAClC,OAAO,GACR,EAAE,gCAAgC,GAAG;IACpC,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC,CAUA;AAQD,wBAAgB,iCAAiC,CAC/C,OAAO,EAAE,gCAAgC,GACxC,YAAY,CAEd;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAKhE;AAED,wBAAgB,iCAAiC,CAC/C,QAAQ,EAAE,YAAY,EACtB,OAAO,GAAE,kCAAuC,GAC/C,aAAa,CAYf;AAED,wBAAgB,2BAA2B,IAAI;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAKlE;AAED,wBAAgB,+BAA+B,CAC7C,IAAI,SAAS;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,EAEhD,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE;IAC1B,IAAI,EAAE,IAAI,CAAC;CACZ,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GACxC,CAAC,OAAO,EAAE;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAOlE"}

package/dist/version.d.ts

@@ -1,5 +1,2 @@
-//#region src/version.d.ts
-declare const ASSISTANT_CLOUD_VERSION: string;
-//#endregion
-export { ASSISTANT_CLOUD_VERSION };
+export declare const ASSISTANT_CLOUD_VERSION: string;
 //# sourceMappingURL=version.d.ts.map

package/dist/version.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"version.d.ts","names":[],"sources":["../src/version.ts"],"mappings":";cAAa"}
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,uBAAuB,EAAE,MAGzB,CAAC"}

package/dist/version.js

@@ -1,5 +1,5 @@
 //#region src/version.ts
-const ASSISTANT_CLOUD_VERSION = "0.2.1";
+const ASSISTANT_CLOUD_VERSION = "0.2.3";
 //#endregion
 export { ASSISTANT_CLOUD_VERSION };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assistant-cloud",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Cloud integration for assistant-ui",
   "keywords": [
     "assistant",
@@ -35,7 +35,7 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "assistant-stream": "^0.3.43"
+    "assistant-stream": "^0.3.45"
   },
   "peerDependencies": {
     "@opentelemetry/api": "^1.9.0",
@@ -58,15 +58,15 @@
     }
   },
   "devDependencies": {
-    "@assistant-ui/x-buildutils": "0.0.27",
-    "@opentelemetry/api": "^1.9.0",
-    "@opentelemetry/exporter-trace-otlp-http": "^0.205.0",
-    "@opentelemetry/sdk-trace-base": "^2.1.0",
-    "@types/node": "^26.4.1",
-    "ai": "^7.0.93",
+    "@assistant-ui/x-buildutils": "0.0.29",
+    "@opentelemetry/api": "^1.9.1",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.222.0",
+    "@opentelemetry/sdk-trace-base": "^2.11.0",
+    "@types/node": "^26.5.1",
+    "ai": "^7.0.101",
     "ai-v6": "npm:ai@^6.0.277",
     "jsdom": "^30.0.1",
-    "vitest": "^5.0.0"
+    "vitest": "^5.0.1"
   },
   "publishConfig": {
     "access": "public",
@@ -84,6 +84,7 @@
   "scripts": {
     "build": "aui-build",
     "test": "pnpm run test:v7 && pnpm run test:peer-v6 && pnpm run test:types:peer-v6",
+    "typecheck": "tsc --noEmit",
     "test:v7": "vitest run",
     "test:peer-v6": "vitest run --config vitest.peer-v6.config.ts",
     "test:types:peer-v6": "tsc --noEmit --project tsconfig.peer-v6.json",

package/src/AssistantCloud.ts

@@ -9,7 +9,10 @@ import { AssistantCloudProjects } from "./AssistantCloudProjects";
 import { AssistantCloudRuns } from "./AssistantCloudRuns";
 import { AssistantCloudThreads } from "./AssistantCloudThreads";
 import { AssistantCloudFiles } from "./AssistantCloudFiles";
-import { AssistantCloudEvents } from "./AssistantCloudEvents";
+import {
+  AssistantCloudEvents,
+  clearPendingAssistantCloudEvents,
+} from "./AssistantCloudEvents";
 import { AssistantCloudScores } from "./AssistantCloudScores";
 
 export class AssistantCloud {
@@ -27,7 +30,7 @@ export class AssistantCloud {
     const api = new AssistantCloudAPI(config);
     this.registerSdk = api.registerSdk;
     const t = config.telemetry;
-    this.telemetry =
+    const telemetry =
       t === false
         ? { enabled: false }
         : t === true || t === undefined
@@ -36,6 +39,18 @@ export class AssistantCloud {
               ...t,
               enabled: t.enabled !== false,
             };
+    this.telemetry = new Proxy(telemetry, {
+      set: (target, property, value) => {
+        const updated = Reflect.set(target, property, value);
+        if (
+          (property === "enabled" || property === "events") &&
+          (target.enabled === false || target.events === false)
+        ) {
+          clearPendingAssistantCloudEvents(this.events);
+        }
+        return updated;
+      },
+    });
 
     this.threads = new AssistantCloudThreads(api);
     this.projects = new AssistantCloudProjects(api);

package/src/AssistantCloudAPI.ts

@@ -25,6 +25,10 @@ export type AssistantCloudTelemetryConfig = {
    * engagement events.
    */
   events?: boolean;
+  /**
+   * Stores the messages of runtimes whose backend keeps the transcript (LangGraph, LangChain, Google ADK, custom external stores), so the dashboard can show them. Defaults to `true` when telemetry is enabled. Set to `false` to keep run reports and events without storing those messages.
+   */
+  messages?: boolean;
   release?: string;
   environment?: string;
   tags?: string[];

package/src/AssistantCloudEvents.test.ts

@@ -3,6 +3,7 @@
 import { afterEach, describe, expect, it, vi } from "vitest";
 import {
   AssistantCloudEvents,
+  clearPendingAssistantCloudEvents,
   type AssistantCloudEvent,
 } from "./AssistantCloudEvents";
 import type { AssistantCloudAPI } from "./AssistantCloudAPI";
@@ -84,6 +85,121 @@ describe("AssistantCloudEvents", () => {
     expect(makeRequest).toHaveBeenCalledOnce();
   });
 
+  it("retries a failed event batch with bounded backoff", async () => {
+    vi.useFakeTimers();
+    const { events, makeRequest } = createEvents();
+    makeRequest.mockRejectedValueOnce(new Error("temporary failure"));
+
+    for (let index = 0; index < 20; index++) events.track(event(index));
+    await vi.waitFor(() => expect(makeRequest).toHaveBeenCalledOnce());
+
+    await vi.advanceTimersByTimeAsync(249);
+    expect(makeRequest).toHaveBeenCalledOnce();
+    await vi.advanceTimersByTimeAsync(1);
+
+    expect(makeRequest).toHaveBeenCalledTimes(2);
+    expect(makeRequest.mock.calls[1]).toEqual(makeRequest.mock.calls[0]);
+  });
+
+  it("does not retry a cleared batch", async () => {
+    vi.useFakeTimers();
+    const { events, makeRequest } = createEvents();
+    makeRequest.mockRejectedValueOnce(new Error("temporary failure"));
+
+    for (let index = 0; index < 20; index++) events.track(event(index));
+    await vi.waitFor(() => expect(makeRequest).toHaveBeenCalledOnce());
+
+    clearPendingAssistantCloudEvents(events);
+    await vi.runAllTimersAsync();
+
+    expect(makeRequest).toHaveBeenCalledOnce();
+  });
+
+  it("does not let an invalidated flush consume new events", async () => {
+    vi.useFakeTimers();
+    let resolveFirstRequest!: (value: { accepted: number }) => void;
+    const { events, makeRequest } = createEvents();
+    makeRequest
+      .mockImplementationOnce(
+        () =>
+          new Promise((resolve) => {
+            resolveFirstRequest = resolve;
+          }),
+      )
+      .mockRejectedValueOnce(new Error("temporary failure"));
+
+    for (let index = 0; index < 20; index++) events.track(event(index));
+    await vi.waitFor(() => expect(makeRequest).toHaveBeenCalledOnce());
+
+    window.dispatchEvent(new Event("pagehide"));
+    clearPendingAssistantCloudEvents(events);
+    events.track(event(20));
+    resolveFirstRequest({ accepted: 20 });
+
+    await vi.waitFor(() => expect(makeRequest).toHaveBeenCalledTimes(2));
+    await vi.advanceTimersByTimeAsync(250);
+
+    expect(makeRequest).toHaveBeenCalledTimes(3);
+    expect(makeRequest.mock.calls[1]?.[1].body.events).toEqual([event(20)]);
+    expect(makeRequest.mock.calls[2]).toEqual(makeRequest.mock.calls[1]);
+  });
+
+  it("stops retrying an event batch after three attempts", async () => {
+    vi.useFakeTimers();
+    const { events, makeRequest } = createEvents();
+    makeRequest.mockRejectedValue(new Error("persistent failure"));
+
+    for (let index = 0; index < 20; index++) events.track(event(index));
+    await vi.waitFor(() => expect(makeRequest).toHaveBeenCalledOnce());
+
+    await vi.advanceTimersByTimeAsync(250);
+    expect(makeRequest).toHaveBeenCalledTimes(2);
+    await vi.advanceTimersByTimeAsync(999);
+    expect(makeRequest).toHaveBeenCalledTimes(2);
+    await vi.advanceTimersByTimeAsync(1);
+    expect(makeRequest).toHaveBeenCalledTimes(3);
+    await vi.runAllTimersAsync();
+
+    expect(makeRequest).toHaveBeenCalledTimes(3);
+  });
+
+  it("keeps dispose delivery best effort", async () => {
+    vi.useFakeTimers();
+    const { events, makeRequest } = createEvents();
+    makeRequest.mockRejectedValue(new Error("offline"));
+
+    events.track(event(1));
+    events.dispose();
+    await vi.waitFor(() => expect(makeRequest).toHaveBeenCalledOnce());
+    await vi.runAllTimersAsync();
+
+    expect(makeRequest).toHaveBeenCalledOnce();
+  });
+
+  it.each(["dispose", "pagehide"] as const)(
+    "interrupts retry backoff on %s and drains buffered events once",
+    async (trigger) => {
+      vi.useFakeTimers();
+      const { events, makeRequest } = createEvents();
+      makeRequest.mockRejectedValue(new Error("offline"));
+
+      for (let index = 0; index < 20; index++) events.track(event(index));
+      await vi.waitFor(() => expect(makeRequest).toHaveBeenCalledOnce());
+      events.track(event(20));
+
+      if (trigger === "dispose") {
+        events.dispose();
+      } else {
+        window.dispatchEvent(new Event("pagehide"));
+      }
+      await vi.waitFor(() => expect(makeRequest).toHaveBeenCalledTimes(2));
+      await vi.runAllTimersAsync();
+
+      expect(makeRequest).toHaveBeenCalledTimes(2);
+      expect(makeRequest.mock.calls[1]?.[1].body.events).toEqual([event(20)]);
+    },
+  );
+
   it("flushes when the document becomes hidden", async () => {
     const { events, makeRequest } = createEvents();
     events.track(event(1));
@@ -146,4 +262,45 @@ describe("AssistantCloudEvents", () => {
       expect(options.body.events.length).toBeLessThanOrEqual(50);
     }
   });
+
+  it.each([Number.NaN, Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY])(
+    "drops props containing the non-finite number %s",
+    async (value) => {
+      const { events, makeRequest } = createEvents();
+
+      events.track({ kind: "message_sent", props: { value } });
+      events.dispose();
+
+      await vi.waitFor(() => expect(makeRequest).toHaveBeenCalledOnce());
+      expect(makeRequest).toHaveBeenCalledWith("/events", {
+        method: "POST",
+        body: { events: [{ kind: "message_sent" }] },
+        keepalive: true,
+      });
+    },
+  );
+
+  it("keeps finite numeric props", async () => {
+    const { events, makeRequest } = createEvents();
+
+    events.track({
+      kind: "message_sent",
+      props: { negative: -1.5, zero: 0, positive: 2.5 },
+    });
+    events.dispose();
+
+    await vi.waitFor(() => expect(makeRequest).toHaveBeenCalledOnce());
+    expect(makeRequest).toHaveBeenCalledWith("/events", {
+      method: "POST",
+      body: {
+        events: [
+          {
+            kind: "message_sent",
+            props: { negative: -1.5, zero: 0, positive: 2.5 },
+          },
+        ],
+      },
+      keepalive: true,
+    });
+  });
 });

package/src/AssistantCloudEvents.ts

@@ -30,11 +30,23 @@ export type AssistantCloudEvent = {
 const FLUSH_SIZE = 20;
 const MAX_BATCH_SIZE = 50;
 const FLUSH_DELAY_MS = 2_000;
+const RETRY_DELAYS_MS = [250, 1_000] as const;
+const pendingClearers = new WeakMap<AssistantCloudEvents, () => void>();
+
+export const clearPendingAssistantCloudEvents = (
+  events: AssistantCloudEvents,
+): void => {
+  pendingClearers.get(events)?.();
+};
 
 export class AssistantCloudEvents {
   private buffer: AssistantCloudEvent[] = [];
   private timer: ReturnType<typeof setTimeout> | undefined;
   private flushing: Promise<void> | undefined;
+  private retryTimer: ReturnType<typeof setTimeout> | undefined;
+  private resolveRetryDelay: (() => void) | undefined;
+  private bestEffortRequested = false;
+  private generation = 0;
 
   private readonly cloud: AssistantCloudAPI;
   private readonly isEnabled: () => boolean;
@@ -44,6 +56,7 @@ export class AssistantCloudEvents {
   constructor(cloud: AssistantCloudAPI, isEnabled: () => boolean) {
     this.cloud = cloud;
     this.isEnabled = isEnabled;
+    pendingClearers.set(this, () => this.clearPending());
   }
 
   public track(event: AssistantCloudEvent): void {
@@ -52,7 +65,7 @@ export class AssistantCloudEvents {
     this.listen();
     this.buffer.push(normalizeEvent(event));
     if (this.buffer.length >= FLUSH_SIZE) {
-      void this.flush();
+      void this.flush(true);
       return;
     }
 
@@ -68,55 +81,70 @@ export class AssistantCloudEvents {
       return;
     }
     this.listening = true;
-    window.addEventListener("pagehide", this.flush);
+    window.addEventListener("pagehide", this.flushBestEffort);
     document.addEventListener("visibilitychange", this.onVisibilityChange);
   }
 
   private unlisten(): void {
     if (!this.listening) return;
     this.listening = false;
-    window.removeEventListener("pagehide", this.flush);
+    window.removeEventListener("pagehide", this.flushBestEffort);
     document.removeEventListener("visibilitychange", this.onVisibilityChange);
   }
 
   public dispose(): void {
     this.unlisten();
     this.clearFlushTimer();
-    void this.flush();
+    void this.flushBestEffort();
+  }
+
+  private clearPending(): void {
+    this.generation++;
+    this.buffer = [];
+    this.clearFlushTimer();
+    this.interruptRetryDelay();
+    this.unlisten();
   }
 
   private onVisibilityChange = () => {
     if (document.visibilityState === "hidden") {
-      void this.flush();
+      void this.flushBestEffort();
     }
   };
 
-  private flush = async (): Promise<void> => {
+  private flushBestEffort = () => {
+    if (this.flushing) {
+      this.bestEffortRequested = true;
+      this.interruptRetryDelay();
+    }
+    return this.flush(false);
+  };
+
+  private flush = async (retryFailures: boolean): Promise<void> => {
     if (!this.isEnabled()) {
-      this.buffer = [];
-      this.clearFlushTimer();
-      this.unlisten();
+      this.clearPending();
       return;
     }
     if (this.flushing) return this.flushing;
 
     this.clearFlushTimer();
-    const task = this.flushPending();
+    const task = this.flushPending(retryFailures);
     this.flushing = task;
     void task.then(() => {
       if (this.flushing !== task) return;
       this.flushing = undefined;
+      this.bestEffortRequested = false;
       if (this.buffer.length === 0) {
         this.clearFlushTimer();
         this.unlisten();
       } else {
-        void this.flush();
+        void this.flush(true);
       }
     });
     return task;
   };
 
-  private async flushPending(): Promise<void> {
+  private async flushPending(retryFailures: boolean): Promise<void> {
     while (this.buffer.length > 0) {
       if (!this.isEnabled()) {
         this.buffer = [];
@@ -124,21 +152,54 @@ export class AssistantCloudEvents {
       }
 
       const events = this.buffer.splice(0, MAX_BATCH_SIZE);
-      try {
-        await this.cloud.makeRequest("/events", {
-          method: "POST",
-          body: { events },
-          keepalive: true,
-        });
-      } catch {}
+      const generation = this.generation;
+      for (let attempt = 0; ; attempt++) {
+        try {
+          await this.cloud.makeRequest("/events", {
+            method: "POST",
+            body: { events },
+            keepalive: true,
+          });
+          if (generation !== this.generation) return;
+          break;
+        } catch {
+          if (generation !== this.generation) return;
+          const delay =
+            retryFailures && !this.bestEffortRequested
+              ? RETRY_DELAYS_MS[attempt]
+              : undefined;
+          if (delay === undefined) break;
+          await this.waitForRetry(delay);
+          if (generation !== this.generation) return;
+          if (!this.isEnabled()) return this.clearPending();
+          if (this.bestEffortRequested) break;
+        }
+      }
     }
   }
 
+  private waitForRetry(delay: number): Promise<void> {
+    return new Promise((resolve) => {
+      const finish = () => {
+        this.retryTimer = undefined;
+        this.resolveRetryDelay = undefined;
+        resolve();
+      };
+      this.resolveRetryDelay = finish;
+      this.retryTimer = setTimeout(finish, delay);
+    });
+  }
+
+  private interruptRetryDelay(): void {
+    if (this.retryTimer !== undefined) clearTimeout(this.retryTimer);
+    this.resolveRetryDelay?.();
+  }
+
   private scheduleFlush() {
     if (this.timer !== undefined) return;
     this.timer = setTimeout(() => {
       this.timer = undefined;
-      void this.flush();
+      void this.flush(true);
     }, FLUSH_DELAY_MS);
   }
 
@@ -176,6 +237,7 @@ const normalizeProps = (
     entries.some(
       ([, value]) =>
         (typeof value === "string" && value.length > 256) ||
+        (typeof value === "number" && !Number.isFinite(value)) ||
         (typeof value !== "string" &&
           typeof value !== "number" &&
           typeof value !== "boolean"),

package/src/AssistantCloudRuns.ts

@@ -19,7 +19,18 @@ type AssistantCloudRunsStreamBody = {
 export type AssistantCloudRunReport = {
   thread_id: string;
   status: "completed" | "incomplete" | "error";
-  outcome_type?: "aborted" | "disconnected" | "length" | "content_filter";
+  outcome_type?:
+    | "rate_limited"
+    | "validation_failed"
+    | "provider_error"
+    | "server_error"
+    | "budget_denied"
+    | "persistence_error"
+    | "aborted"
+    | "timeout"
+    | "disconnected"
+    | "length"
+    | "content_filter";
   message_id?: string;
   first_token_ms?: number;
   release?: string;
@@ -27,6 +38,7 @@ export type AssistantCloudRunReport = {
   tags?: string[];
   provider?: string;
   trace_id?: string;
+  root_span_id?: string;
   error_code?: string;
   error?: string;
   total_steps?: number;
@@ -40,15 +52,24 @@ export type AssistantCloudRunReport = {
     start_ms?: number;
     end_ms?: number;
     finish_reason?: string;
+    input?: string;
   }[];
   input_tokens?: number;
   output_tokens?: number;
   reasoning_tokens?: number;
   cached_input_tokens?: number;
+  cost_usd?: number;
+  cost_details?: {
+    input?: number;
+    input_cached_tokens?: number;
+    output?: number;
+    total?: number;
+  };
   model_id?: string;
   provider_type?: string;
   duration_ms?: number;
   output_text?: string;
+  attributes?: Record<string, unknown>;
   metadata?: Record<string, unknown>;
 };
 
@@ -62,6 +83,7 @@ export class AssistantCloudRuns {
   public __internal_getAssistantOptions(assistantId: string) {
     return {
       api: `${this.cloud._baseUrl}/v1/runs/stream`,
+      protocol: "ui-message-stream" as const,
       headers: async () => {
         const headers = await this.cloud._auth.getAuthHeaders();
         if (!headers) throw new Error("Authorization failed");
@@ -71,10 +93,18 @@ export class AssistantCloudRuns {
           "Aui-Sdk": this.cloud.sdkHeader(),
         };
       },
-      body: {
-        assistant_id: assistantId,
-        response_format: "vercel-ai-data-stream/v1",
-        thread_id: "unstable_todo",
+      body: async (options?: { threadId?: string }) => {
+        const threadId = options?.threadId;
+        if (threadId === undefined) {
+          throw new Error(
+            "Assistant Cloud runs need a thread; the thread list adapter has not assigned a remote id to this thread yet.",
+          );
+        }
+        return {
+          assistant_id: assistantId,
+          response_format: "vercel-ai-data-stream/v1",
+          thread_id: threadId,
+        };
       },
     };
   }