@runtypelabs/sdk 6.4.0 → 6.5.0

package/dist/index.cjs

@@ -213,6 +213,8 @@ var UNIFIED_EVENT_TYPES = /* @__PURE__ */ new Set([
   "artifact_update",
   "artifact_complete",
   "source",
+  "state_snapshot",
+  "state_delta",
   "tool_start",
   "tool_input_delta",
   "tool_input_complete",
@@ -365,9 +367,10 @@ function createFlowEventTranslator() {
             pageOrigin: data.pageOrigin
           })
         ];
-      // Channels/markers/tool-family/approval/skip/source/custom/ping the flow
-      // consumer never read → no callback event. (A non-terminal `error` is only
-      // produced on agent streams; dropping it here avoids a false flow_error.)
+      // Channels/markers/tool-family/approval/skip/source/state/custom/ping the
+      // flow consumer never read → no callback event. (A non-terminal `error` is
+      // only produced on agent streams; dropping it here avoids a false
+      // flow_error.)
       default:
         return [];
     }
@@ -670,8 +673,9 @@ function createAgentEventTranslator() {
       case "ping":
         return [compact({ type: "agent_ping", executionId, seq, timestamp: data.timestamp })];
       // turn/text/reasoning open+close markers, step_*, artifact_*, source,
-      // custom (fallback beat / routing), and the skill-fold result envelope
-      // the SDK never consumed → no callback event.
+      // state_snapshot/state_delta (agent-state channel with no stable SDK
+      // callback), custom (fallback beat / routing), and the skill-fold result
+      // envelope the SDK never consumed → no callback event.
       default:
         return [];
     }
@@ -6048,19 +6052,35 @@ var RuntypeClient = class {
    * normalization the `DispatchEndpoint` applies, with no per-builder call.
    */
   async dispatch(config) {
+    const normalized = normalizeDispatchRequest(config);
+    const request6 = transformRequest({
+      ...normalized,
+      options: {
+        ...normalized.options,
+        streamResponse: true
+      }
+    });
     return this.requestStream("/dispatch", {
       method: "POST",
-      body: JSON.stringify(transformRequest(normalizeDispatchRequest(config)))
+      body: JSON.stringify(request6)
     });
   }
   /**
    * Dispatch flow execution (non-streaming JSON).
    *
    * The non-streaming sibling of {@link dispatch}; it normalizes to the same
-   * canonical wire contract so builders never post a raw, un-normalized body.
+   * canonical wire contract so builders never post a raw, un-normalized body,
+   * and pins `streamResponse: false` so the server returns buffered JSON.
    */
   async dispatchJson(config) {
-    return this.post("/dispatch", normalizeDispatchRequest(config));
+    const normalized = normalizeDispatchRequest(config);
+    return this.post("/dispatch", {
+      ...normalized,
+      options: {
+        ...normalized.options,
+        streamResponse: false
+      }
+    });
   }
   /**
    * Build full URL with query parameters
@@ -6428,7 +6448,7 @@ var Runtype = class {
 
 // src/version.ts
 var FALLBACK_VERSION = "0.0.0";
-var SDK_VERSION = "6.4.0".length > 0 ? "6.4.0" : FALLBACK_VERSION;
+var SDK_VERSION = "6.5.0".length > 0 ? "6.5.0" : FALLBACK_VERSION;
 var RUNTYPE_CLIENT_KIND = "sdk";
 var SDK_USER_AGENT = `runtype-sdk/${SDK_VERSION} (typescript)`;
 
@@ -8977,34 +8997,52 @@ var DispatchEndpoint = class {
    * Dispatch: create and/or execute flows on records atomically
    */
   async execute(data) {
-    return this.client.post("/dispatch", normalizeDispatchRequest(data));
+    const normalized = normalizeDispatchRequest(data);
+    return this.client.post("/dispatch", {
+      ...normalized,
+      options: {
+        ...normalized.options,
+        streamResponse: false
+      }
+    });
   }
   /**
    * Dispatch with streaming response
    */
   async executeStream(data) {
+    const normalized = normalizeDispatchRequest(data);
     return this.client.requestStream("/dispatch", {
       method: "POST",
-      body: JSON.stringify(normalizeDispatchRequest(data))
+      body: JSON.stringify({
+        ...normalized,
+        options: {
+          ...normalized.options,
+          streamResponse: true
+        }
+      })
     });
   }
   /**
    * Resume paused flow execution
-   * API expects snake_case field names
+   * Uses buffered JSON when streamResponse is omitted.
    *
-   * @param data.execution_id - The execution ID to resume
-   * @param data.tool_outputs - Tool outputs to inject into the flow
-   * @param data.stream_response - Whether to stream the response
+   * @param data.executionId - The execution ID to resume
+   * @param data.toolOutputs - Tool outputs to inject into the flow
+   * @param data.streamResponse - Whether to stream the response (defaults to false)
    * @param data.messages - Optional messages to override the original dispatch messages
    */
   async resume(data) {
-    if (data.streamResponse) {
+    const request6 = {
+      ...data,
+      streamResponse: data.streamResponse ?? false
+    };
+    if (request6.streamResponse) {
       return this.client.requestStream("/dispatch/resume", {
         method: "POST",
-        body: JSON.stringify(data)
+        body: JSON.stringify(request6)
       });
     }
-    return this.client.post("/dispatch/resume", data);
+    return this.client.post("/dispatch/resume", request6);
   }
   /**
    * Evaluate a model-proposed runtime tool against a configurable allowlist policy.
@@ -9100,6 +9138,12 @@ var AnalyticsEndpoint = class {
   async getModelUsage(params) {
     return this.client.get("/model-usage", params);
   }
+  /**
+   * Get execution and platform-spend usage grouped by projected product end user.
+   */
+  async getEndUserUsage(params) {
+    return this.client.get("/analytics/end-user-usage", params);
+  }
 };
 var FlowStepsEndpoint = class {
   constructor(client) {