assistant-cloud 0.2.1 → 0.2.2

package/src/AssistantCloudThreadMessages.ts

@@ -49,11 +49,13 @@ const MESSAGE_FEEDBACK_TYPES = ["positive", "negative"] as const;
 
 export type AssistantCloudThreadMessageFeedbackBody = {
   type: "positive" | "negative";
+  comment?: string;
 };
 
 export type AssistantCloudThreadMessageFeedbackResponse = {
   feedback_id: string;
   type: "positive" | "negative";
+  comment?: string | null;
 };
 
 export const decodeCloudMessage = (
@@ -132,10 +134,17 @@ export class AssistantCloudThreadMessages {
     messageId: string,
     body: AssistantCloudThreadMessageFeedbackBody,
   ): Promise<AssistantCloudThreadMessageFeedbackResponse> {
+    const comment = body.comment?.trim();
     const response = readCloudRecord(
       await this.cloud.makeRequest(
         `/threads/${encodeURIComponent(threadId)}/messages/${encodeURIComponent(messageId)}/feedback`,
-        { method: "POST", body },
+        {
+          method: "POST",
+          body: {
+            type: body.type,
+            ...(comment ? { comment } : undefined),
+          },
+        },
       ),
       "thread message feedback response",
     );
@@ -143,6 +152,9 @@ export class AssistantCloudThreadMessages {
     return {
       feedback_id: readCloudString(response.feedback_id, "feedback_id"),
       type: readCloudEnum(response.type, "type", MESSAGE_FEEDBACK_TYPES),
+      ...("comment" in response
+        ? { comment: readCloudNullableString(response.comment, "comment") }
+        : undefined),
     };
   }
 }

package/src/CloudRunReporter.ts

@@ -1,4 +1,5 @@
 import type { AssistantCloud } from "./AssistantCloud";
+import { CloudAPIError } from "./AssistantCloudAPI";
 import { createRunReport, type RunReportInit } from "./runTelemetry";
 
 export type CloudRunReportInit = Omit<RunReportInit, "telemetry">;
@@ -7,8 +8,8 @@ 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.
  */
 export class CloudRunReporter {
   private readonly reported = new Set<string>();
@@ -19,6 +20,7 @@ export class CloudRunReporter {
   }
 
   public async report(init: CloudRunReportInit, key?: string): Promise<void> {
+    let claimedKey: string | undefined;
     try {
       const cloud = this.getCloud();
       if (!cloud.telemetry.enabled) return;
@@ -29,10 +31,20 @@ export class CloudRunReporter {
       const report = beforeReport ? beforeReport(initial) : initial;
       if (!report) return;
 
-      if (key !== undefined) this.reported.add(key);
+      if (key !== undefined) {
+        this.reported.add(key);
+        claimedKey = key;
+      }
       await cloud.runs.report(report);
-    } catch {
+    } catch (error) {
+      if (claimedKey !== undefined && isRetryableReportError(error)) {
+        this.reported.delete(claimedKey);
+      }
       return;
     }
   }
 }
+
+const isRetryableReportError = (error: unknown): boolean => {
+  return error instanceof CloudAPIError && error.status === 429;
+};

package/src/tests/CloudRunReporter.test.ts

@@ -1,6 +1,8 @@
 import { describe, expect, it, vi } from "vitest";
 import type { AssistantCloud } from "../AssistantCloud";
+import { CloudAPIError } from "../AssistantCloudAPI";
 import { CloudRunReporter } from "../CloudRunReporter";
+import { CloudResponseError } from "../cloudResponse";
 
 const createCloud = (telemetry: AssistantCloud["telemetry"]) => {
   const report = vi.fn().mockResolvedValue({ run_id: "run_1" });
@@ -69,6 +71,39 @@ describe("CloudRunReporter", () => {
     expect(report).toHaveBeenCalledTimes(3);
   });
 
+  it("allows a keyed run to retry after rate limiting", async () => {
+    const { cloud, report } = createCloud({ enabled: true });
+    report.mockRejectedValueOnce(new CloudAPIError("rate limited", 429));
+    const reporter = new CloudRunReporter(cloud);
+
+    await reporter.report({ threadId: "t", status: "completed" }, "t:m");
+    await reporter.report({ threadId: "t", status: "completed" }, "t:m");
+    await reporter.report({ threadId: "t", status: "completed" }, "t:m");
+
+    expect(report).toHaveBeenCalledTimes(2);
+  });
+
+  it.each([
+    ["a transport failure", new Error("offline")],
+    ["a request timeout", new CloudAPIError("timeout", 408)],
+    ["a server error", new CloudAPIError("unavailable", 503)],
+    [
+      "a successful response with an invalid body",
+      new CloudResponseError("invalid response"),
+    ],
+    ["a successful response with invalid JSON", new SyntaxError("invalid")],
+    ["a permanent client error", new CloudAPIError("invalid report", 400)],
+  ])("does not retry after %s", async (_name, error) => {
+    const { cloud, report } = createCloud({ enabled: true });
+    report.mockRejectedValueOnce(error);
+    const reporter = new CloudRunReporter(cloud);
+
+    await reporter.report({ threadId: "t", status: "completed" }, "t:m");
+    await reporter.report({ threadId: "t", status: "completed" }, "t:m");
+
+    expect(report).toHaveBeenCalledOnce();
+  });
+
   it("swallows a failed send and reads the cloud through a getter", async () => {
     const { cloud } = createCloud({ enabled: true });
     (cloud.runs.report as ReturnType<typeof vi.fn>).mockRejectedValue(