@runtypelabs/sdk 9.2.1 → 9.3.0

package/dist/index.mjs

@@ -4757,7 +4757,8 @@ var AGENT_CONFIG_KEYS = [
   "temporal",
   "memory",
   "sandbox",
-  "tenancyStrategy"
+  "tenancyStrategy",
+  "durability"
 ];
 var AGENT_CONFIG_KEY_LIST = [...AGENT_CONFIG_KEYS].sort();
 function isPlainObject2(value) {
@@ -6327,10 +6328,151 @@ var Runtype = class {
 
 // src/version.ts
 var FALLBACK_VERSION = "0.0.0";
-var SDK_VERSION = "9.2.1".length > 0 ? "9.2.1" : FALLBACK_VERSION;
+var SDK_VERSION = "9.3.0".length > 0 ? "9.3.0" : FALLBACK_VERSION;
 var RUNTYPE_CLIENT_KIND = "sdk";
 var SDK_USER_AGENT = `runtype-sdk/${SDK_VERSION} (typescript)`;
 
+// src/detached-reconnect.ts
+var TERMINAL_EVENTS = /* @__PURE__ */ new Set(["execution_complete", "execution_error"]);
+var DEFAULT_MAX_DETACHED_RECONNECTS = 12;
+function observeBlock(block, into) {
+  let eventName = null;
+  for (const line of block.split("\n")) {
+    if (line.startsWith("id:")) {
+      into.lastId = line.slice(3).trim();
+      continue;
+    }
+    if (line.startsWith("event:")) {
+      eventName = line.slice(6).trim();
+      continue;
+    }
+    if (!line.startsWith("data:")) continue;
+    const raw = line.slice(5).trim();
+    if (!raw || raw === "[DONE]") continue;
+    let payload;
+    try {
+      const parsed = JSON.parse(raw);
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) continue;
+      payload = parsed;
+    } catch {
+      continue;
+    }
+    if (typeof payload.executionId === "string") into.executionId = payload.executionId;
+    const type = typeof payload.type === "string" ? payload.type : eventName;
+    if (type && TERMINAL_EVENTS.has(type)) into.sawTerminal = true;
+    if (type === "await" && payload.awaitReason === "detached") into.sawDetach = true;
+  }
+}
+function withDetachedReconnect(response, reattach, options = {}) {
+  if (options.autoReconnect === false) return response;
+  if (!response.ok || !response.body) return response;
+  const contentType = response.headers.get("content-type") ?? "";
+  if (!contentType.includes("text/event-stream")) return response;
+  const maxReconnects = options.maxReconnects ?? DEFAULT_MAX_DETACHED_RECONNECTS;
+  const reconnectDelayMs = options.reconnectDelayMs ?? 0;
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder();
+  const abort = new AbortController();
+  let cancelled = false;
+  let activeReader = null;
+  const stream = new ReadableStream({
+    async start(controller) {
+      const observed = {
+        lastId: null,
+        executionId: null,
+        sawTerminal: false,
+        sawDetach: false
+      };
+      let current = response;
+      let legs = 0;
+      const enqueue = (chunk) => {
+        if (cancelled) return;
+        controller.enqueue(chunk);
+      };
+      try {
+        while (!cancelled && current?.body) {
+          const reader = current.body.getReader();
+          activeReader = reader;
+          let buffer = "";
+          observed.sawDetach = false;
+          for (; ; ) {
+            const { value, done } = await reader.read();
+            if (cancelled) break;
+            if (value) {
+              enqueue(value);
+              buffer += decoder.decode(value, { stream: !done });
+              let boundary = buffer.indexOf("\n\n");
+              while (boundary >= 0) {
+                observeBlock(buffer.slice(0, boundary), observed);
+                buffer = buffer.slice(boundary + 2);
+                boundary = buffer.indexOf("\n\n");
+              }
+            }
+            if (done) break;
+          }
+          activeReader = null;
+          if (cancelled) break;
+          if (buffer.trim()) observeBlock(buffer, observed);
+          if (observed.sawTerminal || !observed.sawDetach) break;
+          if (!observed.executionId || legs >= maxReconnects) break;
+          legs += 1;
+          if (reconnectDelayMs > 0) {
+            await new Promise((resolve) => setTimeout(resolve, reconnectDelayMs));
+          }
+          if (cancelled) break;
+          current = await reattach({
+            executionId: observed.executionId,
+            // `'0'` replays the whole turn — the fail-open answer for a leg
+            // that produced no cursor at all.
+            after: observed.lastId ?? "0",
+            signal: abort.signal
+          });
+          if (cancelled) {
+            await current?.body?.cancel().catch(() => {
+            });
+            break;
+          }
+          if (!current || !current.ok || !current.body) {
+            enqueue(
+              encoder.encode(
+                `event: error
+data: ${JSON.stringify({
+                  type: "error",
+                  executionId: observed.executionId,
+                  error: {
+                    code: "detached_reconnect_failed",
+                    message: "The agent detached and this client could not rejoin its stream. The execution is still running; reattach with the events route."
+                  },
+                  recoverable: false
+                })}
+
+`
+              )
+            );
+            break;
+          }
+        }
+      } finally {
+        activeReader = null;
+        if (!cancelled) controller.close();
+      }
+    },
+    async cancel(reason) {
+      cancelled = true;
+      abort.abort(reason);
+      const reader = activeReader;
+      activeReader = null;
+      if (reader) await reader.cancel(reason).catch(() => {
+      });
+    }
+  });
+  return new Response(stream, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+}
+
 // src/generated-tool-gate.ts
 var TOOL_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_]{1,63}$/;
 var DEFAULT_MAX_CODE_LENGTH = 12e3;
@@ -9711,6 +9853,14 @@ function appendRuntimeToolsToAgentRequest(request6, runtimeTools) {
     }
   };
 }
+function buildAgentAdmissionHeaders(options) {
+  if (!options) return {};
+  const headers = {};
+  if (options.concurrency) headers["x-runtype-concurrency"] = options.concurrency;
+  if (options.coalesce) headers["x-runtype-coalesce"] = "true";
+  if (options.idempotencyKey) headers["idempotency-key"] = options.idempotencyKey;
+  return headers;
+}
 var _AgentsEndpoint = class _AgentsEndpoint {
   constructor(client) {
     this.client = client;
@@ -9802,18 +9952,22 @@ var _AgentsEndpoint = class _AgentsEndpoint {
   /**
    * Execute an agent (non-streaming)
    */
-  async execute(id, data) {
-    return this.client.post(`/agents/${id}/execute`, {
-      ...data,
-      streamResponse: false
-    });
+  async execute(id, data, options) {
+    return this.client.post(
+      `/agents/${id}/execute`,
+      {
+        ...data,
+        streamResponse: false
+      },
+      buildAgentAdmissionHeaders(options)
+    );
   }
   /** Start an agent execution and return its durable handle immediately. */
-  async executeAsync(id, data) {
+  async executeAsync(id, data, options) {
     return this.client.post(
       `/agents/${id}/execute`,
       { ...data, streamResponse: false },
-      { Prefer: "respond-async" }
+      { Prefer: "respond-async", ...buildAgentAdmissionHeaders(options) }
     );
   }
   /**
@@ -9835,14 +9989,42 @@ var _AgentsEndpoint = class _AgentsEndpoint {
    * ```
    */
   async executeStream(id, data, init) {
-    return this.client.requestStream(`/agents/${id}/execute`, {
+    const admissionHeaders = buildAgentAdmissionHeaders(init);
+    const response = await this.client.requestStream(`/agents/${id}/execute`, {
       method: "POST",
       body: JSON.stringify({
         ...data,
         streamResponse: true
       }),
+      ...Object.keys(admissionHeaders).length > 0 ? { headers: admissionHeaders } : {},
       ...init?.signal ? { signal: init.signal } : {}
     });
+    return withDetachedReconnect(
+      response,
+      this.buildDetachedReattach(id, data, init?.signal),
+      init ?? {}
+    );
+  }
+  /**
+   * The `?after=` reattach leg every durable agent stream is followed with.
+   *
+   * Shared by `executeStream` and by the local-tool loop's RESUME leg: a
+   * durable resume answers on the same watch-lease contract as the original
+   * execute, so its socket can close on `awaitReason: 'detached'` too. Building
+   * it once is what keeps the two from drifting into different cursor or
+   * conversation-key behavior.
+   */
+  buildDetachedReattach(id, data, signal) {
+    return async ({ executionId, after }) => {
+      const named = data?.conversationId;
+      const conversationId = typeof named === "string" ? named : "";
+      const query = new URLSearchParams({ after });
+      if (conversationId) query.set("conversationId", conversationId);
+      return this.client.requestStream(`/agents/${id}/executions/${executionId}/events?${query.toString()}`, {
+        method: "GET",
+        ...signal ? { signal } : {}
+      }).catch(() => null);
+    };
   }
   /**
    * Execute an agent with streaming and callbacks
@@ -10006,7 +10188,7 @@ var _AgentsEndpoint = class _AgentsEndpoint {
             callbacks?.onTurnComplete?.(event);
           },
           onAgentPaused: (event) => {
-            pausedEvent = event;
+            if (event.awaitReason !== "detached") pausedEvent = event;
             callbacks?.onAgentPaused?.(event);
           },
           onAgentComplete: (event) => {
@@ -10187,7 +10369,7 @@ var _AgentsEndpoint = class _AgentsEndpoint {
         }
         let resumeResponse;
         try {
-          resumeResponse = await this.client.requestStream(`/agents/${id}/resume`, {
+          const rawResumeResponse = await this.client.requestStream(`/agents/${id}/resume`, {
             method: "POST",
             body: JSON.stringify({
               executionId,
@@ -10197,6 +10379,11 @@ var _AgentsEndpoint = class _AgentsEndpoint {
             }),
             ...abortSignal ? { signal: abortSignal } : {}
           });
+          resumeResponse = withDetachedReconnect(
+            rawResumeResponse,
+            this.buildDetachedReattach(id, data, abortSignal),
+            {}
+          );
         } catch (error) {
           if (abortSignal?.aborted) return finishAborted(executionId);
           throw error;
@@ -14258,6 +14445,7 @@ export {
   CollectionsEndpoint,
   ContextTemplatesEndpoint,
   ConversationsEndpoint,
+  DEFAULT_MAX_DETACHED_RECONNECTS,
   DEFAULT_RECOVERY_AFTER_EMPTY_SESSIONS,
   DEFAULT_STALL_STOP_AFTER,
   DispatchEndpoint,
@@ -14316,6 +14504,7 @@ export {
   UsersEndpoint,
   applyGeneratedRuntimeToolProposalToDispatchRequest,
   attachRuntimeToolsToDispatchRequest,
+  buildAgentAdmissionHeaders,
   buildEmptySessionNudge,
   buildGeneratedRuntimeToolGateOutput,
   buildLedgerOffloadReference,
@@ -14405,5 +14594,6 @@ export {
   unregisterWorkflowHook,
   usedNoTools,
   validJson,
+  withDetachedReconnect,
   withUnifiedEvents
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runtypelabs/sdk",
-  "version": "9.2.1",
+  "version": "9.3.0",
   "type": "module",
   "description": "TypeScript SDK for the Runtype API with fluent methods. Use it to quickly realize AI products, agents, and workflows.",
   "main": "dist/index.cjs",