@runtypelabs/sdk 4.19.2 → 4.21.0

package/dist/index.cjs

@@ -89,6 +89,7 @@ __export(index_exports, {
   ToolEnsureConflictError: () => ToolEnsureConflictError,
   ToolsEndpoint: () => ToolsEndpoint,
   ToolsNamespace: () => ToolsNamespace,
+  UNIFIED_EVENTS_QUERY: () => UNIFIED_EVENTS_QUERY,
   UsersEndpoint: () => UsersEndpoint,
   applyGeneratedRuntimeToolProposalToDispatchRequest: () => applyGeneratedRuntimeToolProposalToDispatchRequest,
   attachRuntimeToolsToDispatchRequest: () => attachRuntimeToolsToDispatchRequest,
@@ -105,8 +106,10 @@ __export(index_exports, {
   computeSkillContentHash: () => computeSkillContentHash,
   computeSurfaceContentHash: () => computeSurfaceContentHash,
   computeToolContentHash: () => computeToolContentHash,
+  createAgentEventTranslator: () => createAgentEventTranslator,
   createClient: () => createClient,
   createExternalTool: () => createExternalTool,
+  createFlowEventTranslator: () => createFlowEventTranslator,
   defaultWorkflow: () => defaultWorkflow,
   defaultWorkflowConfig: () => defaultWorkflowConfig,
   defineAgent: () => defineAgent,
@@ -129,6 +132,7 @@ __export(index_exports, {
   isDiscoveryToolName: () => isDiscoveryToolName,
   isMarathonArtifactPath: () => isMarathonArtifactPath,
   isPreservationSensitiveTask: () => isPreservationSensitiveTask,
+  isUnifiedEventType: () => isUnifiedEventType,
   isWorkflowHookRef: () => isWorkflowHookRef,
   listWorkflowHooks: () => listWorkflowHooks,
   normalizeAgentDefinition: () => normalizeAgentDefinition,
@@ -143,6 +147,7 @@ __export(index_exports, {
   parseOffloadedOutputId: () => parseOffloadedOutputId,
   parseSSEChunk: () => parseSSEChunk,
   processStream: () => processStream,
+  pullFpo: () => pullFpo,
   registerWorkflowHook: () => registerWorkflowHook,
   resolveStallStopAfter: () => resolveStallStopAfter,
   resolveWorkflowHook: () => resolveWorkflowHook,
@@ -150,10 +155,511 @@ __export(index_exports, {
   shouldInjectEmptySessionNudge: () => shouldInjectEmptySessionNudge,
   shouldRequestModelEscalation: () => shouldRequestModelEscalation,
   streamEvents: () => streamEvents,
-  unregisterWorkflowHook: () => unregisterWorkflowHook
+  unregisterWorkflowHook: () => unregisterWorkflowHook,
+  withUnifiedEvents: () => withUnifiedEvents
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/unified-stream-adapter.ts
+var UNIFIED_EVENTS_QUERY = "events=unified";
+function withUnifiedEvents(path) {
+  return path.includes("?") ? `${path}&${UNIFIED_EVENTS_QUERY}` : `${path}?${UNIFIED_EVENTS_QUERY}`;
+}
+var UNIFIED_ONLY_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "execution_start",
+  "execution_complete",
+  "execution_error",
+  "turn_start",
+  "turn_complete",
+  "text_start",
+  "text_delta",
+  "text_complete",
+  "reasoning_start",
+  "reasoning_delta",
+  "reasoning_complete",
+  "media_start",
+  "media_delta",
+  "media_complete",
+  "tool_output_delta",
+  "await"
+]);
+function isUnifiedEventType(type) {
+  return typeof type === "string" && UNIFIED_ONLY_EVENT_TYPES.has(type);
+}
+function str(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function num(value) {
+  return typeof value === "number" ? value : void 0;
+}
+function compact(event) {
+  const out = { type: event.type };
+  for (const [k, v] of Object.entries(event)) {
+    if (k !== "type" && v !== void 0) out[k] = v;
+  }
+  return out;
+}
+var LEGACY_FLOW_PASSTHROUGH = /* @__PURE__ */ new Set([
+  "flow_start",
+  "flow_complete",
+  "flow_error",
+  "flow_await",
+  "step_await",
+  "step_delta"
+]);
+function createFlowEventTranslator() {
+  let currentStepId;
+  let currentStepName;
+  return (raw) => {
+    if (!raw || typeof raw !== "object") return [];
+    const data = raw;
+    const type = str(data.type);
+    if (!type) return [];
+    const executionId = str(data.executionId);
+    const seq = num(data.seq);
+    if (LEGACY_FLOW_PASSTHROUGH.has(type)) return [data];
+    switch (type) {
+      case "execution_start":
+        if (data.kind !== "flow") return [];
+        return [
+          compact({
+            type: "flow_start",
+            executionId,
+            seq,
+            flowId: data.flowId,
+            flowName: data.flowName,
+            totalSteps: data.totalSteps,
+            startedAt: data.startedAt,
+            source: data.source
+          })
+        ];
+      case "step_start": {
+        const id = str(data.id) ?? str(data.stepId);
+        const name = str(data.name) ?? str(data.stepName);
+        currentStepId = id;
+        currentStepName = name;
+        return [
+          compact({
+            type: "step_start",
+            executionId,
+            seq,
+            stepId: id,
+            name,
+            stepName: name,
+            stepType: data.stepType,
+            index: data.index,
+            totalSteps: data.totalSteps,
+            startedAt: data.startedAt,
+            outputVariable: data.outputVariable
+          })
+        ];
+      }
+      case "text_delta":
+        return [
+          compact({
+            type: "step_delta",
+            executionId,
+            seq,
+            delta: str(data.delta) ?? "",
+            text: str(data.delta) ?? "",
+            stepId: currentStepId,
+            name: currentStepName,
+            stepName: currentStepName
+          })
+        ];
+      case "step_complete": {
+        const id = str(data.id) ?? str(data.stepId);
+        const name = str(data.name) ?? str(data.stepName);
+        const out = compact({
+          type: "step_complete",
+          executionId,
+          seq,
+          stepId: id,
+          name,
+          stepName: name,
+          stepType: data.stepType,
+          result: data.result,
+          success: data.success,
+          executionTime: num(data.durationMs) ?? num(data.executionTime),
+          stopReason: data.stopReason,
+          completedAt: data.completedAt,
+          unresolvedVariables: data.unresolvedVariables,
+          error: data.error
+        });
+        currentStepId = void 0;
+        currentStepName = void 0;
+        return [out];
+      }
+      case "execution_complete":
+        if (data.kind !== "flow") return [];
+        return [
+          compact({
+            type: "flow_complete",
+            executionId,
+            seq,
+            success: data.success,
+            totalSteps: data.totalSteps,
+            successfulSteps: data.successfulSteps,
+            failedSteps: data.failedSteps,
+            executionTime: data.durationMs,
+            finalOutput: data.finalOutput,
+            completedAt: data.completedAt
+          })
+        ];
+      case "execution_error":
+        return [
+          compact({
+            type: "flow_error",
+            executionId,
+            seq,
+            error: data.error,
+            code: data.code,
+            upgradeUrl: data.upgradeUrl
+          })
+        ];
+      case "await":
+        return [
+          compact({
+            type: "flow_await",
+            executionId,
+            seq,
+            toolId: data.toolId ?? data.toolCallId,
+            toolName: data.toolName,
+            parameters: data.parameters,
+            awaitedAt: data.awaitedAt,
+            origin: data.origin,
+            pageOrigin: data.pageOrigin
+          })
+        ];
+      // Channels/markers/tool-family/approval/skip/source/custom/ping the flow
+      // consumer never read → no legacy event. (A non-terminal `error` is only
+      // produced on agent streams; dropping it here avoids a false flow_error.)
+      default:
+        return [];
+    }
+  };
+}
+function createAgentEventTranslator() {
+  let agentId;
+  let iteration;
+  let turnId;
+  let reasoningScope;
+  let media = null;
+  return (raw) => {
+    if (!raw || typeof raw !== "object") return [];
+    const data = raw;
+    const type = str(data.type);
+    if (!type) return [];
+    const executionId = str(data.executionId);
+    const seq = num(data.seq);
+    const iter = num(data.iteration) ?? iteration;
+    if (type.startsWith("agent_")) return [data];
+    switch (type) {
+      case "execution_start":
+        if (data.kind !== "agent") return [];
+        agentId = str(data.agentId);
+        return [
+          compact({
+            type: "agent_start",
+            executionId,
+            seq,
+            agentId: data.agentId,
+            agentName: data.agentName,
+            maxTurns: data.maxTurns,
+            startedAt: data.startedAt,
+            config: data.config
+          })
+        ];
+      case "turn_start":
+        turnId = str(data.id);
+        iteration = num(data.iteration) ?? iteration;
+        return [
+          compact({
+            type: "agent_turn_start",
+            executionId,
+            seq,
+            iteration: data.iteration ?? iteration,
+            turnId: data.id,
+            turnIndex: data.turnIndex,
+            role: data.role
+          })
+        ];
+      case "text_delta":
+        return [
+          compact({
+            type: "agent_turn_delta",
+            executionId,
+            seq,
+            iteration: iter,
+            turnId,
+            delta: str(data.delta) ?? "",
+            contentType: "text"
+          })
+        ];
+      case "reasoning_start":
+        reasoningScope = data.scope === "loop" ? "loop" : "turn";
+        return [];
+      case "reasoning_delta":
+        return [
+          compact({
+            type: "agent_turn_delta",
+            executionId,
+            seq,
+            iteration: iter,
+            turnId,
+            delta: str(data.delta) ?? "",
+            contentType: "thinking"
+          })
+        ];
+      case "reasoning_complete": {
+        const scope = data.scope === "loop" ? "loop" : reasoningScope;
+        reasoningScope = void 0;
+        if (scope === "loop") {
+          return [
+            compact({
+              type: "agent_reflection",
+              executionId,
+              seq,
+              iteration: iter,
+              reflection: data.text
+            })
+          ];
+        }
+        return [];
+      }
+      case "turn_complete":
+        return [
+          compact({
+            type: "agent_turn_complete",
+            executionId,
+            seq,
+            iteration: data.iteration ?? iter,
+            turnId: data.id,
+            role: data.role,
+            completedAt: data.completedAt,
+            content: data.content,
+            tokens: data.tokens,
+            cost: data.cost,
+            stopReason: data.stopReason
+          })
+        ];
+      case "tool_start":
+        return [
+          compact({
+            type: "agent_tool_start",
+            executionId,
+            seq,
+            iteration: iter,
+            toolCallId: data.toolCallId,
+            toolName: data.toolName,
+            toolType: data.toolType,
+            parameters: data.parameters,
+            origin: data.origin,
+            pageOrigin: data.pageOrigin
+          })
+        ];
+      case "tool_output_delta":
+        return [
+          compact({
+            type: "agent_tool_delta",
+            executionId,
+            seq,
+            iteration: iter,
+            toolCallId: data.toolCallId,
+            delta: str(data.delta) ?? ""
+          })
+        ];
+      case "tool_input_delta":
+        return [
+          compact({
+            type: "agent_tool_input_delta",
+            executionId,
+            seq,
+            iteration: iter,
+            toolCallId: data.toolCallId,
+            delta: str(data.delta) ?? ""
+          })
+        ];
+      case "tool_input_complete":
+        return [
+          compact({
+            type: "agent_tool_input_complete",
+            executionId,
+            seq,
+            iteration: iter,
+            toolCallId: data.toolCallId,
+            toolName: data.toolName,
+            parameters: data.parameters ?? {},
+            hiddenParameterNames: data.hiddenParameterNames
+          })
+        ];
+      case "tool_complete":
+        return [
+          compact({
+            type: "agent_tool_complete",
+            executionId,
+            seq,
+            iteration: num(data.iteration) ?? iter,
+            toolCallId: data.toolCallId,
+            toolName: data.toolName,
+            success: data.success,
+            result: data.result,
+            executionTime: data.executionTime
+          })
+        ];
+      case "media_start":
+        media = {
+          mediaType: str(data.mediaType),
+          role: str(data.role),
+          toolCallId: str(data.toolCallId),
+          chunks: []
+        };
+        return [];
+      case "media_delta": {
+        const delta = str(data.delta);
+        if (media && delta) media.chunks.push(delta);
+        return [];
+      }
+      case "media_complete": {
+        const acc = media;
+        media = null;
+        const mediaType = str(data.mediaType) ?? acc?.mediaType;
+        const toolCallId = str(data.toolCallId) ?? acc?.toolCallId;
+        const url = str(data.url);
+        const inlineData = str(data.data) ?? (acc && acc.chunks.length ? acc.chunks.join("") : void 0);
+        let item;
+        if (url) {
+          const kind = mediaType && mediaType.startsWith("image/") ? "image-url" : "file-url";
+          item = compact({ type: kind, url, mediaType });
+        } else {
+          item = compact({ type: "media", data: inlineData ?? "", mediaType });
+        }
+        return [
+          compact({
+            type: "agent_media",
+            executionId,
+            seq,
+            iteration: iter,
+            toolCallId,
+            media: [item]
+          })
+        ];
+      }
+      case "approval_start":
+        return [
+          compact({
+            type: "agent_approval_start",
+            executionId,
+            seq,
+            iteration: iter,
+            approvalId: data.approvalId,
+            toolCallId: data.toolCallId,
+            toolName: data.toolName,
+            toolType: data.toolType,
+            description: data.description,
+            reason: data.reason,
+            parameters: data.parameters,
+            timeout: data.timeout,
+            startedAt: data.startedAt
+          })
+        ];
+      case "approval_complete":
+        return [
+          compact({
+            type: "agent_approval_complete",
+            executionId,
+            seq,
+            approvalId: data.approvalId,
+            decision: data.decision,
+            completedAt: data.completedAt,
+            resolvedBy: data.resolvedBy
+          })
+        ];
+      case "await":
+        return [
+          compact({
+            type: "agent_await",
+            executionId,
+            seq,
+            toolId: data.toolId ?? data.toolCallId,
+            toolName: data.toolName,
+            parameters: data.parameters,
+            awaitedAt: data.awaitedAt,
+            origin: data.origin,
+            pageOrigin: data.pageOrigin
+          })
+        ];
+      case "execution_complete":
+        if (data.kind !== "agent") return [];
+        return [
+          compact({
+            type: "agent_complete",
+            executionId,
+            seq,
+            agentId: data.agentId ?? agentId,
+            success: data.success,
+            iterations: data.iterations,
+            stopReason: data.stopReason,
+            completedAt: data.completedAt,
+            totalCost: data.totalCost,
+            totalTokens: data.totalTokens,
+            finalOutput: data.finalOutput,
+            duration: data.durationMs
+          })
+        ];
+      case "execution_error":
+        return [
+          compact({
+            type: "agent_complete",
+            executionId,
+            seq,
+            agentId,
+            success: false,
+            stopReason: "error",
+            error: errorMessage(data.error),
+            completedAt: data.completedAt
+          })
+        ];
+      case "error":
+        return [
+          compact({
+            type: "agent_error",
+            executionId,
+            seq,
+            iteration: iter,
+            error: errorObject(data.error),
+            recoverable: true
+          })
+        ];
+      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 legacy event.
+      default:
+        return [];
+    }
+  };
+}
+function errorMessage(error) {
+  if (typeof error === "string") return error;
+  if (error && typeof error === "object" && "message" in error) {
+    const message = error.message;
+    if (typeof message === "string") return message;
+  }
+  return error === void 0 ? "Agent execution failed" : JSON.stringify(error);
+}
+function errorObject(error) {
+  if (typeof error === "string") return { code: "error", message: error };
+  if (error && typeof error === "object") {
+    const e = error;
+    const obj = { code: e.code ?? "error", message: e.message ?? "" };
+    if (e.details !== void 0) obj.details = e.details;
+    return obj;
+  }
+  return { code: "error", message: String(error) };
+}
+
 // src/stream-utils.ts
 function parseSSEChunk(chunk, buffer) {
   buffer += chunk;
@@ -191,7 +697,7 @@ function parseFinalBuffer(buffer) {
   }
   return null;
 }
-async function processStream(response, callbacks = {}) {
+async function processStream(response, callbacks = {}, options = {}) {
   if (!response.ok) {
     const error = new Error(`HTTP ${response.status}: ${response.statusText}`);
     callbacks.onError?.(error);
@@ -215,6 +721,20 @@ async function processStream(response, callbacks = {}) {
     executionTime: 0,
     success: true
   };
+  let translate = options.unified === true ? createFlowEventTranslator() : null;
+  const autoDetect = options.unified === void 0;
+  const dispatch = (parsed) => {
+    if (autoDetect && !translate && isUnifiedEventType(parsed?.type)) {
+      translate = createFlowEventTranslator();
+    }
+    if (translate) {
+      for (const ev of translate(parsed)) {
+        handleEvent(ev, callbacks, results, flowSummary);
+      }
+    } else {
+      handleEvent(parsed, callbacks, results, flowSummary);
+    }
+  };
   const contentType = response.headers.get("content-type");
   if (contentType?.includes("application/json")) {
     try {
@@ -271,8 +791,7 @@ async function processStream(response, callbacks = {}) {
       buffer = remainingBuffer;
       for (const eventStr of events) {
         try {
-          const event = JSON.parse(eventStr);
-          handleEvent(event, callbacks, results, flowSummary);
+          dispatch(JSON.parse(eventStr));
         } catch {
           console.warn("Failed to parse SSE event:", eventStr);
         }
@@ -281,8 +800,7 @@ async function processStream(response, callbacks = {}) {
     const finalEvent = parseFinalBuffer(buffer);
     if (finalEvent) {
       try {
-        const event = JSON.parse(finalEvent);
-        handleEvent(event, callbacks, results, flowSummary);
+        dispatch(JSON.parse(finalEvent));
       } catch {
       }
     }
@@ -352,10 +870,17 @@ function handleEvent(event, callbacks, results, summary) {
       break;
   }
 }
-async function* streamEvents(response) {
+async function* streamEvents(response, options = {}) {
   if (!response.ok) {
     throw new Error(`HTTP ${response.status}: ${response.statusText}`);
   }
+  let translate = options.unified === true ? createFlowEventTranslator() : null;
+  const autoDetect = options.unified === void 0;
+  const maybeDetect = (parsed) => {
+    if (autoDetect && !translate && isUnifiedEventType(parsed?.type)) {
+      translate = createFlowEventTranslator();
+    }
+  };
   const contentType = response.headers.get("content-type");
   if (contentType?.includes("application/json")) {
     try {
@@ -385,19 +910,35 @@ async function* streamEvents(response) {
       const { events, remainingBuffer } = parseSSEChunk(chunk, buffer);
       buffer = remainingBuffer;
       for (const eventStr of events) {
+        let parsed;
         try {
-          const event = JSON.parse(eventStr);
-          yield event;
+          parsed = JSON.parse(eventStr);
         } catch {
+          continue;
+        }
+        maybeDetect(parsed);
+        if (translate) {
+          for (const ev of translate(parsed)) yield ev;
+        } else {
+          yield parsed;
         }
       }
     }
     const finalEvent = parseFinalBuffer(buffer);
     if (finalEvent) {
+      let parsed;
       try {
-        const event = JSON.parse(finalEvent);
-        yield event;
+        parsed = JSON.parse(finalEvent);
       } catch {
+        parsed = void 0;
+      }
+      if (parsed !== void 0) {
+        maybeDetect(parsed);
+        if (translate) {
+          for (const ev of translate(parsed)) yield ev;
+        } else {
+          yield parsed;
+        }
       }
     }
   } finally {
@@ -407,10 +948,16 @@ async function* streamEvents(response) {
 
 // src/flow-result.ts
 var FlowResult = class {
-  constructor(response, summary) {
+  /**
+   * @param options.unified - The response is a unified-vocabulary SSE stream
+   *   (`/dispatch` since the unified-SSE cutover). Set by dispatch call sites;
+   *   left unset by still-legacy producers (`/prompts/{id}/run`, eval stream).
+   */
+  constructor(response, summary, options = {}) {
     this.consumed = false;
     this.cachedSummary = null;
     this.response = response;
+    this.streamOptions = options;
     if (summary) {
       this.cachedSummary = summary;
       this.consumed = true;
@@ -463,7 +1010,7 @@ var FlowResult = class {
     }
     this.ensureNotConsumed();
     this.consumed = true;
-    this.cachedSummary = await processStream(this.response, callbacks);
+    this.cachedSummary = await processStream(this.response, callbacks, this.streamOptions);
     return this.cachedSummary;
   }
   /**
@@ -1309,9 +1856,9 @@ var FlowBuilder = class {
     }
     const response = await client.dispatch(config);
     if (callbacks) {
-      return processStream(response, callbacks);
+      return processStream(response, callbacks, { unified: true });
     }
-    return new FlowResult(response);
+    return new FlowResult(response, void 0, { unified: true });
   }
   /**
    * Set a run condition (when predicate) on the last added step.
@@ -1443,9 +1990,9 @@ var ClientFlowBuilder = class extends FlowBuilder {
     }
     const response = await dispatchClient.dispatch(config);
     if (runCallbacks) {
-      return processStream(response, runCallbacks);
+      return processStream(response, runCallbacks, { unified: true });
     }
-    return new FlowResult(response);
+    return new FlowResult(response, void 0, { unified: true });
   }
 };
 function isStreamCallbacks(obj) {
@@ -2463,7 +3010,7 @@ var RuntypeFlowBuilder = class {
     config.options = { ...config.options, streamResponse: true };
     const client = this.getClient();
     const response = await this.dispatchWithPersistedFlow(client, config);
-    const result = new FlowResult(response);
+    const result = new FlowResult(response, void 0, { unified: true });
     if (callbacks) {
       await result.stream(callbacks);
     }
@@ -2492,7 +3039,7 @@ var RuntypeFlowBuilder = class {
     config.options = { ...config.options, streamResponse: true };
     const client = this.getClient();
     const response = await this.dispatchWithPersistedFlow(client, config);
-    const result = new FlowResult(response);
+    const result = new FlowResult(response, void 0, { unified: true });
     await result.getSummary();
     return result;
   }
@@ -2527,7 +3074,7 @@ var RuntypeFlowBuilder = class {
           onError: (error) => callbacks?.onError?.(error)
         };
         try {
-          for await (const event of streamEvents(response)) {
+          for await (const event of streamEvents(response, { unified: true })) {
             collectLocalToolAwait(pausedTools, event);
             switch (event.type) {
               case "flow_start":
@@ -2635,7 +3182,7 @@ var RuntypeFlowBuilder = class {
             streamResponse: isStreaming
           };
           if (isStreaming) {
-            currentResponse = await client.requestStream("/dispatch/resume", {
+            currentResponse = await client.requestStream(withUnifiedEvents("/dispatch/resume"), {
               method: "POST",
               body: JSON.stringify(resumeData)
             });
@@ -4426,13 +4973,17 @@ function defineFpo(fpo) {
   return fpo;
 }
 async function ensureFpo(client, fpo, options = {}) {
-  const { dryRun, onConflict } = options;
+  const { dryRun, onConflict, prune } = options;
   return client.post("/products/ensure-fpo", {
     fpo,
     ...dryRun ? { dryRun: true } : {},
-    ...onConflict ? { onConflict } : {}
+    ...onConflict ? { onConflict } : {},
+    ...prune ? { prune: true } : {}
   });
 }
+async function pullFpo(client, name) {
+  return client.get("/products/pull-fpo", { name });
+}
 
 // src/products-namespace.ts
 var ProductsNamespace = class {
@@ -4490,6 +5041,24 @@ var ProductsNamespace = class {
   async ensureFpo(fpo, options = {}) {
     return ensureFpo(this.getClient(), fpo, options);
   }
+  /**
+   * Reconstruct a self-contained Full Product Object from the live product graph
+   * (resolved by name) — the absorb-drift direction of `ensureFpo`. Feeding the
+   * returned `fpo` back into `ensureFpo` converges to `unchanged`.
+   *
+   * records/schedules/secrets are not reconstructed and `tools` is emitted empty
+   * (tool refs are portable `tool:<name>`); inspect `result.warnings` for
+   * per-pull caveats.
+   *
+   * @example
+   * ```typescript
+   * const { fpo } = await Runtype.products.pullFpo('Support Copilot')
+   * await Runtype.products.ensureFpo(fpo, { dryRun: true }) // → result: 'unchanged'
+   * ```
+   */
+  async pullFpo(name) {
+    return pullFpo(this.getClient(), name);
+  }
 };
 
 // src/surfaces-ensure.ts
@@ -4857,7 +5426,7 @@ var RuntypeClient = class {
    * Dispatch flow execution (streaming)
    */
   async dispatch(config) {
-    return this.requestStream("/dispatch", {
+    return this.requestStream(withUnifiedEvents("/dispatch"), {
       method: "POST",
       body: JSON.stringify(transformRequest(config))
     });
@@ -5228,7 +5797,7 @@ var Runtype = class {
 
 // src/version.ts
 var FALLBACK_VERSION = "0.0.0";
-var SDK_VERSION = "4.19.2".length > 0 ? "4.19.2" : FALLBACK_VERSION;
+var SDK_VERSION = "4.21.0".length > 0 ? "4.21.0" : FALLBACK_VERSION;
 var RUNTYPE_CLIENT_KIND = "sdk";
 var SDK_USER_AGENT = `runtype-sdk/${SDK_VERSION} (typescript)`;
 
@@ -7722,7 +8291,7 @@ var DispatchEndpoint = class {
    * Dispatch with streaming response
    */
   async executeStream(data) {
-    return this.client.requestStream("/dispatch", {
+    return this.client.requestStream(withUnifiedEvents("/dispatch"), {
       method: "POST",
       body: JSON.stringify(data)
     });
@@ -7738,7 +8307,7 @@ var DispatchEndpoint = class {
    */
   async resume(data) {
     if (data.streamResponse) {
-      return this.client.requestStream("/dispatch/resume", {
+      return this.client.requestStream(withUnifiedEvents("/dispatch/resume"), {
         method: "POST",
         body: JSON.stringify(data)
       });
@@ -8253,6 +8822,19 @@ async function processAgentStream(body, callbacks) {
   const reader = body.getReader();
   const decoder = new TextDecoder();
   let buffer = "";
+  let translate = null;
+  const dispatch = (event) => {
+    if (!translate && isUnifiedEventType(event.data?.type ?? event.eventType)) {
+      translate = createAgentEventTranslator();
+    }
+    if (translate) {
+      for (const legacy of translate(event.data)) {
+        dispatchAgentEvent({ eventType: legacy.type, data: legacy }, callbacks);
+      }
+    } else {
+      dispatchAgentEvent(event, callbacks);
+    }
+  };
   try {
     while (true) {
       const { done, value } = await reader.read();
@@ -8260,7 +8842,7 @@ async function processAgentStream(body, callbacks) {
         if (buffer.trim()) {
           const { events: events2 } = parseSSEChunkWithEventType(buffer + "\n\n", "");
           for (const event of events2) {
-            dispatchAgentEvent(event, callbacks);
+            dispatch(event);
           }
         }
         break;
@@ -8269,7 +8851,7 @@ async function processAgentStream(body, callbacks) {
       const { events, remainingBuffer } = parseSSEChunkWithEventType(chunk, buffer);
       buffer = remainingBuffer;
       for (const event of events) {
-        dispatchAgentEvent(event, callbacks);
+        dispatch(event);
       }
     }
   } finally {
@@ -8457,7 +9039,7 @@ var _AgentsEndpoint = class _AgentsEndpoint {
    * ```
    */
   async executeStream(id, data, init) {
-    return this.client.requestStream(`/agents/${id}/execute`, {
+    return this.client.requestStream(withUnifiedEvents(`/agents/${id}/execute`), {
       method: "POST",
       body: JSON.stringify({
         ...data,
@@ -8809,16 +9391,19 @@ var _AgentsEndpoint = class _AgentsEndpoint {
         }
         let resumeResponse;
         try {
-          resumeResponse = await this.client.requestStream(`/agents/${id}/resume`, {
-            method: "POST",
-            body: JSON.stringify({
-              executionId,
-              toolOutputs: { [toolName]: toolResult },
-              streamResponse: true,
-              debugMode: data.debugMode
-            }),
-            ...abortSignal ? { signal: abortSignal } : {}
-          });
+          resumeResponse = await this.client.requestStream(
+            withUnifiedEvents(`/agents/${id}/resume`),
+            {
+              method: "POST",
+              body: JSON.stringify({
+                executionId,
+                toolOutputs: { [toolName]: toolResult },
+                streamResponse: true,
+                debugMode: data.debugMode
+              }),
+              ...abortSignal ? { signal: abortSignal } : {}
+            }
+          );
         } catch (error) {
           if (abortSignal?.aborted) return finishAborted(executionId);
           throw error;
@@ -10283,9 +10868,9 @@ var _AgentsEndpoint = class _AgentsEndpoint {
   }
   /** Returns true if a server-side session error message indicates a transient
    *  network failure that is safe to retry. */
-  static isRetryableSessionError(errorMessage) {
-    if (!errorMessage) return false;
-    const lower = errorMessage.toLowerCase();
+  static isRetryableSessionError(errorMessage2) {
+    if (!errorMessage2) return false;
+    const lower = errorMessage2.toLowerCase();
     return _AgentsEndpoint.RETRYABLE_SESSION_ERROR_PATTERNS.some(
       (pattern) => lower.includes(pattern)
     );
@@ -11737,7 +12322,7 @@ var RuntypeClient2 = class {
           success: true
         };
         try {
-          for await (const event of streamEvents(response)) {
+          for await (const event of streamEvents(response, { unified: true })) {
             collectLocalToolAwait(pausedTools, event);
             switch (event.type) {
               case "flow_start":
@@ -12921,6 +13506,7 @@ var STEP_TYPE_TO_METHOD = {
   ToolEnsureConflictError,
   ToolsEndpoint,
   ToolsNamespace,
+  UNIFIED_EVENTS_QUERY,
   UsersEndpoint,
   applyGeneratedRuntimeToolProposalToDispatchRequest,
   attachRuntimeToolsToDispatchRequest,
@@ -12937,8 +13523,10 @@ var STEP_TYPE_TO_METHOD = {
   computeSkillContentHash,
   computeSurfaceContentHash,
   computeToolContentHash,
+  createAgentEventTranslator,
   createClient,
   createExternalTool,
+  createFlowEventTranslator,
   defaultWorkflow,
   defaultWorkflowConfig,
   defineAgent,
@@ -12961,6 +13549,7 @@ var STEP_TYPE_TO_METHOD = {
   isDiscoveryToolName,
   isMarathonArtifactPath,
   isPreservationSensitiveTask,
+  isUnifiedEventType,
   isWorkflowHookRef,
   listWorkflowHooks,
   normalizeAgentDefinition,
@@ -12975,6 +13564,7 @@ var STEP_TYPE_TO_METHOD = {
   parseOffloadedOutputId,
   parseSSEChunk,
   processStream,
+  pullFpo,
   registerWorkflowHook,
   resolveStallStopAfter,
   resolveWorkflowHook,
@@ -12982,5 +13572,6 @@ var STEP_TYPE_TO_METHOD = {
   shouldInjectEmptySessionNudge,
   shouldRequestModelEscalation,
   streamEvents,
-  unregisterWorkflowHook
+  unregisterWorkflowHook,
+  withUnifiedEvents
 });