@runtypelabs/sdk 9.2.1 → 9.3.0

package/dist/index.cjs

@@ -39,6 +39,7 @@ __export(index_exports, {
   CollectionsEndpoint: () => CollectionsEndpoint,
   ContextTemplatesEndpoint: () => ContextTemplatesEndpoint,
   ConversationsEndpoint: () => ConversationsEndpoint,
+  DEFAULT_MAX_DETACHED_RECONNECTS: () => DEFAULT_MAX_DETACHED_RECONNECTS,
   DEFAULT_RECOVERY_AFTER_EMPTY_SESSIONS: () => DEFAULT_RECOVERY_AFTER_EMPTY_SESSIONS,
   DEFAULT_STALL_STOP_AFTER: () => DEFAULT_STALL_STOP_AFTER,
   DispatchEndpoint: () => DispatchEndpoint,
@@ -97,6 +98,7 @@ __export(index_exports, {
   UsersEndpoint: () => UsersEndpoint,
   applyGeneratedRuntimeToolProposalToDispatchRequest: () => applyGeneratedRuntimeToolProposalToDispatchRequest,
   attachRuntimeToolsToDispatchRequest: () => attachRuntimeToolsToDispatchRequest,
+  buildAgentAdmissionHeaders: () => buildAgentAdmissionHeaders,
   buildEmptySessionNudge: () => buildEmptySessionNudge,
   buildGeneratedRuntimeToolGateOutput: () => buildGeneratedRuntimeToolGateOutput,
   buildLedgerOffloadReference: () => buildLedgerOffloadReference,
@@ -186,6 +188,7 @@ __export(index_exports, {
   unregisterWorkflowHook: () => unregisterWorkflowHook,
   usedNoTools: () => usedNoTools,
   validJson: () => validJson,
+  withDetachedReconnect: () => withDetachedReconnect,
   withUnifiedEvents: () => withUnifiedEvents
 });
 module.exports = __toCommonJS(index_exports);
@@ -4949,7 +4952,8 @@ var AGENT_CONFIG_KEYS = [
   "temporal",
   "memory",
   "sandbox",
-  "tenancyStrategy"
+  "tenancyStrategy",
+  "durability"
 ];
 var AGENT_CONFIG_KEY_LIST = [...AGENT_CONFIG_KEYS].sort();
 function isPlainObject2(value) {
@@ -6519,10 +6523,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;
@@ -9903,6 +10048,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;
@@ -9994,18 +10147,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) }
     );
   }
   /**
@@ -10027,14 +10184,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
@@ -10198,7 +10383,7 @@ var _AgentsEndpoint = class _AgentsEndpoint {
             callbacks?.onTurnComplete?.(event);
           },
           onAgentPaused: (event) => {
-            pausedEvent = event;
+            if (event.awaitReason !== "detached") pausedEvent = event;
             callbacks?.onAgentPaused?.(event);
           },
           onAgentComplete: (event) => {
@@ -10379,7 +10564,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,
@@ -10389,6 +10574,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;
@@ -14451,6 +14641,7 @@ var STEP_TYPE_TO_METHOD = {
   CollectionsEndpoint,
   ContextTemplatesEndpoint,
   ConversationsEndpoint,
+  DEFAULT_MAX_DETACHED_RECONNECTS,
   DEFAULT_RECOVERY_AFTER_EMPTY_SESSIONS,
   DEFAULT_STALL_STOP_AFTER,
   DispatchEndpoint,
@@ -14509,6 +14700,7 @@ var STEP_TYPE_TO_METHOD = {
   UsersEndpoint,
   applyGeneratedRuntimeToolProposalToDispatchRequest,
   attachRuntimeToolsToDispatchRequest,
+  buildAgentAdmissionHeaders,
   buildEmptySessionNudge,
   buildGeneratedRuntimeToolGateOutput,
   buildLedgerOffloadReference,
@@ -14598,5 +14790,6 @@ var STEP_TYPE_TO_METHOD = {
   unregisterWorkflowHook,
   usedNoTools,
   validJson,
+  withDetachedReconnect,
   withUnifiedEvents
 });