assistant-cloud 0.2.1 → 0.2.2

package/dist/CloudMessagePersistence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CloudMessagePersistence.d.ts","names":[],"sources":["../src/CloudMessagePersistence.ts"],"mappings":";;;;;;;;;cAWa;UACH;UACA;EAEI,YAAA,OAAO;EACP,YAAA,gBAAgB;;;;;;;;;;EActB,OACJ,kBACA,mBACA,yBACA,gBACA,SAAS,qBACR;;;;EAsCG,OACJ,kBACA,mBACA,iBACA,SAAS,qBACR;;;;EAeH,YAAY;;;;;EAQN,YAAY,oBAAoB;EAMtC,oBAAoB;;;;;;;;;;;;;;;;EAoBd,KAAK,kBAAkB,kBAAe,QAAA;;;;;;;EAmD5C"}
+{"version":3,"file":"CloudMessagePersistence.d.ts","names":[],"sources":["../src/CloudMessagePersistence.ts"],"mappings":";;;;;;;;;qBAWa;UACH;UACA;EAEI,YAAA,OAAO;EACP,YAAA,gBAAgB;;;;;;;;;;EActB,OACJ,kBACA,mBACA,yBACA,gBACA,SAAS,qBACR;;;;EAsCG,OACJ,kBACA,mBACA,iBACA,SAAS,qBACR;;;;EAeH,YAAY;;;;;EAQN,YAAY,oBAAoB;EAMtC,oBAAoB;;;;;;;;;;;;;;;;EAoBd,KAAK,kBAAkB,kBAAe,QAAA;;;;;;;EAmD5C"}

package/dist/CloudRunReporter.d.ts

@@ -1,20 +1,19 @@
 import { RunReportInit } from "./runTelemetry.js";
 import { AssistantCloud } from "./AssistantCloud.js";
 //#region src/CloudRunReporter.d.ts
-type CloudRunReportInit = Omit<RunReportInit, "telemetry">;
+export type CloudRunReportInit = Omit<RunReportInit, "telemetry">;
 /**
  * Sends run reports the way every client integration has to: nothing while
  * telemetry is off, the cloud's environment, release and tags on every report,
  * the `beforeReport` hook applied last, and a failed send that never surfaces.
- * A report given a key is sent once per key, so an integration that observes
- * the same finished run twice reports it once.
+ * A keyed report is deduplicated while in flight and after an attempt. A
+ * rate-limited attempt releases the key so a later observation can try again.
  */
-declare class CloudRunReporter {
+export declare class CloudRunReporter {
   private readonly reported;
   private readonly getCloud;
   constructor(cloud: AssistantCloud | (() => AssistantCloud));
   report(init: CloudRunReportInit, key?: string): Promise<void>;
 }
 //#endregion
-export { CloudRunReportInit, CloudRunReporter };
 //# sourceMappingURL=CloudRunReporter.d.ts.map

package/dist/CloudRunReporter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CloudRunReporter.d.ts","names":[],"sources":["../src/CloudRunReporter.ts"],"mappings":";;;KAGY,qBAAqB,KAAK;;;;;;;;cASzB;mBACM;mBACA;EAEL,YAAA,OAAO,wBAAwB;EAI9B,OAAO,MAAM,oBAAoB,eAAe"}
+{"version":3,"file":"CloudRunReporter.d.ts","names":[],"sources":["../src/CloudRunReporter.ts"],"mappings":";;;YAIY,qBAAqB,KAAK;;;;;;;;qBASzB;mBACM;mBACA;EAEL,YAAA,OAAO,wBAAwB;EAI9B,OAAO,MAAM,oBAAoB,eAAe"}

package/dist/CloudRunReporter.js

@@ -1,11 +1,12 @@
+import { CloudAPIError } from "./AssistantCloudAPI.js";
 import { createRunReport } from "./runTelemetry.js";
 //#region src/CloudRunReporter.ts
 /**
 * Sends run reports the way every client integration has to: nothing while
 * telemetry is off, the cloud's environment, release and tags on every report,
 * the `beforeReport` hook applied last, and a failed send that never surfaces.
-* A report given a key is sent once per key, so an integration that observes
-* the same finished run twice reports it once.
+* A keyed report is deduplicated while in flight and after an attempt. A
+* rate-limited attempt releases the key so a later observation can try again.
 */
 var CloudRunReporter = class {
 	reported = /* @__PURE__ */ new Set();
@@ -14,6 +15,7 @@ var CloudRunReporter = class {
 		this.getCloud = typeof cloud === "function" ? cloud : () => cloud;
 	}
 	async report(init, key) {
+		let claimedKey;
 		try {
 			const cloud = this.getCloud();
 			if (!cloud.telemetry.enabled) return;
@@ -25,13 +27,20 @@ var CloudRunReporter = class {
 			const { beforeReport } = cloud.telemetry;
 			const report = beforeReport ? beforeReport(initial) : initial;
 			if (!report) return;
-			if (key !== void 0) this.reported.add(key);
+			if (key !== void 0) {
+				this.reported.add(key);
+				claimedKey = key;
+			}
 			await cloud.runs.report(report);
-		} catch {
+		} catch (error) {
+			if (claimedKey !== void 0 && isRetryableReportError(error)) this.reported.delete(claimedKey);
 			return;
 		}
 	}
 };
+const isRetryableReportError = (error) => {
+	return error instanceof CloudAPIError && error.status === 429;
+};
 //#endregion
 export { CloudRunReporter };
 

package/dist/CloudRunReporter.js.map

@@ -1 +1 @@
-{"version":3,"file":"CloudRunReporter.js","names":[],"sources":["../src/CloudRunReporter.ts"],"sourcesContent":["import type { AssistantCloud } from \"./AssistantCloud\";\nimport { createRunReport, type RunReportInit } from \"./runTelemetry\";\n\nexport type CloudRunReportInit = Omit<RunReportInit, \"telemetry\">;\n\n/**\n * Sends run reports the way every client integration has to: nothing while\n * telemetry is off, the cloud's environment, release and tags on every report,\n * the `beforeReport` hook applied last, and a failed send that never surfaces.\n * A report given a key is sent once per key, so an integration that observes\n * the same finished run twice reports it once.\n */\nexport class CloudRunReporter {\n  private readonly reported = new Set<string>();\n  private readonly getCloud: () => AssistantCloud;\n\n  constructor(cloud: AssistantCloud | (() => AssistantCloud)) {\n    this.getCloud = typeof cloud === \"function\" ? cloud : () => cloud;\n  }\n\n  public async report(init: CloudRunReportInit, key?: string): Promise<void> {\n    try {\n      const cloud = this.getCloud();\n      if (!cloud.telemetry.enabled) return;\n      if (key !== undefined && this.reported.has(key)) return;\n\n      const initial = createRunReport({ ...init, telemetry: cloud.telemetry });\n      const { beforeReport } = cloud.telemetry;\n      const report = beforeReport ? beforeReport(initial) : initial;\n      if (!report) return;\n\n      if (key !== undefined) this.reported.add(key);\n      await cloud.runs.report(report);\n    } catch {\n      return;\n    }\n  }\n}\n"],"mappings":";;;;;;;;;AAYA,IAAa,mBAAb,MAA8B;CAC5B,2BAA4B,IAAI,IAAY;CAC5C;CAEA,YAAY,OAAgD;EAC1D,KAAK,WAAW,OAAO,UAAU,aAAa,cAAc;CAC9D;CAEA,MAAa,OAAO,MAA0B,KAA6B;EACzE,IAAI;GACF,MAAM,QAAQ,KAAK,SAAS;GAC5B,IAAI,CAAC,MAAM,UAAU,SAAS;GAC9B,IAAI,QAAQ,KAAA,KAAa,KAAK,SAAS,IAAI,GAAG,GAAG;GAEjD,MAAM,UAAU,gBAAgB;IAAE,GAAG;IAAM,WAAW,MAAM;GAAU,CAAC;GACvE,MAAM,EAAE,iBAAiB,MAAM;GAC/B,MAAM,SAAS,eAAe,aAAa,OAAO,IAAI;GACtD,IAAI,CAAC,QAAQ;GAEb,IAAI,QAAQ,KAAA,GAAW,KAAK,SAAS,IAAI,GAAG;GAC5C,MAAM,MAAM,KAAK,OAAO,MAAM;EAChC,QAAQ;GACN;EACF;CACF;AACF"}
+{"version":3,"file":"CloudRunReporter.js","names":[],"sources":["../src/CloudRunReporter.ts"],"sourcesContent":["import type { AssistantCloud } from \"./AssistantCloud\";\nimport { CloudAPIError } from \"./AssistantCloudAPI\";\nimport { createRunReport, type RunReportInit } from \"./runTelemetry\";\n\nexport type CloudRunReportInit = Omit<RunReportInit, \"telemetry\">;\n\n/**\n * Sends run reports the way every client integration has to: nothing while\n * telemetry is off, the cloud's environment, release and tags on every report,\n * the `beforeReport` hook applied last, and a failed send that never surfaces.\n * A keyed report is deduplicated while in flight and after an attempt. A\n * rate-limited attempt releases the key so a later observation can try again.\n */\nexport class CloudRunReporter {\n  private readonly reported = new Set<string>();\n  private readonly getCloud: () => AssistantCloud;\n\n  constructor(cloud: AssistantCloud | (() => AssistantCloud)) {\n    this.getCloud = typeof cloud === \"function\" ? cloud : () => cloud;\n  }\n\n  public async report(init: CloudRunReportInit, key?: string): Promise<void> {\n    let claimedKey: string | undefined;\n    try {\n      const cloud = this.getCloud();\n      if (!cloud.telemetry.enabled) return;\n      if (key !== undefined && this.reported.has(key)) return;\n\n      const initial = createRunReport({ ...init, telemetry: cloud.telemetry });\n      const { beforeReport } = cloud.telemetry;\n      const report = beforeReport ? beforeReport(initial) : initial;\n      if (!report) return;\n\n      if (key !== undefined) {\n        this.reported.add(key);\n        claimedKey = key;\n      }\n      await cloud.runs.report(report);\n    } catch (error) {\n      if (claimedKey !== undefined && isRetryableReportError(error)) {\n        this.reported.delete(claimedKey);\n      }\n      return;\n    }\n  }\n}\n\nconst isRetryableReportError = (error: unknown): boolean => {\n  return error instanceof CloudAPIError && error.status === 429;\n};\n"],"mappings":";;;;;;;;;;AAaA,IAAa,mBAAb,MAA8B;CAC5B,2BAA4B,IAAI,IAAY;CAC5C;CAEA,YAAY,OAAgD;EAC1D,KAAK,WAAW,OAAO,UAAU,aAAa,cAAc;CAC9D;CAEA,MAAa,OAAO,MAA0B,KAA6B;EACzE,IAAI;EACJ,IAAI;GACF,MAAM,QAAQ,KAAK,SAAS;GAC5B,IAAI,CAAC,MAAM,UAAU,SAAS;GAC9B,IAAI,QAAQ,KAAA,KAAa,KAAK,SAAS,IAAI,GAAG,GAAG;GAEjD,MAAM,UAAU,gBAAgB;IAAE,GAAG;IAAM,WAAW,MAAM;GAAU,CAAC;GACvE,MAAM,EAAE,iBAAiB,MAAM;GAC/B,MAAM,SAAS,eAAe,aAAa,OAAO,IAAI;GACtD,IAAI,CAAC,QAAQ;GAEb,IAAI,QAAQ,KAAA,GAAW;IACrB,KAAK,SAAS,IAAI,GAAG;IACrB,aAAa;GACf;GACA,MAAM,MAAM,KAAK,OAAO,MAAM;EAChC,SAAS,OAAO;GACd,IAAI,eAAe,KAAA,KAAa,uBAAuB,KAAK,GAC1D,KAAK,SAAS,OAAO,UAAU;GAEjC;EACF;CACF;AACF;AAEA,MAAM,0BAA0B,UAA4B;CAC1D,OAAO,iBAAiB,iBAAiB,MAAM,WAAW;AAC5D"}

package/dist/FormattedCloudPersistence.d.ts

@@ -5,7 +5,7 @@ import { ReadonlyJSONObject } from "assistant-stream/utils";
  * in @assistant-ui/react, but defined here to avoid cross-package type moves.
  * TypeScript's structural typing ensures these are interchangeable.
  */
-type MessageFormatAdapter<TMessage, TStorageFormat> = {
+export type MessageFormatAdapter<TMessage, TStorageFormat> = {
   format: string;
   encode(item: {
     parentId: string | null;
@@ -27,7 +27,7 @@ type MessageFormatAdapter<TMessage, TStorageFormat> = {
  * decode. The persistence parameter is typed structurally, so a caller does
  * not need to import the class.
  */
-declare const createFormattedPersistence: <TMessage, TStorageFormat>(persistence: {
+export declare const createFormattedPersistence: <TMessage, TStorageFormat>(persistence: {
   append: (threadId: string, messageId: string, parentId: string | null, format: string, content: ReadonlyJSONObject) => Promise<void>;
   load: (threadId: string, format?: string) => Promise<any[]>;
   isPersisted: (messageId: string) => boolean;
@@ -50,5 +50,4 @@ declare const createFormattedPersistence: <TMessage, TStorageFormat>(persistence
   isPersisted: (messageId: string) => boolean;
 };
 //#endregion
-export { MessageFormatAdapter, createFormattedPersistence };
 //# sourceMappingURL=FormattedCloudPersistence.d.ts.map

package/dist/FormattedCloudPersistence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FormattedCloudPersistence.d.ts","names":[],"sources":["../src/FormattedCloudPersistence.ts"],"mappings":";;;;;;;KAOY,qBAAqB,UAAU;EACzC;EACA,OAAO;IAAQ;IAAyB,SAAS;MAAa;EAC9D,OAAO;IACL;IACA;IACA;IACA,SAAS;;IACL;IAAyB,SAAS;;EACxC,MAAM,SAAS;;;;;;;cAQJ,6BAA8B,UAAU,gBACnD;EACE,SACE,kBACA,mBACA,yBACA,gBACA,SAAS,uBACN;EACL,OAAO,kBAAkB,oBAAoB;EAC7C,cAAc;EACd,UACE,kBACA,mBACA,gBACA,SAAS,uBACN;GAEP,SAAS,qBAAqB,UAAU;EAG5B,SAAA,kBAAM;IACR;IAAyB,SAAS;QACzC;EAaa,UAAA,kBAAM;IACR;IAAyB,SAAS;KAAU,sBAEnD;EAUgB,OAAA,qBAAM;;MA1Db;;;;EA0ES,cAAA"}
+{"version":3,"file":"FormattedCloudPersistence.d.ts","names":[],"sources":["../src/FormattedCloudPersistence.ts"],"mappings":";;;;;;;YAOY,qBAAqB,UAAU;EACzC;EACA,OAAO;IAAQ;IAAyB,SAAS;MAAa;EAC9D,OAAO;IACL;IACA;IACA;IACA,SAAS;;IACL;IAAyB,SAAS;;EACxC,MAAM,SAAS;;;;;;;qBAQJ,6BAA8B,UAAU,gBACnD;EACE,SACE,kBACA,mBACA,yBACA,gBACA,SAAS,uBACN;EACL,OAAO,kBAAkB,oBAAoB;EAC7C,cAAc;EACd,UACE,kBACA,mBACA,gBACA,SAAS,uBACN;GAEP,SAAS,qBAAqB,UAAU;EAG5B,SAAA,kBAAM;IACR;IAAyB,SAAS;QACzC;EAaa,UAAA,kBAAM;IACR;IAAyB,SAAS;KAAU,sBAEnD;EAUgB,OAAA,qBAAM;;MA1Db;;;;EA0ES,cAAA"}

package/dist/ai-sdk/index.d.ts

@@ -2,15 +2,15 @@ import { RunMessageTelemetry } from "../runTelemetry.js";
 import { MessageFormatAdapter } from "../FormattedCloudPersistence.js";
 import { UIMessage } from "ai";
 //#region src/ai-sdk/index.d.ts
-type AISDKStorageFormat = Omit<UIMessage, "id">;
+export type AISDKStorageFormat = Omit<UIMessage, "id">;
 /** The stored form of an AI SDK message: the message without its id. */
-declare const aiSDKV6FormatAdapter: MessageFormatAdapter<UIMessage, AISDKStorageFormat>;
+export declare const aiSDKV6FormatAdapter: MessageFormatAdapter<UIMessage, AISDKStorageFormat>;
 /**
  * A message as an AI SDK integration holds it, or as the cloud stored it under
  * the ai-sdk/v6 format, which drops the id. Parts are typed by their `type`
  * alone, so this shape and the telemetry read from it need nothing from `ai`.
  */
-type AISDKMessageLike = {
+export type AISDKMessageLike = {
   id?: string | undefined;
   role: string;
   parts: readonly {
@@ -27,7 +27,6 @@ type AISDKMessageLike = {
  * produced text or tool calls, as a live finish with reason `tool-calls` does;
  * an integration that observed the finish event overrides it.
  */
-declare function extractAISDKRunTelemetry(messages: readonly AISDKMessageLike[]): RunMessageTelemetry | null;
+export declare function extractAISDKRunTelemetry(messages: readonly AISDKMessageLike[]): RunMessageTelemetry | null;
 //#endregion
-export { AISDKMessageLike, AISDKStorageFormat, aiSDKV6FormatAdapter, extractAISDKRunTelemetry };
 //# sourceMappingURL=index.d.ts.map

package/dist/ai-sdk/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/ai-sdk/index.ts"],"mappings":";;;;KAeY,qBAAqB,KAAK;;cAGzB,sBAAsB,qBACjC,WACA;;;;;;KAgBU;EACV;EACA;EACA;IAAkB;KAAe;;EACjC;;;;;;;;;;iBAgHc,yBACd,mBAAmB,qBAClB"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/ai-sdk/index.ts"],"mappings":";;;;YAeY,qBAAqB,KAAK;;qBAGzB,sBAAsB,qBACjC,WACA;;;;;;YAgBU;EACV;EACA;EACA;IAAkB;KAAe;;EACjC;;;;;;;;;;wBAgHc,yBACd,mBAAmB,qBAClB"}

package/dist/cloudResponse.d.ts

@@ -1,19 +1,18 @@
 import { ReadonlyJSONObject } from "assistant-stream/utils";
 //#region src/cloudResponse.d.ts
-declare class CloudResponseError extends Error {
+export declare class CloudResponseError extends Error {
   constructor(message: string);
 }
-declare const readCloudRecord: (value: unknown, field: string) => Record<string, unknown>;
-declare const readCloudArray: (value: unknown, field: string) => unknown[];
-declare const readCloudString: (value: unknown, field: string) => string;
-declare const readCloudNumber: (value: unknown, field: string) => number;
-declare const readCloudNullableNumber: (value: unknown, field: string) => number | null;
-declare const readCloudEnum: <const T extends readonly string[]>(value: unknown, field: string, allowed: T) => T[number];
-declare const readCloudNullableString: (value: unknown, field: string) => string | null;
-declare const readCloudBoolean: (value: unknown, field: string) => boolean;
-declare const readCloudInteger: (value: unknown, field: string) => number;
-declare const readCloudTimestamp: (value: unknown, field: string) => Date;
-declare const readCloudJSONObject: (value: unknown, field: string) => ReadonlyJSONObject;
+export declare const readCloudRecord: (value: unknown, field: string) => Record<string, unknown>;
+export declare const readCloudArray: (value: unknown, field: string) => unknown[];
+export declare const readCloudString: (value: unknown, field: string) => string;
+export declare const readCloudNumber: (value: unknown, field: string) => number;
+export declare const readCloudNullableNumber: (value: unknown, field: string) => number | null;
+export declare const readCloudEnum: <const T extends readonly string[]>(value: unknown, field: string, allowed: T) => T[number];
+export declare const readCloudNullableString: (value: unknown, field: string) => string | null;
+export declare const readCloudBoolean: (value: unknown, field: string) => boolean;
+export declare const readCloudInteger: (value: unknown, field: string) => number;
+export declare const readCloudTimestamp: (value: unknown, field: string) => Date;
+export declare const readCloudJSONObject: (value: unknown, field: string) => ReadonlyJSONObject;
 //#endregion
-export { CloudResponseError, readCloudArray, readCloudBoolean, readCloudEnum, readCloudInteger, readCloudJSONObject, readCloudNullableNumber, readCloudNullableString, readCloudNumber, readCloudRecord, readCloudString, readCloudTimestamp };
 //# sourceMappingURL=cloudResponse.d.ts.map

package/dist/cloudResponse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloudResponse.d.ts","names":[],"sources":["../src/cloudResponse.ts"],"mappings":";;cAEa,2BAA2B;EAC1B,YAAA;;cAWD,kBACX,gBACA,kBACC;cAOU,iBAAkB,gBAAgB;cAKlC,kBAAmB,gBAAgB;cAKnC,kBAAmB,gBAAgB;cAOnC,0BACX,gBACA;cAMW,sBAAuB,6BAClC,gBACA,eACA,SAAS,MACR;cAWU,0BACX,gBACA;cAMW,mBAAoB,gBAAgB;cAOpC,mBAAoB,gBAAgB;cAKpC,qBAAsB,gBAAgB,kBAAgB;cActD,sBACX,gBACA,kBACC"}
+{"version":3,"file":"cloudResponse.d.ts","names":[],"sources":["../src/cloudResponse.ts"],"mappings":";;qBAEa,2BAA2B;EAC1B,YAAA;;qBAWD,kBACX,gBACA,kBACC;qBAOU,iBAAkB,gBAAgB;qBAKlC,kBAAmB,gBAAgB;qBAKnC,kBAAmB,gBAAgB;qBAOnC,0BACX,gBACA;qBAMW,sBAAuB,6BAClC,gBACA,eACA,SAAS,MACR;qBAWU,0BACX,gBACA;qBAMW,mBAAoB,gBAAgB;qBAOpC,mBAAoB,gBAAgB;qBAKpC,qBAAsB,gBAAgB,kBAAgB;qBActD,sBACX,gBACA,kBACC"}

package/dist/generateThreadTitle.d.ts

@@ -1,6 +1,6 @@
 import { AssistantCloud } from "./AssistantCloud.js";
 //#region src/generateThreadTitle.d.ts
-declare function generateThreadTitle(cloud: AssistantCloud, options: {
+export declare function generateThreadTitle(cloud: AssistantCloud, options: {
   threadId: string;
   messages: readonly {
     role: string;
@@ -11,5 +11,4 @@ declare function generateThreadTitle(cloud: AssistantCloud, options: {
   }[];
 }): Promise<string | null>;
 //#endregion
-export { generateThreadTitle };
 //# sourceMappingURL=generateThreadTitle.d.ts.map

package/dist/generateThreadTitle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generateThreadTitle.d.ts","names":[],"sources":["../src/generateThreadTitle.ts"],"mappings":";;iBAEsB,oBACpB,OAAO,gBACP;EACE;EACA;IACE;IACA;MAAoB;MAAc;;;IAGrC"}
+{"version":3,"file":"generateThreadTitle.d.ts","names":[],"sources":["../src/generateThreadTitle.ts"],"mappings":";;wBAEsB,oBACpB,OAAO,gBACP;EACE;EACA;IACE;IACA;MAAoB;MAAc;;;IAGrC"}

package/dist/instrumentMcpSampling.d.ts

@@ -6,7 +6,7 @@
  * (sampling/createMessage requests) made during tool execution.
  * The captured data can be reported as child generation spans.
  */
-type SamplingCallData = {
+export type SamplingCallData = {
   model_id?: string;
   input_tokens?: number;
   output_tokens?: number;
@@ -14,8 +14,8 @@ type SamplingCallData = {
   cached_input_tokens?: number;
   duration_ms?: number;
 };
-type McpSamplingHandler = (request: McpSamplingRequest) => Promise<McpSamplingResponse>;
-type McpSamplingRequest = {
+export type McpSamplingHandler = (request: McpSamplingRequest) => Promise<McpSamplingResponse>;
+export type McpSamplingRequest = {
   method: "sampling/createMessage";
   params: {
     messages: unknown[];
@@ -28,7 +28,7 @@ type McpSamplingRequest = {
     [key: string]: unknown;
   };
 };
-type McpSamplingResponse = {
+export type McpSamplingResponse = {
   model?: string;
   content: unknown;
   usage?: {
@@ -59,7 +59,7 @@ type McpSamplingResponse = {
  * // After tool execution, `samplingCalls` contains metrics for all nested LLM calls
  * ```
  */
-declare function wrapSamplingHandler(handler: McpSamplingHandler, onSamplingCall: (data: SamplingCallData) => void): McpSamplingHandler;
+export declare function wrapSamplingHandler(handler: McpSamplingHandler, onSamplingCall: (data: SamplingCallData) => void): McpSamplingHandler;
 /**
  * Creates a collector that accumulates sampling call data during tool execution.
  * Use with `wrapSamplingHandler` to capture all sampling calls for a tool invocation.
@@ -72,11 +72,10 @@ declare function wrapSamplingHandler(handler: McpSamplingHandler, onSamplingCall
  * const calls = collector.getCalls(); // SamplingCallData[]
  * ```
  */
-declare function createSamplingCollector(): {
+export declare function createSamplingCollector(): {
   collect: (data: SamplingCallData) => number;
   getCalls: () => SamplingCallData[];
   reset: () => void;
 };
 //#endregion
-export { McpSamplingHandler, McpSamplingRequest, McpSamplingResponse, SamplingCallData, createSamplingCollector, wrapSamplingHandler };
 //# sourceMappingURL=instrumentMcpSampling.d.ts.map

package/dist/instrumentMcpSampling.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"instrumentMcpSampling.d.ts","names":[],"sources":["../src/instrumentMcpSampling.ts"],"mappings":";;;;;;;;KAQY;EACV;EACA;EACA;EACA;EACA;EACA;;KAGU,sBACV,SAAS,uBACN,QAAQ;KAED;EACV;EACA;IACE;IACA;MAAqB;QAAU;;;IAC/B;KACC;;;KAIO;EACV;EACA;EACA;IACE;IACA;IACA;IACA;IACA;IACA;;GAED;;;;;;;;;;;;;;;;;;;;iBA8Ba,oBACd,SAAS,oBACT,iBAAiB,MAAM,4BACtB;;;;;;;;;;;;;iBAkDa;EAGI,UAAA,MAAA;kBAAA"}
+{"version":3,"file":"instrumentMcpSampling.d.ts","names":[],"sources":["../src/instrumentMcpSampling.ts"],"mappings":";;;;;;;;YAQY;EACV;EACA;EACA;EACA;EACA;EACA;;YAGU,sBACV,SAAS,uBACN,QAAQ;YAED;EACV;EACA;IACE;IACA;MAAqB;QAAU;;;IAC/B;KACC;;;YAIO;EACV;EACA;EACA;IACE;IACA;IACA;IACA;IACA;IACA;;GAED;;;;;;;;;;;;;;;;;;;;wBA8Ba,oBACd,SAAS,oBACT,iBAAiB,MAAM,4BACtB;;;;;;;;;;;;;wBAkDa;EAGI,UAAA,MAAA;kBAAA"}

package/dist/runTelemetry.d.ts

@@ -1,7 +1,7 @@
 import { SamplingCallData } from "./instrumentMcpSampling.js";
 import { AssistantCloudRunReport } from "./AssistantCloudRuns.js";
 //#region src/runTelemetry.d.ts
-type AssistantCloudRunReportToolCall = {
+export type AssistantCloudRunReportToolCall = {
   tool_name: string;
   tool_call_id: string;
   tool_args?: string;
@@ -11,12 +11,12 @@ type AssistantCloudRunReportToolCall = {
   end_ms?: number;
   sampling_calls?: SamplingCallData[];
 };
-type RunReportOutcome = "aborted" | "disconnected" | "length" | "content_filter";
+export type RunReportOutcome = "aborted" | "disconnected" | "length" | "content_filter";
 /**
  * Maps a finish event to the report status and outcome. `fallbackStatus`
  * applies when the event carries neither a finish reason nor a failure flag.
  */
-declare function deriveRunOutcome(input: {
+export declare function deriveRunOutcome(input: {
   finishReason?: string | undefined;
   isAbort?: boolean | undefined;
   isDisconnect?: boolean | undefined;
@@ -29,7 +29,7 @@ declare function deriveRunOutcome(input: {
  * Reads the message and code the runs endpoint stores for a failed run. The
  * code is the error's `code` when it has one, else its class name.
  */
-declare function describeRunError(error: unknown): {
+export declare function describeRunError(error: unknown): {
   error?: string;
   errorCode?: string;
 };
@@ -37,8 +37,8 @@ declare function describeRunError(error: unknown): {
  * Clamps a string to the size the runs endpoint accepts for a single span
  * field.
  */
-declare function truncateRunTelemetryText(value: string): string;
-type RunTelemetryToolCallInit = {
+export declare function truncateRunTelemetryText(value: string): string;
+export type RunTelemetryToolCallInit = {
   toolName: string;
   toolCallId: string;
   args?: unknown;
@@ -55,7 +55,7 @@ type RunTelemetryToolCallInit = {
  * source has its result summarized, because MCP content blocks carry inline
  * base64 image and audio payloads that would otherwise dominate the report.
  */
-declare function createRunTelemetryToolCall(init: RunTelemetryToolCallInit): AssistantCloudRunReportToolCall;
+export declare function createRunTelemetryToolCall(init: RunTelemetryToolCallInit): AssistantCloudRunReportToolCall;
 /**
  * Resolves the model ID a run reports, in the order an app can supply it: an
  * explicit `modelId`, the `custom` bag, then the per-step `response.modelId`
@@ -63,14 +63,14 @@ declare function createRunTelemetryToolCall(init: RunTelemetryToolCallInit): Ass
  * The AI SDK puts no model ID on a UI message part, so message metadata is the
  * only channel one arrives on.
  */
-declare function extractRunTelemetryModelId(metadata: Record<string, unknown> | undefined): string | undefined;
-type RunTelemetryUsage = {
+export declare function extractRunTelemetryModelId(metadata: Record<string, unknown> | undefined): string | undefined;
+export type RunTelemetryUsage = {
   inputTokens?: number | undefined;
   outputTokens?: number | undefined;
   reasoningTokens?: number | undefined;
   cachedInputTokens?: number | undefined;
 };
-type RunTelemetryUsageInit = RunTelemetryUsage & {
+export type RunTelemetryUsageInit = RunTelemetryUsage & {
   promptTokens?: number | undefined;
   completionTokens?: number | undefined;
   inputTokenDetails?: {
@@ -80,7 +80,7 @@ type RunTelemetryUsageInit = RunTelemetryUsage & {
     reasoningTokens?: number;
   };
 };
-type RunReportStepInit = {
+export type RunReportStepInit = {
   usage?: RunTelemetryUsageInit | undefined;
   toolCalls?: AssistantCloudRunReportToolCall[] | undefined;
   startMs?: number | undefined;
@@ -92,7 +92,7 @@ type RunReportStepInit = {
  * format they were stored: the status the messages imply, the tool calls, the
  * steps, the text, the usage and the model.
  */
-type RunMessageTelemetry = {
+export type RunMessageTelemetry = {
   assistantMessageId?: string;
   status: "completed" | "incomplete";
   toolCalls?: AssistantCloudRunReportToolCall[];
@@ -103,7 +103,7 @@ type RunMessageTelemetry = {
   modelId?: string;
   metadata?: Record<string, unknown>;
 };
-type RunReportInit = {
+export type RunReportInit = {
   threadId: string;
   status: AssistantCloudRunReport["status"];
   outcome?: RunReportOutcome | undefined;
@@ -127,14 +127,13 @@ type RunReportInit = {
     tags?: readonly string[] | undefined;
   };
 };
-declare function createRunReport(init: RunReportInit): AssistantCloudRunReport;
+export declare function createRunReport(init: RunReportInit): AssistantCloudRunReport;
 /**
  * Resolves the token counts a provider reports under any of the names the AI
  * SDK has used: the current top-level ones, the legacy prompt/completion pair,
  * and the v7 token detail objects. Returns undefined when no count is present,
  * so callers can tell an empty usage object from a zeroed one.
  */
-declare function normalizeRunTelemetryUsage(usage: RunTelemetryUsageInit): RunTelemetryUsage | undefined;
+export declare function normalizeRunTelemetryUsage(usage: RunTelemetryUsageInit): RunTelemetryUsage | undefined;
 //#endregion
-export { AssistantCloudRunReportToolCall, RunMessageTelemetry, RunReportInit, RunReportOutcome, RunReportStepInit, RunTelemetryToolCallInit, RunTelemetryUsage, RunTelemetryUsageInit, createRunReport, createRunTelemetryToolCall, deriveRunOutcome, describeRunError, extractRunTelemetryModelId, normalizeRunTelemetryUsage, truncateRunTelemetryText };
 //# sourceMappingURL=runTelemetry.d.ts.map

package/dist/runTelemetry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runTelemetry.d.ts","names":[],"sources":["../src/runTelemetry.ts"],"mappings":";;;KAOY;EACV;EACA;EACA;EACA;EACA;EACA;EACA;EACA,iBAAiB;;KAGP;;;;;iBAUI,iBACd;EACE;EACA;EACA;EACA;GAEF;EAEA;EACA,UAAU;;;;;;iBA+BI,iBAAiB;EAC/B;EACA;;;;;;iBA+Bc,yBAAyB;KAwC7B;EACV;EACA;EACA;;;;;EAKA;EACA;EACA;;;;;;;iBAQc,2BACd,MAAM,2BACL;;;;;;;;iBAuBa,2BACd,UAAU;KAmBA;EACV;EACA;EACA;EACA;;KAGU,wBAAwB;EAClC;EACA;EACA;IAAsB;;EACtB;IAAuB;;;KAGb;EACV,QAAQ;EACR,YAAY;EACZ;EACA;EACA;;;;;;;KAQU;EACV;EACA;EACA,YAAY;EACZ,QAAQ;EACR;EACA;EACA,QAAQ;EACR;EACA,WAAW;;KAGD;EACV;EACA,QAAQ;EACR,UAAU;EACV;EACA;EACA;EACA;EACA;EACA;EACA,QAAQ;EACR,QAAQ;EACR;EACA,YAAY;EACZ;EACA;EACA;EACA,WAAW;EACX;IACE;IACA;IACA;;;iBAuEY,gBAAgB,MAAM,gBAAgB;;;;;;;iBAiDtC,2BACd,OAAO,wBACN"}
+{"version":3,"file":"runTelemetry.d.ts","names":[],"sources":["../src/runTelemetry.ts"],"mappings":";;;YAOY;EACV;EACA;EACA;EACA;EACA;EACA;EACA;EACA,iBAAiB;;YAGP;;;;;wBAUI,iBACd;EACE;EACA;EACA;EACA;GAEF;EAEA;EACA,UAAU;;;;;;wBA+BI,iBAAiB;EAC/B;EACA;;;;;;wBA+Bc,yBAAyB;YAwC7B;EACV;EACA;EACA;;;;;EAKA;EACA;EACA;;;;;;;wBAQc,2BACd,MAAM,2BACL;;;;;;;;wBAuBa,2BACd,UAAU;YAmBA;EACV;EACA;EACA;EACA;;YAGU,wBAAwB;EAClC;EACA;EACA;IAAsB;;EACtB;IAAuB;;;YAGb;EACV,QAAQ;EACR,YAAY;EACZ;EACA;EACA;;;;;;;YAQU;EACV;EACA;EACA,YAAY;EACZ,QAAQ;EACR;EACA;EACA,QAAQ;EACR;EACA,WAAW;;YAGD;EACV;EACA,QAAQ;EACR,UAAU;EACV;EACA;EACA;EACA;EACA;EACA;EACA,QAAQ;EACR,QAAQ;EACR;EACA,YAAY;EACZ;EACA;EACA;EACA,WAAW;EACX;IACE;IACA;IACA;;;wBAuEY,gBAAgB,MAAM,gBAAgB;;;;;;;wBAiDtC,2BACd,OAAO,wBACN"}

package/dist/telemetry/index.d.ts

@@ -1,24 +1,24 @@
 import { ReadableSpan, SpanExporter, SpanProcessor } from "@opentelemetry/sdk-trace-base";
 //#region src/telemetry/index.d.ts
-type AssistantCloudTraceExportOptions = {
+export type AssistantCloudTraceExportOptions = {
   apiKey: string;
   baseUrl?: string;
   headers?: Record<string, string>;
 };
-type AssistantCloudSpanProcessorOptions = {
+export type AssistantCloudSpanProcessorOptions = {
   filter?: (span: ReadableSpan) => boolean;
 };
-declare function assistantCloudTraceExportOptions({ apiKey, baseUrl, headers }: AssistantCloudTraceExportOptions): {
+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(): {
+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 {
+export declare function withAssistantCloudTraceMetadata<Part extends {
   type: string;
 } = {
   type: string;
@@ -28,5 +28,4 @@ declare function withAssistantCloudTraceMetadata<Part extends {
   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","names":[],"sources":["../../src/telemetry/index.ts"],"mappings":";;YAYY;EACV;EACA;EACA,UAAU;;YAGA;EACV,UAAU,MAAM;;wBAGF,mCACd,QACA,SACA,WACC;EACD;EACA,SAAS;;wBAmBK,kCACd,SAAS,mCACR;wBAIa,qBAAqB,MAAM;wBAO3B,kCACd,UAAU,cACV,UAAS,qCACR;wBAca;EAAiC;;wBAOjC,gCACd;EAAe;;EAAmB;GAElC,mBAAmB;EACjB,MAAM;MACF,uCACJ;EAAW,MAAM;MAAW"}

package/dist/version.d.ts

@@ -1,5 +1,4 @@
 //#region src/version.d.ts
-declare const ASSISTANT_CLOUD_VERSION: string;
+export declare const ASSISTANT_CLOUD_VERSION: string;
 //#endregion
-export { ASSISTANT_CLOUD_VERSION };
 //# 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","names":[],"sources":["../src/version.ts"],"mappings":";qBAAa"}

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.2";
 //#endregion
 export { ASSISTANT_CLOUD_VERSION };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assistant-cloud",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Cloud integration for assistant-ui",
   "keywords": [
     "assistant",
@@ -35,7 +35,7 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "assistant-stream": "^0.3.43"
+    "assistant-stream": "^0.3.44"
   },
   "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.28",
+    "@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/AssistantCloudEvents.test.ts

@@ -146,4 +146,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

@@ -176,6 +176,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/AssistantCloudThreadMessages.test.ts

@@ -43,14 +43,65 @@ describe("AssistantCloudThreadMessages responses", () => {
 
     await expect(
       messages.feedback("thread/1", "message/1", body),
-    ).resolves.toEqual({
+    ).resolves.toStrictEqual({
       feedback_id: "feedback-1",
       type: "positive",
     });
     expect(makeRequest).toHaveBeenCalledWith(
       "/threads/thread%2F1/messages/message%2F1/feedback",
-      { method: "POST", body },
+      { method: "POST", body: { type: "positive" } },
     );
+    expect(makeRequest.mock.calls[0]![1].body).toStrictEqual({
+      type: "positive",
+    });
+
+    const bodyWithComment = {
+      type: "negative" as const,
+      comment: "The response missed a detail",
+    };
+    makeRequest.mockResolvedValueOnce({
+      feedback_id: "feedback-2",
+      type: "negative",
+      comment: "The response missed a detail",
+    });
+
+    await expect(
+      messages.feedback("thread-1", "message-1", bodyWithComment),
+    ).resolves.toEqual({
+      feedback_id: "feedback-2",
+      type: "negative",
+      comment: "The response missed a detail",
+    });
+    expect(makeRequest).toHaveBeenLastCalledWith(
+      "/threads/thread-1/messages/message-1/feedback",
+      { method: "POST", body: bodyWithComment },
+    );
+
+    makeRequest.mockResolvedValueOnce({
+      feedback_id: "feedback-1",
+      type: "positive",
+    });
+    await messages.feedback("thread-1", "message-1", {
+      type: "positive",
+      comment: "   ",
+    });
+    expect(makeRequest.mock.lastCall![1].body).toStrictEqual({
+      type: "positive",
+    });
+
+    makeRequest.mockResolvedValueOnce({
+      feedback_id: "feedback-3",
+      type: "positive",
+      comment: null,
+    });
+
+    await expect(
+      messages.feedback("thread-1", "message-1", body),
+    ).resolves.toStrictEqual({
+      feedback_id: "feedback-3",
+      type: "positive",
+      comment: null,
+    });
 
     makeRequest.mockResolvedValueOnce({ type: "positive" });