@runtypelabs/sdk 1.22.0 → 1.24.0

package/dist/index.cjs

@@ -469,6 +469,53 @@ var FlowResult = class {
 };
 
 // src/flows-namespace.ts
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeConfig(config) {
+  if (!isRecord(config)) return {};
+  const normalized = {};
+  for (const key of Object.keys(config).sort()) {
+    const value = config[key];
+    if (value === void 0) continue;
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      normalized[key] = normalizeConfig(value);
+    } else if (Array.isArray(value)) {
+      normalized[key] = value.map((item) => {
+        if (item !== null && typeof item === "object" && !Array.isArray(item)) {
+          return normalizeConfig(item);
+        }
+        return item;
+      });
+    } else {
+      normalized[key] = value;
+    }
+  }
+  return normalized;
+}
+function normalizeStepForHash(step) {
+  const stepObj = isRecord(step) ? step : {};
+  return {
+    type: typeof stepObj.type === "string" ? stepObj.type : "",
+    name: typeof stepObj.name === "string" ? stepObj.name : "",
+    enabled: stepObj.enabled !== false,
+    ...typeof stepObj.when === "string" ? { when: stepObj.when } : {},
+    config: normalizeConfig(stepObj.config),
+    order: typeof stepObj.order === "number" ? stepObj.order : 0
+  };
+}
+async function computeFlowContentHash(steps) {
+  const normalized = [...steps].sort((a, b) => {
+    const orderA = isRecord(a) && typeof a.order === "number" ? a.order : 0;
+    const orderB = isRecord(b) && typeof b.order === "number" ? b.order : 0;
+    return orderA - orderB;
+  }).map(normalizeStepForHash);
+  const serialized = JSON.stringify(normalized);
+  const encoded = new TextEncoder().encode(serialized);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", encoded);
+  const hashArray = new Uint8Array(hashBuffer);
+  return Array.from(hashArray).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
 var FlowsNamespace = class {
   constructor(getClient) {
     this.getClient = getClient;
@@ -914,7 +961,7 @@ var RuntypeFlowBuilder = class {
     }
     config.options = { ...config.options, streamResponse: true };
     const client = this.getClient();
-    const response = await client.dispatch(config);
+    const response = await this.dispatchWithPersistedFlow(client, config);
     const result = new FlowResult(response);
     if (callbacks) {
       await result.stream(callbacks);
@@ -943,7 +990,7 @@ var RuntypeFlowBuilder = class {
     }
     config.options = { ...config.options, streamResponse: true };
     const client = this.getClient();
-    const response = await client.dispatch(config);
+    const response = await this.dispatchWithPersistedFlow(client, config);
     const result = new FlowResult(response);
     await result.getSummary();
     return result;
@@ -1127,6 +1174,37 @@ var RuntypeFlowBuilder = class {
   // ============================================================================
   // Private Helpers
   // ============================================================================
+  /**
+   * Persisted flow protocol (APQ-style): send hash-only first, retry with
+   * full definition on FLOW_DEFINITION_REQUIRED. For non-upsert modes,
+   * dispatches directly.
+   */
+  async dispatchWithPersistedFlow(client, config) {
+    if (this.mode !== "upsert" || !this.steps.length) {
+      return client.dispatch(config);
+    }
+    const contentHash = await this.computeContentHash();
+    const hashOnlyConfig = {
+      ...config,
+      flow: { name: config.flow.name, contentHash }
+    };
+    try {
+      return await client.dispatch(hashOnlyConfig);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "";
+      if (!message.includes("422")) {
+        throw err;
+      }
+    }
+    const fullConfig = {
+      ...config,
+      flow: { ...config.flow, contentHash }
+    };
+    return client.dispatch(fullConfig);
+  }
+  async computeContentHash() {
+    return computeFlowContentHash(this.steps);
+  }
   addStep(type, name, config, enabled = true) {
     this.stepCounter++;
     const cleanConfig = {};
@@ -3526,6 +3604,12 @@ var FlowsEndpoint = class {
   async delete(id) {
     return this.client.delete(`/flows/${id}`);
   }
+  /**
+   * Export a flow as a self-contained runtime definition for @runtypelabs/runtime
+   */
+  async exportRuntime(id) {
+    return this.client.get(`/flows/${id}/export-runtime`);
+  }
   /**
    * Run a flow on all records of a specific type
    */
@@ -4507,6 +4591,12 @@ var _AgentsEndpoint = class _AgentsEndpoint {
   async delete(id) {
     return this.client.delete(`/agents/${id}`);
   }
+  /**
+   * Export an agent as a self-contained runtime definition for @runtypelabs/runtime
+   */
+  async exportRuntime(id) {
+    return this.client.get(`/agents/${id}/export-runtime`);
+  }
   /**
    * Evaluate a model-proposed runtime tool against a configurable allowlist policy.
    * Useful for local `propose_runtime_tool` handlers before follow-up execution.