@astralform/js 1.1.0 → 1.2.0

package/dist/index.d.cts

@@ -917,6 +917,13 @@ declare class ChatSession {
     private processStream;
     /** Last received sequence number for resumable reconnection */
     private lastSeq;
+    /**
+     * Client-tool call_ids whose result was already submitted this turn. On a
+     * reconnect the resumed stream can replay a tool request we already handled;
+     * this dedups so each is executed + submitted at most once (but a request we
+     * never submitted still runs). Cleared at the start of each turn.
+     */
+    private submittedToolCallIds;
     /** Current job ID for cancellation */
     currentJobId: string | null;
     private consumeJobStream;
@@ -925,6 +932,16 @@ declare class ChatSession {
      * minimal session state, and emits typed ChatEvents to consumers.
      */
     private consumeEventStream;
+    /**
+     * Consume a single SSE stream to exhaustion. Returns whether a terminal
+     * event (``message_stop`` / ``error``) was seen, so the caller can decide
+     * whether an ended stream means "turn done" vs "dropped, reconnect".
+     */
+    private pumpStream;
+    /** Sleep for ``ms``, resolving early if the turn is aborted mid-backoff. */
+    private sleepUnlessAborted;
+    /** POST a client-tool result, retrying transient failures a few times. */
+    private submitToolResultWithRetry;
     private dispatchWireEvent;
     /**
      * State mutations driven by wire events. Kept separate from translation so

package/dist/index.d.ts

@@ -917,6 +917,13 @@ declare class ChatSession {
     private processStream;
     /** Last received sequence number for resumable reconnection */
     private lastSeq;
+    /**
+     * Client-tool call_ids whose result was already submitted this turn. On a
+     * reconnect the resumed stream can replay a tool request we already handled;
+     * this dedups so each is executed + submitted at most once (but a request we
+     * never submitted still runs). Cleared at the start of each turn.
+     */
+    private submittedToolCallIds;
     /** Current job ID for cancellation */
     currentJobId: string | null;
     private consumeJobStream;
@@ -925,6 +932,16 @@ declare class ChatSession {
      * minimal session state, and emits typed ChatEvents to consumers.
      */
     private consumeEventStream;
+    /**
+     * Consume a single SSE stream to exhaustion. Returns whether a terminal
+     * event (``message_stop`` / ``error``) was seen, so the caller can decide
+     * whether an ended stream means "turn done" vs "dropped, reconnect".
+     */
+    private pumpStream;
+    /** Sleep for ``ms``, resolving early if the turn is aborted mid-backoff. */
+    private sleepUnlessAborted;
+    /** POST a client-tool result, retrying transient failures a few times. */
+    private submitToolResultWithRetry;
     private dispatchWireEvent;
     /**
      * State mutations driven by wire events. Kept separate from translation so

package/dist/index.js

@@ -1144,6 +1144,11 @@ function translateWireEvent(wire) {
 }
 
 // src/session.ts
+var SSE_MAX_RECONNECTS = 6;
+var TOOL_RESULT_MAX_RETRIES = 3;
+function sseReconnectDelayMs(attempt) {
+  return Math.min(500 * 2 ** (attempt - 1), 5e3);
+}
 function pathEquals(a, b) {
   if (a.length !== b.length) return false;
   for (let i = 0; i < a.length; i++) {
@@ -1180,6 +1185,13 @@ var ChatSession = class {
     this.abortController = null;
     /** Last received sequence number for resumable reconnection */
     this.lastSeq = -1;
+    /**
+     * Client-tool call_ids whose result was already submitted this turn. On a
+     * reconnect the resumed stream can replay a tool request we already handled;
+     * this dedups so each is executed + submitted at most once (but a request we
+     * never submitted still runs). Cleared at the start of each turn.
+     */
+    this.submittedToolCallIds = /* @__PURE__ */ new Set();
     /** Current job ID for cancellation */
     this.currentJobId = null;
     this.client = new AstralformClient(config);
@@ -1314,13 +1326,9 @@ var ChatSession = class {
     }
     const messageId = job.message_id;
     this.lastSeq = -1;
-    const stream = this.client.streamJobEvents(
-      job.job_id,
-      this.lastSeq,
-      this.abortController?.signal
-    );
+    this.submittedToolCallIds.clear();
     await this.consumeEventStream(
-      stream,
+      job.job_id,
       conversationId,
       messageId,
       true
@@ -1331,7 +1339,41 @@ var ChatSession = class {
    * Shared event consumption loop. Parses each wire event, updates
    * minimal session state, and emits typed ChatEvents to consumers.
    */
-  async consumeEventStream(stream, conversationId, messageId, executeClientTools) {
+  async consumeEventStream(jobId, conversationId, messageId, executeClientTools) {
+    const signal = this.abortController?.signal;
+    for (let attempt = 0; ; attempt++) {
+      const stream = this.client.streamJobEvents(jobId, this.lastSeq, signal);
+      let sawTerminal;
+      try {
+        sawTerminal = await this.pumpStream(
+          stream,
+          conversationId,
+          messageId,
+          executeClientTools
+        );
+      } catch (err) {
+        if (signal?.aborted) return;
+        if (err instanceof AuthenticationError || err instanceof RateLimitError) {
+          throw err;
+        }
+        if (attempt >= SSE_MAX_RECONNECTS) throw err;
+        await this.sleepUnlessAborted(sseReconnectDelayMs(attempt + 1), signal);
+        continue;
+      }
+      if (sawTerminal || signal?.aborted) return;
+      if (attempt >= SSE_MAX_RECONNECTS) {
+        throw new ConnectionError("Lost connection to the response stream.");
+      }
+      await this.sleepUnlessAborted(sseReconnectDelayMs(attempt + 1), signal);
+    }
+  }
+  /**
+   * Consume a single SSE stream to exhaustion. Returns whether a terminal
+   * event (``message_stop`` / ``error``) was seen, so the caller can decide
+   * whether an ended stream means "turn done" vs "dropped, reconnect".
+   */
+  async pumpStream(stream, conversationId, messageId, executeClientTools) {
+    let sawTerminal = false;
     for await (const raw of stream) {
       let parsed;
       try {
@@ -1349,6 +1391,9 @@ var ChatSession = class {
       } catch {
         continue;
       }
+      if (parsed.type === "message_stop" || parsed.type === "error") {
+        sawTerminal = true;
+      }
       await this.dispatchWireEvent(
         parsed,
         conversationId,
@@ -1356,6 +1401,39 @@ var ChatSession = class {
         executeClientTools
       );
     }
+    return sawTerminal;
+  }
+  /** Sleep for ``ms``, resolving early if the turn is aborted mid-backoff. */
+  sleepUnlessAborted(ms, signal) {
+    return new Promise((resolve) => {
+      if (signal?.aborted) return resolve();
+      const timer = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
+        resolve();
+      }, ms);
+      const onAbort = () => {
+        clearTimeout(timer);
+        resolve();
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  /** POST a client-tool result, retrying transient failures a few times. */
+  async submitToolResultWithRetry(payload) {
+    const signal = this.abortController?.signal;
+    for (let attempt = 0; ; attempt++) {
+      try {
+        await this.client.submitToolResult(payload);
+        return;
+      } catch (err) {
+        if (signal?.aborted) throw err;
+        if (err instanceof AuthenticationError || err instanceof RateLimitError) {
+          throw err;
+        }
+        if (attempt >= TOOL_RESULT_MAX_RETRIES) throw err;
+        await this.sleepUnlessAborted(sseReconnectDelayMs(attempt + 1), signal);
+      }
+    }
   }
   async dispatchWireEvent(wire, conversationId, messageId, executeClientTools) {
     this.applyWireSideEffects(wire, conversationId, messageId);
@@ -1365,18 +1443,22 @@ var ChatSession = class {
     }
     if (executeClientTools && wire.type === "block_stop" && wire.status === "awaiting_client_result" && wire.final?.call_id) {
       const f = wire.final;
-      const request = {
-        callId: f.call_id ?? "",
-        toolName: f.tool_name ?? "",
-        arguments: f.input ?? {},
-        isClientTool: true
-      };
-      const results = await this.executeClientTools([request]);
-      await this.client.submitToolResult({
-        conversation_id: conversationId,
-        message_id: messageId,
-        tool_results: results
-      });
+      const callId = f.call_id ?? "";
+      if (callId && !this.submittedToolCallIds.has(callId)) {
+        const request = {
+          callId,
+          toolName: f.tool_name ?? "",
+          arguments: f.input ?? {},
+          isClientTool: true
+        };
+        const results = await this.executeClientTools([request]);
+        await this.submitToolResultWithRetry({
+          conversation_id: conversationId,
+          message_id: messageId,
+          tool_results: results
+        });
+        this.submittedToolCallIds.add(callId);
+      }
     }
   }
   /**
@@ -1473,16 +1555,12 @@ var ChatSession = class {
     this.isStreaming = true;
     this.currentJobId = jobId;
     this.lastSeq = -1;
+    this.submittedToolCallIds.clear();
     this.resetStreamingState();
     this.abortController = new AbortController();
     try {
-      const stream = this.client.streamJobEvents(
-        jobId,
-        this.lastSeq,
-        this.abortController?.signal
-      );
       await this.consumeEventStream(
-        stream,
+        jobId,
         this.conversationId ?? "",
         "",
         false