@astralform/js 1.0.0 → 1.2.0

package/dist/index.cjs

@@ -554,6 +554,49 @@ var AstralformClient = class {
   async submitToolApproval(request) {
     await this.post("/v1/tool-approval", request);
   }
+  // --- End-user tool-permission self-service ---
+  /**
+   * List the current end user's own remembered tool-permission grants.
+   * Only `conversation`/`always` grants exist (`once` is never persisted).
+   * Paginated via `limit` (default 100, max 200) / `offset`; `total` lets you
+   * page through all of them.
+   */
+  async getMyToolPermissions(options) {
+    const params = new URLSearchParams();
+    if (options?.limit != null) {
+      const safeLimit = Math.max(
+        1,
+        Math.min(200, Math.floor(Number(options.limit)))
+      );
+      params.set("limit", String(safeLimit));
+    }
+    if (options?.offset != null) {
+      const safeOffset = Math.max(0, Math.floor(Number(options.offset)));
+      params.set("offset", String(safeOffset));
+    }
+    const qs = params.toString();
+    const raw = await this.get(`/v1/me/tool-permissions${qs ? `?${qs}` : ""}`);
+    return {
+      grants: raw.grants.map((g) => ({
+        id: g.id,
+        toolName: g.tool_name,
+        decision: g.decision,
+        scope: g.scope,
+        conversationId: g.conversation_id,
+        createdAt: g.created_at
+      })),
+      total: raw.total,
+      limit: raw.limit,
+      offset: raw.offset
+    };
+  }
+  /**
+   * Revoke one of the current end user's remembered grants by id. The agent
+   * will ask again the next time that tool is used.
+   */
+  async revokeToolPermission(id) {
+    await this.del(`/v1/me/tool-permissions/${encodeURIComponent(id)}`);
+  }
   // --- Conversation Assets ---
   mapAsset(raw) {
     return {
@@ -1147,6 +1190,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++) {
@@ -1183,6 +1231,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);
@@ -1317,13 +1372,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
@@ -1334,7 +1385,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 {
@@ -1352,6 +1437,9 @@ var ChatSession = class {
       } catch {
         continue;
       }
+      if (parsed.type === "message_stop" || parsed.type === "error") {
+        sawTerminal = true;
+      }
       await this.dispatchWireEvent(
         parsed,
         conversationId,
@@ -1359,6 +1447,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);
@@ -1368,18 +1489,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);
+      }
     }
   }
   /**
@@ -1476,16 +1601,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