@runtypelabs/sdk 4.20.0 → 5.0.0

package/dist/index.cjs

@@ -60,7 +60,6 @@ __export(index_exports, {
   ProductDriftError: () => ProductDriftError,
   ProductEnsureConflictError: () => ProductEnsureConflictError,
   ProductsNamespace: () => ProductsNamespace,
-  PromptRunner: () => PromptRunner,
   PromptsEndpoint: () => PromptsEndpoint,
   PromptsNamespace: () => PromptsNamespace,
   ProviderKeysEndpoint: () => ProviderKeysEndpoint,
@@ -89,6 +88,7 @@ __export(index_exports, {
   ToolEnsureConflictError: () => ToolEnsureConflictError,
   ToolsEndpoint: () => ToolsEndpoint,
   ToolsNamespace: () => ToolsNamespace,
+  UNIFIED_EVENTS_QUERY: () => UNIFIED_EVENTS_QUERY,
   UsersEndpoint: () => UsersEndpoint,
   applyGeneratedRuntimeToolProposalToDispatchRequest: () => applyGeneratedRuntimeToolProposalToDispatchRequest,
   attachRuntimeToolsToDispatchRequest: () => attachRuntimeToolsToDispatchRequest,
@@ -105,8 +105,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 +131,7 @@ __export(index_exports, {
   isDiscoveryToolName: () => isDiscoveryToolName,
   isMarathonArtifactPath: () => isMarathonArtifactPath,
   isPreservationSensitiveTask: () => isPreservationSensitiveTask,
+  isUnifiedEventType: () => isUnifiedEventType,
   isWorkflowHookRef: () => isWorkflowHookRef,
   listWorkflowHooks: () => listWorkflowHooks,
   normalizeAgentDefinition: () => normalizeAgentDefinition,
@@ -151,10 +154,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;
@@ -192,7 +696,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);
@@ -216,6 +720,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 {
@@ -272,8 +790,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);
         }
@@ -282,8 +799,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 {
       }
     }
@@ -353,10 +869,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 {
@@ -386,19 +909,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 {
@@ -408,10 +947,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 the still-legacy eval stream producer.
+   */
+  constructor(response, summary, options = {}) {
     this.consumed = false;
     this.cachedSummary = null;
     this.response = response;
+    this.streamOptions = options;
     if (summary) {
       this.cachedSummary = summary;
       this.consumed = true;
@@ -464,7 +1009,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;
   }
   /**
@@ -488,6 +1033,7 @@ var FlowResult = class {
    * const analysis = await result.getResult('analyze screenshot')  // ✗ undefined
    * ```
    */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- SDK step results are intentionally untyped (FlowSummary.results is Map<string, any>); consumers narrow at the use site
   async getResult(stepName) {
     const summary = await this.ensureSummary();
     if (summary.results.has(stepName)) {
@@ -508,6 +1054,7 @@ var FlowResult = class {
    * }
    * ```
    */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- SDK step results are intentionally untyped (FlowSummary.results is Map<string, any>); consumers narrow at the use site
   async getAllResults() {
     const summary = await this.ensureSummary();
     return summary.results;
@@ -1310,9 +1857,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.
@@ -1444,9 +1991,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) {
@@ -2464,7 +3011,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);
     }
@@ -2493,7 +3040,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;
   }
@@ -2528,7 +3075,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":
@@ -2636,7 +3183,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)
             });
@@ -3069,138 +3616,10 @@ var EvalsNamespace = class {
 };
 
 // src/prompts-namespace.ts
-var PromptRunner = class {
-  constructor(getClient, promptId, options) {
-    this.getClient = getClient;
-    this.promptId = promptId;
-    this.options = options;
-  }
-  /**
-   * Execute the prompt with streaming response
-   *
-   * Streams the prompt response as it's generated.
-   *
-   * @example
-   * ```typescript
-   * const result = await Runtype.prompts.run('prompt_123', {
-   *   recordId: 'rec_456'
-   * }).stream()
-   *
-   * // Process with callbacks
-   * await result.stream({
-   *   onStepDelta: (text) => process.stdout.write(text),
-   *   onFlowComplete: () => console.log('Done!'),
-   * })
-   * ```
-   */
-  async stream(callbacks) {
-    const client = this.getClient();
-    const payload = this.buildPayload();
-    payload.stream = true;
-    const response = await client.requestStream(`/prompts/${this.promptId}/run`, {
-      method: "POST",
-      body: JSON.stringify(payload)
-    });
-    const result = new FlowResult(response);
-    if (callbacks) {
-      await result.stream(callbacks);
-    }
-    return result;
-  }
-  /**
-   * Execute the prompt and wait for complete result
-   *
-   * Waits for the entire response before returning.
-   *
-   * @example
-   * ```typescript
-   * const result = await Runtype.prompts.run('prompt_123', {
-   *   recordId: 'rec_456'
-   * }).result()
-   *
-   * const output = await result.getResult('prompt')
-   * console.log(output)
-   * ```
-   */
-  async result() {
-    const client = this.getClient();
-    const payload = this.buildPayload();
-    payload.stream = true;
-    const response = await client.requestStream(`/prompts/${this.promptId}/run`, {
-      method: "POST",
-      body: JSON.stringify(payload)
-    });
-    const result = new FlowResult(response);
-    await result.getSummary();
-    return result;
-  }
-  /**
-   * Build the run payload
-   */
-  buildPayload() {
-    const payload = {};
-    if (this.options.recordId) {
-      payload.recordId = this.options.recordId;
-    } else if (this.options.record) {
-      payload.record = this.options.record;
-    }
-    if (this.options.modelOverride) {
-      payload.modelOverride = this.options.modelOverride;
-    }
-    if (this.options.temperature !== void 0) {
-      payload.temperature = this.options.temperature;
-    }
-    if (this.options.topP !== void 0) {
-      payload.topP = this.options.topP;
-    }
-    if (this.options.topK !== void 0) {
-      payload.topK = this.options.topK;
-    }
-    if (this.options.frequencyPenalty !== void 0) {
-      payload.frequencyPenalty = this.options.frequencyPenalty;
-    }
-    if (this.options.presencePenalty !== void 0) {
-      payload.presencePenalty = this.options.presencePenalty;
-    }
-    if (this.options.seed !== void 0) {
-      payload.seed = this.options.seed;
-    }
-    if (this.options.maxTokens !== void 0) {
-      payload.maxTokens = this.options.maxTokens;
-    }
-    if (this.options.storeResult !== void 0) {
-      payload.storeResult = this.options.storeResult;
-    }
-    return payload;
-  }
-};
 var PromptsNamespace = class {
   constructor(getClient) {
     this.getClient = getClient;
   }
-  /**
-   * Run a prompt
-   *
-   * Returns a PromptRunner with terminal methods:
-   * - .stream() - Execute and stream results
-   * - .result() - Execute and wait for complete result
-   *
-   * @example
-   * ```typescript
-   * // Stream the response
-   * const result = await Runtype.prompts.run('prompt_123', {
-   *   recordId: 'rec_456'
-   * }).stream()
-   *
-   * // Get complete result
-   * const result = await Runtype.prompts.run('prompt_123', {
-   *   record: { name: 'Test', metadata: { input: 'Hello' } }
-   * }).result()
-   * ```
-   */
-  run(promptId, options = {}) {
-    return new PromptRunner(this.getClient, promptId, options);
-  }
   /**
    * Create a new prompt
    *
@@ -4880,7 +5299,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))
     });
@@ -5251,7 +5670,7 @@ var Runtype = class {
 
 // src/version.ts
 var FALLBACK_VERSION = "0.0.0";
-var SDK_VERSION = "4.20.0".length > 0 ? "4.20.0" : FALLBACK_VERSION;
+var SDK_VERSION = "5.0.0".length > 0 ? "5.0.0" : FALLBACK_VERSION;
 var RUNTYPE_CLIENT_KIND = "sdk";
 var SDK_USER_AGENT = `runtype-sdk/${SDK_VERSION} (typescript)`;
 
@@ -7374,12 +7793,6 @@ var PromptsEndpoint = class {
   async delete(id) {
     return this.client.delete(`/prompts/${id}`);
   }
-  /**
-   * Run a prompt on a specific record
-   */
-  async runOnRecord(id, recordId) {
-    return this.client.post(`/prompts/${id}/run-on-record`, { recordId });
-  }
   /**
    * Get flows using this prompt
    */
@@ -7745,7 +8158,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)
     });
@@ -7761,7 +8174,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)
       });
@@ -8276,6 +8689,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();
@@ -8283,7 +8709,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;
@@ -8292,7 +8718,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 {
@@ -8480,7 +8906,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,
@@ -8832,16 +9258,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;
@@ -10306,9 +10735,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)
     );
@@ -11760,7 +12189,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":
@@ -12915,7 +13344,6 @@ var STEP_TYPE_TO_METHOD = {
   ProductDriftError,
   ProductEnsureConflictError,
   ProductsNamespace,
-  PromptRunner,
   PromptsEndpoint,
   PromptsNamespace,
   ProviderKeysEndpoint,
@@ -12944,6 +13372,7 @@ var STEP_TYPE_TO_METHOD = {
   ToolEnsureConflictError,
   ToolsEndpoint,
   ToolsNamespace,
+  UNIFIED_EVENTS_QUERY,
   UsersEndpoint,
   applyGeneratedRuntimeToolProposalToDispatchRequest,
   attachRuntimeToolsToDispatchRequest,
@@ -12960,8 +13389,10 @@ var STEP_TYPE_TO_METHOD = {
   computeSkillContentHash,
   computeSurfaceContentHash,
   computeToolContentHash,
+  createAgentEventTranslator,
   createClient,
   createExternalTool,
+  createFlowEventTranslator,
   defaultWorkflow,
   defaultWorkflowConfig,
   defineAgent,
@@ -12984,6 +13415,7 @@ var STEP_TYPE_TO_METHOD = {
   isDiscoveryToolName,
   isMarathonArtifactPath,
   isPreservationSensitiveTask,
+  isUnifiedEventType,
   isWorkflowHookRef,
   listWorkflowHooks,
   normalizeAgentDefinition,
@@ -13006,5 +13438,6 @@ var STEP_TYPE_TO_METHOD = {
   shouldInjectEmptySessionNudge,
   shouldRequestModelEscalation,
   streamEvents,
-  unregisterWorkflowHook
+  unregisterWorkflowHook,
+  withUnifiedEvents
 });