@mastra/react 0.1.0 → 0.2.0-alpha.0

package/dist/{index-ChvWx-iU.cjs → index-TEBHU8EU.cjs}

@@ -33,21 +33,22 @@ function _interopNamespaceDefault(e) {
 const z4__namespace = /*#__PURE__*/_interopNamespaceDefault(z4);
 
 const MastraClientContext = react.createContext({});
-const MastraClientProvider = ({ children, baseUrl, headers }) => {
-  const client = createMastraClient(baseUrl, headers);
+const MastraClientProvider = ({ children, baseUrl, headers, apiPrefix }) => {
+  const client = createMastraClient(baseUrl, headers, apiPrefix);
   return /* @__PURE__ */ jsxRuntime.jsx(MastraClientContext.Provider, { value: client, children });
 };
 const useMastraClient = () => react.useContext(MastraClientContext);
-const createMastraClient = (baseUrl, mastraClientHeaders = {}) => {
+const createMastraClient = (baseUrl, mastraClientHeaders = {}, apiPrefix) => {
   return new clientJs.MastraClient({
     baseUrl: baseUrl || "",
     // only add the header if the baseUrl is not provided i.e it's a local dev environment
-    headers: !baseUrl ? { ...mastraClientHeaders, "x-mastra-dev-playground": "true" } : mastraClientHeaders
+    headers: !baseUrl ? { ...mastraClientHeaders, "x-mastra-dev-playground": "true" } : mastraClientHeaders,
+    apiPrefix
   });
 };
 
-const MastraReactProvider = ({ children, baseUrl, headers }) => {
-  return /* @__PURE__ */ jsxRuntime.jsx(MastraClientProvider, { baseUrl, headers, children });
+const MastraReactProvider = ({ children, baseUrl, headers, apiPrefix }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(MastraClientProvider, { baseUrl, headers, apiPrefix, children });
 };
 
 const mapWorkflowStreamChunkToWatchResult = (prev, chunk) => {
@@ -966,6 +967,125 @@ const resolveToChildMessages = (messages) => {
   return childMessages;
 };
 
+// src/request-context/index.ts
+var RequestContext = class {
+  registry = /* @__PURE__ */ new Map();
+  constructor(iterable) {
+    this.registry = new Map(iterable);
+  }
+  /**
+   * set a value with strict typing if `Values` is a Record and the key exists in it.
+   */
+  set(key, value) {
+    this.registry.set(key, value);
+  }
+  /**
+   * Get a value with its type
+   */
+  get(key) {
+    return this.registry.get(key);
+  }
+  /**
+   * Check if a key exists in the container
+   */
+  has(key) {
+    return this.registry.has(key);
+  }
+  /**
+   * Delete a value by key
+   */
+  delete(key) {
+    return this.registry.delete(key);
+  }
+  /**
+   * Clear all values from the container
+   */
+  clear() {
+    this.registry.clear();
+  }
+  /**
+   * Get all keys in the container
+   */
+  keys() {
+    return this.registry.keys();
+  }
+  /**
+   * Get all values in the container
+   */
+  values() {
+    return this.registry.values();
+  }
+  /**
+   * Get all entries in the container.
+   * Returns a discriminated union of tuples for proper type narrowing when iterating.
+   */
+  entries() {
+    return this.registry.entries();
+  }
+  /**
+   * Get the size of the container
+   */
+  size() {
+    return this.registry.size;
+  }
+  /**
+   * Execute a function for each entry in the container.
+   * The callback receives properly typed key-value pairs.
+   */
+  forEach(callbackfn) {
+    this.registry.forEach(callbackfn);
+  }
+  /**
+   * Custom JSON serialization method.
+   * Converts the internal Map to a plain object for proper JSON serialization.
+   * Non-serializable values (e.g., RPC proxies, functions, circular references)
+   * are skipped to prevent serialization errors when storing to database.
+   */
+  toJSON() {
+    const result = {};
+    for (const [key, value] of this.registry.entries()) {
+      if (this.isSerializable(value)) {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  /**
+   * Check if a value can be safely serialized to JSON.
+   */
+  isSerializable(value) {
+    if (value === null || value === void 0) return true;
+    if (typeof value === "function") return false;
+    if (typeof value === "symbol") return false;
+    if (typeof value !== "object") return true;
+    try {
+      JSON.stringify(value);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get all values as a typed object for destructuring.
+   * Returns Record<string, any> when untyped, or the Values type when typed.
+   *
+   * @example
+   * ```typescript
+   * const ctx = new RequestContext<{ userId: string; apiKey: string }>();
+   * ctx.set('userId', 'user-123');
+   * ctx.set('apiKey', 'key-456');
+   * const { userId, apiKey } = ctx.all;
+   * ```
+   */
+  get all() {
+    return Object.fromEntries(this.registry);
+  }
+};
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
 var __create$3 = Object.create;
 var __defProp$5 = Object.defineProperty;
 var __getOwnPropDesc$3 = Object.getOwnPropertyDescriptor;
@@ -1033,7 +1153,7 @@ var __toESM$2 = (mod, isNodeMode, target) => (target = mod != null ? __create$2(
 
 // ../_vendored/ai_v5/dist/chunk-TLQKI65U.js
 var require_token_error = __commonJS$2({
-  "../../../node_modules/.pnpm/@vercel+oidc@3.0.5/node_modules/@vercel/oidc/dist/token-error.js"(exports, module) {
+  "../../../node_modules/.pnpm/@vercel+oidc@3.0.5/node_modules/@vercel/oidc/dist/token-error.js"(exports$1, module) {
     var __defProp2 = Object.defineProperty;
     var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
     var __getOwnPropNames2 = Object.getOwnPropertyNames;
@@ -3081,7 +3201,7 @@ function withoutTrailingSlash(url) {
 }
 
 var require_get_context = __commonJS$2({
-  "../../../node_modules/.pnpm/@vercel+oidc@3.0.5/node_modules/@vercel/oidc/dist/get-context.js"(exports, module) {
+  "../../../node_modules/.pnpm/@vercel+oidc@3.0.5/node_modules/@vercel/oidc/dist/get-context.js"(exports$1, module) {
     var __defProp2 = Object.defineProperty;
     var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
     var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -3113,7 +3233,7 @@ var require_get_context = __commonJS$2({
   }
 });
 var require_get_vercel_oidc_token = __commonJS$2({
-  "../../../node_modules/.pnpm/@vercel+oidc@3.0.5/node_modules/@vercel/oidc/dist/get-vercel-oidc-token.js"(exports, module) {
+  "../../../node_modules/.pnpm/@vercel+oidc@3.0.5/node_modules/@vercel/oidc/dist/get-vercel-oidc-token.js"(exports$1, module) {
     var __defProp2 = Object.defineProperty;
     var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
     var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -3149,8 +3269,8 @@ var require_get_vercel_oidc_token = __commonJS$2({
       }
       try {
         const [{ getTokenPayload, isExpired }, { refreshToken }] = await Promise.all([
-          await Promise.resolve().then(() => require('./token-util-NEHG7TUY-JRJTGTAB-BU9ZxL1w.cjs')),
-          await Promise.resolve().then(() => require('./token-6GSAFR2W-SPYPLMBM-CWoxKwfk.cjs'))
+          await Promise.resolve().then(() => require('./token-util-NEHG7TUY-U7CX7GS4-CfBW62uu.cjs')),
+          await Promise.resolve().then(() => require('./token-6GSAFR2W-XRCSVUPZ-DdTrjI2X.cjs'))
         ]);
         if (!token || isExpired(getTokenPayload(token))) {
           await refreshToken();
@@ -3177,7 +3297,7 @@ ${error.message}`;
   }
 });
 var require_dist = __commonJS$2({
-  "../../../node_modules/.pnpm/@vercel+oidc@3.0.5/node_modules/@vercel/oidc/dist/index.js"(exports, module) {
+  "../../../node_modules/.pnpm/@vercel+oidc@3.0.5/node_modules/@vercel/oidc/dist/index.js"(exports$1, module) {
     var __defProp2 = Object.defineProperty;
     var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
     var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -5773,7 +5893,7 @@ var __toESM$1 = (mod, isNodeMode, target) => (target = mod != null ? __create$1(
   mod
 ));
 var require_secure_json_parse$1 = __commonJS$1({
-  "../../../node_modules/.pnpm/secure-json-parse@2.7.0/node_modules/secure-json-parse/index.js"(exports, module) {
+  "../../../node_modules/.pnpm/secure-json-parse@2.7.0/node_modules/secure-json-parse/index.js"(exports$1, module) {
     var hasBuffer = typeof Buffer !== "undefined";
     var suspectProtoRx = /"(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])"\s*:/;
     var suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
@@ -11546,6 +11666,9 @@ function sanitizeV5UIMessages(messages, filterIncompleteToolCalls = false) {
   const msgs = messages.map((m) => {
     if (m.parts.length === 0) return false;
     const safeParts = m.parts.filter((p) => {
+      if (typeof p.type === "string" && p.type.startsWith("data-")) {
+        return false;
+      }
       if (!isToolUIPart(p)) return true;
       if (filterIncompleteToolCalls) {
         return p.state === "output-available" || p.state === "output-error";
@@ -12059,10 +12182,10 @@ var imageMediaTypeSignatures = [
 var stripID3 = (data) => {
   const bytes = typeof data === "string" ? convertBase64ToUint8Array(data) : data;
   const id3Size = (
-    // @ts-ignore
-    (bytes[6] & 127) << 21 | // @ts-ignore
-    (bytes[7] & 127) << 14 | // @ts-ignore
-    (bytes[8] & 127) << 7 | // @ts-ignore
+    // @ts-expect-error - bytes array access
+    (bytes[6] & 127) << 21 | // @ts-expect-error - bytes array access
+    (bytes[7] & 127) << 14 | // @ts-expect-error - bytes array access
+    (bytes[8] & 127) << 7 | // @ts-expect-error - bytes array access
     bytes[9] & 127
   );
   return bytes.slice(id3Size + 10);
@@ -12270,7 +12393,7 @@ function convertToV1Messages(messages) {
             role: "user",
             ...fields,
             type: "text",
-            // @ts-ignore
+            // @ts-expect-error - content type mismatch in conversion
             content: userContent
           });
         } else {
@@ -12941,7 +13064,7 @@ var MessageList$1 = class MessageList {
     threadId,
     resourceId,
     generateMessageId,
-    // @ts-ignore Flag for agent network messages
+    // @ts-expect-error Flag for agent network messages
     _agentNetworkAppend
   } = {}) {
     if (threadId) {
@@ -12997,6 +13120,31 @@ var MessageList$1 = class MessageList {
       agentNetworkAppend: this._agentNetworkAppend
     });
   }
+  /**
+   * Custom serialization for tracing/observability spans.
+   * Returns a clean representation with just the essential data,
+   * excluding internal state tracking, methods, and implementation details.
+   *
+   * This is automatically called by the span serialization system when
+   * a MessageList instance appears in span input/output/attributes.
+   */
+  serializeForSpan() {
+    const coreMessages = this.all.aiV4.core();
+    return {
+      messages: coreMessages.map((msg) => ({
+        role: msg.role,
+        content: msg.content
+      })),
+      systemMessages: [
+        // Untagged first (base instructions)
+        ...this.systemMessages.map((m) => ({ role: m.role, content: m.content })),
+        // Tagged after (contextual additions)
+        ...Object.entries(this.taggedSystemMessages).flatMap(
+          ([tag, msgs]) => msgs.map((m) => ({ role: m.role, content: m.content, tag }))
+        )
+      ]
+    };
+  }
   deserialize(state) {
     const data = this.stateManager.deserializeAll(state);
     this.messages = data.messages;
@@ -13533,10 +13681,6 @@ var MessageList$1 = class MessageList {
   }
 };
 
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
-
 new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
 
 // ../_vendored/ai_v4/dist/chunk-OPIPXJLE.js
@@ -13566,7 +13710,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var require_secure_json_parse = __commonJS({
-  "../../../node_modules/.pnpm/secure-json-parse@2.7.0/node_modules/secure-json-parse/index.js"(exports, module) {
+  "../../../node_modules/.pnpm/secure-json-parse@2.7.0/node_modules/secure-json-parse/index.js"(exports$1, module) {
     var hasBuffer = typeof Buffer !== "undefined";
     var suspectProtoRx = /"(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])"\s*:/;
     var suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
@@ -18992,7 +19136,7 @@ class LRUCache {
 
 // ../../node_modules/.pnpm/fast-deep-equal@3.1.3/node_modules/fast-deep-equal/index.js
 var require_fast_deep_equal = __commonJS$3({
-  "../../node_modules/.pnpm/fast-deep-equal@3.1.3/node_modules/fast-deep-equal/index.js"(exports, module) {
+  "../../node_modules/.pnpm/fast-deep-equal@3.1.3/node_modules/fast-deep-equal/index.js"(exports$1, module) {
     module.exports = function equal(a, b) {
       if (a === b) return true;
       if (a && b && typeof a == "object" && typeof b == "object") {
@@ -20644,6 +20788,428 @@ const MessageStreaming = ({ className, ...props }) => {
   return /* @__PURE__ */ jsxRuntime.jsx("span", { className: className || MessageStreamingClass, ...props });
 };
 
+function useMutation(mutationFn) {
+  const [isPending, setIsPending] = react.useState(false);
+  const [isSuccess, setIsSuccess] = react.useState(false);
+  const [isError, setIsError] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [data, setData] = react.useState(void 0);
+  const mutationFnRef = react.useRef(mutationFn);
+  mutationFnRef.current = mutationFn;
+  const reset = react.useCallback(() => {
+    setIsPending(false);
+    setIsSuccess(false);
+    setIsError(false);
+    setError(null);
+    setData(void 0);
+  }, []);
+  const mutateAsync = react.useCallback(async (variables) => {
+    setIsPending(true);
+    setIsSuccess(false);
+    setIsError(false);
+    setError(null);
+    try {
+      const result = await mutationFnRef.current(variables);
+      setData(result);
+      setIsSuccess(true);
+      return result;
+    } catch (err) {
+      const typedError = err;
+      setError(typedError);
+      setIsError(true);
+      throw err;
+    } finally {
+      setIsPending(false);
+    }
+  }, []);
+  const mutate = react.useCallback(
+    (variables) => {
+      mutateAsync(variables).catch(() => {
+      });
+    },
+    [mutateAsync]
+  );
+  return {
+    mutate,
+    mutateAsync,
+    isPending,
+    isSuccess,
+    isError,
+    error,
+    data,
+    reset
+  };
+}
+
+function useStreamWorkflow({ debugMode, tracingOptions, onError }) {
+  const client = useMastraClient();
+  const [streamResult, setStreamResult] = react.useState({});
+  const [isStreaming, setIsStreaming] = react.useState(false);
+  const readerRef = react.useRef(null);
+  const observerRef = react.useRef(null);
+  const resumeStreamRef = react.useRef(null);
+  const timeTravelStreamRef = react.useRef(null);
+  const isMountedRef = react.useRef(true);
+  react.useEffect(() => {
+    isMountedRef.current = true;
+    return () => {
+      isMountedRef.current = false;
+      if (readerRef.current) {
+        try {
+          readerRef.current.releaseLock();
+        } catch (error) {
+        }
+        readerRef.current = null;
+      }
+      if (observerRef.current) {
+        try {
+          observerRef.current.releaseLock();
+        } catch (error) {
+        }
+        observerRef.current = null;
+      }
+      if (resumeStreamRef.current) {
+        try {
+          resumeStreamRef.current.releaseLock();
+        } catch (error) {
+        }
+        resumeStreamRef.current = null;
+      }
+      if (timeTravelStreamRef.current) {
+        try {
+          timeTravelStreamRef.current.releaseLock();
+        } catch (error) {
+        }
+        timeTravelStreamRef.current = null;
+      }
+    };
+  }, []);
+  const handleStreamError = react.useCallback(
+    (err, defaultMessage, setStreamingState) => {
+      if (err instanceof TypeError) {
+        return;
+      }
+      const error = err instanceof Error ? err : new Error(defaultMessage);
+      onError?.(error, defaultMessage);
+      setStreamingState?.(false);
+    },
+    [onError]
+  );
+  const handleWorkflowFinish = react.useCallback((value) => {
+    if (value.type === "workflow-finish") {
+      const streamStatus = value.payload?.workflowStatus;
+      const metadata = value.payload?.metadata;
+      setStreamResult((prev) => ({
+        ...prev,
+        status: streamStatus
+      }));
+      if (streamStatus === "failed") {
+        throw new Error(metadata?.errorMessage || "Workflow execution failed");
+      }
+    }
+  }, []);
+  const streamWorkflow = useMutation(
+    async ({ workflowId, runId, inputData, initialState, requestContext: playgroundRequestContext, perStep }) => {
+      if (readerRef.current) {
+        readerRef.current.releaseLock();
+      }
+      if (!isMountedRef.current) return;
+      setIsStreaming(true);
+      setStreamResult({ input: inputData });
+      const requestContext = new RequestContext();
+      Object.entries(playgroundRequestContext).forEach(([key, value]) => {
+        requestContext.set(key, value);
+      });
+      const workflow = client.getWorkflow(workflowId);
+      const run = await workflow.createRun({ runId });
+      const stream = await run.stream({
+        inputData,
+        initialState,
+        requestContext,
+        closeOnSuspend: true,
+        tracingOptions,
+        perStep: perStep ?? debugMode
+      });
+      if (!stream) {
+        return handleStreamError(new Error("No stream returned"), "No stream returned", setIsStreaming);
+      }
+      const reader = stream.getReader();
+      readerRef.current = reader;
+      try {
+        while (true) {
+          if (!isMountedRef.current) break;
+          const { done, value } = await reader.read();
+          if (done) break;
+          if (isMountedRef.current) {
+            setStreamResult((prev) => {
+              const newResult = mapWorkflowStreamChunkToWatchResult(prev, value);
+              return newResult;
+            });
+            if (value.type === "workflow-step-start") {
+              setIsStreaming(true);
+            }
+            if (value.type === "workflow-step-suspended") {
+              setIsStreaming(false);
+            }
+            if (value.type === "workflow-finish") {
+              handleWorkflowFinish(value);
+            }
+          }
+        }
+      } catch (err) {
+        handleStreamError(err, "Error streaming workflow");
+      } finally {
+        if (isMountedRef.current) {
+          setIsStreaming(false);
+        }
+        if (readerRef.current) {
+          readerRef.current.releaseLock();
+          readerRef.current = null;
+        }
+      }
+    }
+  );
+  const observeWorkflowStream = useMutation(
+    async ({ workflowId, runId, storeRunResult }) => {
+      if (observerRef.current) {
+        observerRef.current.releaseLock();
+      }
+      if (!isMountedRef.current) return;
+      setIsStreaming(true);
+      setStreamResult(storeRunResult || {});
+      if (storeRunResult?.status === "suspended") {
+        setIsStreaming(false);
+        return;
+      }
+      const workflow = client.getWorkflow(workflowId);
+      const run = await workflow.createRun({ runId });
+      const stream = await run.observeStream();
+      if (!stream) {
+        return handleStreamError(new Error("No stream returned"), "No stream returned", setIsStreaming);
+      }
+      const reader = stream.getReader();
+      observerRef.current = reader;
+      try {
+        while (true) {
+          if (!isMountedRef.current) break;
+          const { done, value } = await reader.read();
+          if (done) break;
+          if (isMountedRef.current) {
+            setStreamResult((prev) => {
+              const newResult = mapWorkflowStreamChunkToWatchResult(prev, value);
+              return newResult;
+            });
+            if (value.type === "workflow-step-start") {
+              setIsStreaming(true);
+            }
+            if (value.type === "workflow-step-suspended") {
+              setIsStreaming(false);
+            }
+            if (value.type === "workflow-finish") {
+              handleWorkflowFinish(value);
+            }
+          }
+        }
+      } catch (err) {
+        handleStreamError(err, "Error observing workflow");
+      } finally {
+        if (isMountedRef.current) {
+          setIsStreaming(false);
+        }
+        if (observerRef.current) {
+          observerRef.current.releaseLock();
+          observerRef.current = null;
+        }
+      }
+    }
+  );
+  const resumeWorkflowStream = useMutation(
+    async ({ workflowId, runId, step, resumeData, requestContext: playgroundRequestContext, perStep }) => {
+      if (resumeStreamRef.current) {
+        resumeStreamRef.current.releaseLock();
+      }
+      if (!isMountedRef.current) return;
+      setIsStreaming(true);
+      const workflow = client.getWorkflow(workflowId);
+      const requestContext = new RequestContext();
+      Object.entries(playgroundRequestContext).forEach(([key, value]) => {
+        requestContext.set(key, value);
+      });
+      const run = await workflow.createRun({ runId });
+      const stream = await run.resumeStream({
+        step,
+        resumeData,
+        requestContext,
+        tracingOptions,
+        perStep: perStep ?? debugMode
+      });
+      if (!stream) {
+        return handleStreamError(new Error("No stream returned"), "No stream returned", setIsStreaming);
+      }
+      const reader = stream.getReader();
+      resumeStreamRef.current = reader;
+      try {
+        while (true) {
+          if (!isMountedRef.current) break;
+          const { done, value } = await reader.read();
+          if (done) break;
+          if (isMountedRef.current) {
+            setStreamResult((prev) => {
+              const newResult = mapWorkflowStreamChunkToWatchResult(prev, value);
+              return newResult;
+            });
+            if (value.type === "workflow-step-start") {
+              setIsStreaming(true);
+            }
+            if (value.type === "workflow-step-suspended") {
+              setIsStreaming(false);
+            }
+            if (value.type === "workflow-finish") {
+              handleWorkflowFinish(value);
+            }
+          }
+        }
+      } catch (err) {
+        handleStreamError(err, "Error resuming workflow stream");
+      } finally {
+        if (isMountedRef.current) {
+          setIsStreaming(false);
+        }
+        if (resumeStreamRef.current) {
+          resumeStreamRef.current.releaseLock();
+          resumeStreamRef.current = null;
+        }
+      }
+    }
+  );
+  const timeTravelWorkflowStream = useMutation(
+    async ({ workflowId, requestContext: playgroundRequestContext, runId, perStep, ...params }) => {
+      if (timeTravelStreamRef.current) {
+        timeTravelStreamRef.current.releaseLock();
+      }
+      if (!isMountedRef.current) return;
+      setIsStreaming(true);
+      const workflow = client.getWorkflow(workflowId);
+      const requestContext = new RequestContext();
+      Object.entries(playgroundRequestContext).forEach(([key, value]) => {
+        requestContext.set(key, value);
+      });
+      const run = await workflow.createRun({ runId });
+      const stream = await run.timeTravelStream({
+        ...params,
+        perStep: perStep ?? debugMode,
+        requestContext,
+        tracingOptions
+      });
+      if (!stream) {
+        return handleStreamError(new Error("No stream returned"), "No stream returned", setIsStreaming);
+      }
+      const reader = stream.getReader();
+      timeTravelStreamRef.current = reader;
+      try {
+        while (true) {
+          if (!isMountedRef.current) break;
+          const { done, value } = await reader.read();
+          if (done) break;
+          if (isMountedRef.current) {
+            setStreamResult((prev) => {
+              const newResult = mapWorkflowStreamChunkToWatchResult(prev, value);
+              return newResult;
+            });
+            if (value.type === "workflow-step-start") {
+              setIsStreaming(true);
+            }
+            if (value.type === "workflow-step-suspended") {
+              setIsStreaming(false);
+            }
+            if (value.type === "workflow-finish") {
+              handleWorkflowFinish(value);
+            }
+          }
+        }
+      } catch (err) {
+        handleStreamError(err, "Error time traveling workflow stream");
+      } finally {
+        if (isMountedRef.current) {
+          setIsStreaming(false);
+        }
+        if (timeTravelStreamRef.current) {
+          timeTravelStreamRef.current.releaseLock();
+          timeTravelStreamRef.current = null;
+        }
+      }
+    }
+  );
+  const closeStreamsAndReset = react.useCallback(() => {
+    setIsStreaming(false);
+    setStreamResult({});
+    if (readerRef.current) {
+      try {
+        readerRef.current.releaseLock();
+      } catch (error) {
+      }
+      readerRef.current = null;
+    }
+    if (observerRef.current) {
+      try {
+        observerRef.current.releaseLock();
+      } catch (error) {
+      }
+      observerRef.current = null;
+    }
+    if (resumeStreamRef.current) {
+      try {
+        resumeStreamRef.current.releaseLock();
+      } catch (error) {
+      }
+      resumeStreamRef.current = null;
+    }
+    if (timeTravelStreamRef.current) {
+      try {
+        timeTravelStreamRef.current.releaseLock();
+      } catch (error) {
+      }
+      timeTravelStreamRef.current = null;
+    }
+  }, []);
+  return {
+    streamWorkflow,
+    streamResult,
+    isStreaming,
+    observeWorkflowStream,
+    closeStreamsAndReset,
+    resumeWorkflowStream,
+    timeTravelWorkflowStream
+  };
+}
+
+function useCreateWorkflowRun() {
+  const client = useMastraClient();
+  return useMutation(async ({ workflowId, prevRunId }) => {
+    try {
+      const workflow = client.getWorkflow(workflowId);
+      const { runId: newRunId } = await workflow.createRun({ runId: prevRunId });
+      return { runId: newRunId };
+    } catch (error) {
+      console.error("Error creating workflow run:", error);
+      throw error;
+    }
+  });
+}
+function useCancelWorkflowRun() {
+  const client = useMastraClient();
+  return useMutation(async ({ workflowId, runId }) => {
+    try {
+      const workflow = client.getWorkflow(workflowId);
+      const run = await workflow.createRun({ runId });
+      return run.cancelRun();
+    } catch (error) {
+      console.error("Error canceling workflow run:", error);
+      throw error;
+    }
+  });
+}
+
 exports.AgentIcon = AgentIcon;
 exports.CodeBlock = CodeBlock;
 exports.CodeBlockClass = CodeBlockClass;
@@ -20705,7 +21271,10 @@ exports.require_token_error = require_token_error;
 exports.resolveToChildMessages = resolveToChildMessages;
 exports.toAssistantUIMessage = toAssistantUIMessage;
 exports.toUIMessage = toUIMessage;
+exports.useCancelWorkflowRun = useCancelWorkflowRun;
 exports.useChat = useChat;
+exports.useCreateWorkflowRun = useCreateWorkflowRun;
 exports.useEntity = useEntity;
 exports.useMastraClient = useMastraClient;
-//# sourceMappingURL=index-ChvWx-iU.cjs.map
+exports.useStreamWorkflow = useStreamWorkflow;
+//# sourceMappingURL=index-TEBHU8EU.cjs.map