@mastra/react 0.2.1 → 0.2.2-alpha.1

package/dist/{index-CZvmoC3g.cjs → index-DUTv-1fm.cjs}

@@ -1196,7 +1196,7 @@ var require_token_error = __commonJS$3({
 var marker$4 = "vercel.ai.error";
 var symbol$4 = Symbol.for(marker$4);
 var _a$4;
-var _AISDKError$3 = class _AISDKError2 extends Error {
+var _AISDKError$2 = class _AISDKError2 extends Error {
   /**
    * Creates an AI SDK Error.
    *
@@ -1229,7 +1229,7 @@ var _AISDKError$3 = class _AISDKError2 extends Error {
   }
 };
 _a$4 = symbol$4;
-var AISDKError$3 = _AISDKError$3;
+var AISDKError$3 = _AISDKError$2;
 var name$1 = "AI_APICallError";
 var marker2$1 = `vercel.ai.error.${name$1}`;
 var symbol2$1 = Symbol.for(marker2$1);
@@ -3269,8 +3269,8 @@ var require_get_vercel_oidc_token = __commonJS$3({
       }
       try {
         const [{ getTokenPayload, isExpired }, { refreshToken }] = await Promise.all([
-          await Promise.resolve().then(() => require('./token-util-NEHG7TUY-U7CX7GS4-IAc7W_zi.cjs')),
-          await Promise.resolve().then(() => require('./token-6GSAFR2W-XRCSVUPZ-Poxhi8x5.cjs'))
+          await Promise.resolve().then(() => require('./token-util-NEHG7TUY-U7CX7GS4-CwzYo-I6.cjs')),
+          await Promise.resolve().then(() => require('./token-6GSAFR2W-XRCSVUPZ-CxcM_lpA.cjs'))
         ]);
         if (!token || isExpired(getTokenPayload(token))) {
           await refreshToken();
@@ -3331,8 +3331,8 @@ var import_oidc2 = __toESM$2(require_dist());
 var marker$3 = "vercel.ai.gateway.error";
 var symbol$3 = Symbol.for(marker$3);
 var _a$3;
-var _b;
-var GatewayError = class _GatewayError extends (_b = Error, _a$3 = symbol$3, _b) {
+var _b$1;
+var GatewayError = class _GatewayError extends (_b$1 = Error, _a$3 = symbol$3, _b$1) {
   constructor({
     message,
     statusCode = 500,
@@ -3438,8 +3438,8 @@ var name3$3 = "GatewayRateLimitError";
 var marker4$3 = `vercel.ai.gateway.error.${name3$3}`;
 var symbol4$3 = Symbol.for(marker4$3);
 var _a4$3;
-var _b4;
-var GatewayRateLimitError = class extends (_b4 = GatewayError, _a4$3 = symbol4$3, _b4) {
+var _b4$1;
+var GatewayRateLimitError = class extends (_b4$1 = GatewayError, _a4$3 = symbol4$3, _b4$1) {
   constructor({
     message = "Rate limit exceeded",
     statusCode = 429,
@@ -5996,7 +5996,7 @@ var require_secure_json_parse$1 = __commonJS$2({
 var marker$2 = "vercel.ai.error";
 var symbol$2 = Symbol.for(marker$2);
 var _a$2;
-var _AISDKError$2 = class _AISDKError2 extends Error {
+var _AISDKError$1 = class _AISDKError2 extends Error {
   /**
    * Creates an AI SDK Error.
    *
@@ -6029,7 +6029,7 @@ var _AISDKError$2 = class _AISDKError2 extends Error {
   }
 };
 _a$2 = symbol$2;
-var AISDKError$2 = _AISDKError$2;
+var AISDKError$2 = _AISDKError$1;
 function getErrorMessage$1(error) {
   if (error == null) {
     return "unknown error";
@@ -6330,7 +6330,7 @@ function parseArrayDef$1(def, refs) {
   const res = {
     type: "array"
   };
-  if (def.type?._def && def.type?._def?.typeName !== z10.ZodFirstPartyTypeKind.ZodAny) {
+  if (def.type?._def && def.type?._def?.typeName !== z3.ZodFirstPartyTypeKind.ZodAny) {
     res.items = parseDef$1(def.type._def, {
       ...refs,
       currentPath: [...refs.currentPath, "items"]
@@ -6847,7 +6847,7 @@ function parseRecordDef$1(def, refs) {
   if (refs.target === "openAi") {
     console.warn("Warning: OpenAI may not support records in schemas! Try an array of key-value pairs instead.");
   }
-  if (refs.target === "openApi3" && def.keyType?._def.typeName === z10.ZodFirstPartyTypeKind.ZodEnum) {
+  if (refs.target === "openApi3" && def.keyType?._def.typeName === z3.ZodFirstPartyTypeKind.ZodEnum) {
     return {
       type: "object",
       required: def.keyType._def.values,
@@ -6871,20 +6871,20 @@ function parseRecordDef$1(def, refs) {
   if (refs.target === "openApi3") {
     return schema;
   }
-  if (def.keyType?._def.typeName === z10.ZodFirstPartyTypeKind.ZodString && def.keyType._def.checks?.length) {
+  if (def.keyType?._def.typeName === z3.ZodFirstPartyTypeKind.ZodString && def.keyType._def.checks?.length) {
     const { type, ...keyType } = parseStringDef$1(def.keyType._def, refs);
     return {
       ...schema,
       propertyNames: keyType
     };
-  } else if (def.keyType?._def.typeName === z10.ZodFirstPartyTypeKind.ZodEnum) {
+  } else if (def.keyType?._def.typeName === z3.ZodFirstPartyTypeKind.ZodEnum) {
     return {
       ...schema,
       propertyNames: {
         enum: def.keyType._def.values
       }
     };
-  } else if (def.keyType?._def.typeName === z10.ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === z10.ZodFirstPartyTypeKind.ZodString && def.keyType._def.type._def.checks?.length) {
+  } else if (def.keyType?._def.typeName === z3.ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === z3.ZodFirstPartyTypeKind.ZodString && def.keyType._def.type._def.checks?.length) {
     const { type, ...keyType } = parseBrandedDef$1(def.keyType._def, refs);
     return {
       ...schema,
@@ -7250,73 +7250,73 @@ var parseReadonlyDef$1 = (def, refs) => {
 };
 var selectParser$1 = (def, typeName, refs) => {
   switch (typeName) {
-    case z10.ZodFirstPartyTypeKind.ZodString:
+    case z3.ZodFirstPartyTypeKind.ZodString:
       return parseStringDef$1(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodNumber:
+    case z3.ZodFirstPartyTypeKind.ZodNumber:
       return parseNumberDef$1(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodObject:
+    case z3.ZodFirstPartyTypeKind.ZodObject:
       return parseObjectDef$1(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodBigInt:
+    case z3.ZodFirstPartyTypeKind.ZodBigInt:
       return parseBigintDef$1(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodBoolean:
+    case z3.ZodFirstPartyTypeKind.ZodBoolean:
       return parseBooleanDef$1();
-    case z10.ZodFirstPartyTypeKind.ZodDate:
+    case z3.ZodFirstPartyTypeKind.ZodDate:
       return parseDateDef$1(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodUndefined:
+    case z3.ZodFirstPartyTypeKind.ZodUndefined:
       return parseUndefinedDef$1(refs);
-    case z10.ZodFirstPartyTypeKind.ZodNull:
+    case z3.ZodFirstPartyTypeKind.ZodNull:
       return parseNullDef$1(refs);
-    case z10.ZodFirstPartyTypeKind.ZodArray:
+    case z3.ZodFirstPartyTypeKind.ZodArray:
       return parseArrayDef$1(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodUnion:
-    case z10.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
+    case z3.ZodFirstPartyTypeKind.ZodUnion:
+    case z3.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
       return parseUnionDef$1(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodIntersection:
+    case z3.ZodFirstPartyTypeKind.ZodIntersection:
       return parseIntersectionDef$1(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodTuple:
+    case z3.ZodFirstPartyTypeKind.ZodTuple:
       return parseTupleDef$1(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodRecord:
+    case z3.ZodFirstPartyTypeKind.ZodRecord:
       return parseRecordDef$1(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodLiteral:
+    case z3.ZodFirstPartyTypeKind.ZodLiteral:
       return parseLiteralDef$1(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodEnum:
+    case z3.ZodFirstPartyTypeKind.ZodEnum:
       return parseEnumDef$1(def);
-    case z10.ZodFirstPartyTypeKind.ZodNativeEnum:
+    case z3.ZodFirstPartyTypeKind.ZodNativeEnum:
       return parseNativeEnumDef$1(def);
-    case z10.ZodFirstPartyTypeKind.ZodNullable:
+    case z3.ZodFirstPartyTypeKind.ZodNullable:
       return parseNullableDef$1(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodOptional:
+    case z3.ZodFirstPartyTypeKind.ZodOptional:
       return parseOptionalDef$1(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodMap:
+    case z3.ZodFirstPartyTypeKind.ZodMap:
       return parseMapDef$1(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodSet:
+    case z3.ZodFirstPartyTypeKind.ZodSet:
       return parseSetDef$1(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodLazy:
+    case z3.ZodFirstPartyTypeKind.ZodLazy:
       return () => def.getter()._def;
-    case z10.ZodFirstPartyTypeKind.ZodPromise:
+    case z3.ZodFirstPartyTypeKind.ZodPromise:
       return parsePromiseDef$1(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodNaN:
-    case z10.ZodFirstPartyTypeKind.ZodNever:
+    case z3.ZodFirstPartyTypeKind.ZodNaN:
+    case z3.ZodFirstPartyTypeKind.ZodNever:
       return parseNeverDef$1(refs);
-    case z10.ZodFirstPartyTypeKind.ZodEffects:
+    case z3.ZodFirstPartyTypeKind.ZodEffects:
       return parseEffectsDef$1(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodAny:
+    case z3.ZodFirstPartyTypeKind.ZodAny:
       return parseAnyDef$1(refs);
-    case z10.ZodFirstPartyTypeKind.ZodUnknown:
+    case z3.ZodFirstPartyTypeKind.ZodUnknown:
       return parseUnknownDef$1(refs);
-    case z10.ZodFirstPartyTypeKind.ZodDefault:
+    case z3.ZodFirstPartyTypeKind.ZodDefault:
       return parseDefaultDef$1(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodBranded:
+    case z3.ZodFirstPartyTypeKind.ZodBranded:
       return parseBrandedDef$1(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodReadonly:
+    case z3.ZodFirstPartyTypeKind.ZodReadonly:
       return parseReadonlyDef$1(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodCatch:
+    case z3.ZodFirstPartyTypeKind.ZodCatch:
       return parseCatchDef$1(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodPipeline:
+    case z3.ZodFirstPartyTypeKind.ZodPipeline:
       return parsePipelineDef$1(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodFunction:
-    case z10.ZodFirstPartyTypeKind.ZodVoid:
-    case z10.ZodFirstPartyTypeKind.ZodSymbol:
+    case z3.ZodFirstPartyTypeKind.ZodFunction:
+    case z3.ZodFirstPartyTypeKind.ZodVoid:
+    case z3.ZodFirstPartyTypeKind.ZodSymbol:
       return void 0;
     default:
       return /* @__PURE__ */ ((_) => void 0)();
@@ -9804,8 +9804,8 @@ function trimStartOfStream$1() {
 // src/errors/ai-sdk-error.ts
 var marker$1 = "vercel.ai.error";
 var symbol$1 = Symbol.for(marker$1);
-var _a$1;
-var _AISDKError$1 = class _AISDKError extends Error {
+var _a$1, _b;
+var AISDKError$1 = class _AISDKError extends (_b = Error, _a$1 = symbol$1, _b) {
   /**
    * Creates an AI SDK Error.
    *
@@ -9837,15 +9837,13 @@ var _AISDKError$1 = class _AISDKError extends Error {
     return error != null && typeof error === "object" && markerSymbol in error && typeof error[markerSymbol] === "boolean" && error[markerSymbol] === true;
   }
 };
-_a$1 = symbol$1;
-var AISDKError$1 = _AISDKError$1;
 
 // src/errors/invalid-argument-error.ts
 var name3$1 = "AI_InvalidArgumentError";
 var marker4$1 = `vercel.ai.error.${name3$1}`;
 var symbol4$1 = Symbol.for(marker4$1);
-var _a4$1;
-var InvalidArgumentError$1 = class InvalidArgumentError extends AISDKError$1 {
+var _a4$1, _b4;
+var InvalidArgumentError$1 = class InvalidArgumentError extends (_b4 = AISDKError$1, _a4$1 = symbol4$1, _b4) {
   constructor({
     message,
     cause,
@@ -9859,7 +9857,6 @@ var InvalidArgumentError$1 = class InvalidArgumentError extends AISDKError$1 {
     return AISDKError$1.hasMarker(error, marker4$1);
   }
 };
-_a4$1 = symbol4$1;
 
 // src/combine-headers.ts
 var createIdGenerator$1 = ({
@@ -13664,10 +13661,15 @@ var MessageList$1 = class MessageList {
             sealedPartCount = existingParts.length;
           }
           const incomingParts = messageV2.content.parts;
+          let newParts;
           if (incomingParts.length <= sealedPartCount) {
-            return this;
+            if (messagesAreEqual(existingMessage, messageV2)) {
+              return this;
+            }
+            newParts = incomingParts;
+          } else {
+            newParts = incomingParts.slice(sealedPartCount);
           }
-          const newParts = incomingParts.slice(sealedPartCount);
           if (newParts.length > 0) {
             messageV2.id = this.generateMessageId?.({ idType: "message", source: "memory" }) ?? uuid.v4();
             messageV2.content.parts = newParts;
@@ -20605,7 +20607,7 @@ function parseArrayDef(def, refs) {
   const res = {
     type: "array"
   };
-  if (def.type?._def && def.type?._def?.typeName !== z10.ZodFirstPartyTypeKind.ZodAny) {
+  if (def.type?._def && def.type?._def?.typeName !== z3.ZodFirstPartyTypeKind.ZodAny) {
     res.items = parseDef(def.type._def, {
       ...refs,
       currentPath: [...refs.currentPath, "items"]
@@ -21122,7 +21124,7 @@ function parseRecordDef(def, refs) {
   if (refs.target === "openAi") {
     console.warn("Warning: OpenAI may not support records in schemas! Try an array of key-value pairs instead.");
   }
-  if (refs.target === "openApi3" && def.keyType?._def.typeName === z10.ZodFirstPartyTypeKind.ZodEnum) {
+  if (refs.target === "openApi3" && def.keyType?._def.typeName === z3.ZodFirstPartyTypeKind.ZodEnum) {
     return {
       type: "object",
       required: def.keyType._def.values,
@@ -21146,20 +21148,20 @@ function parseRecordDef(def, refs) {
   if (refs.target === "openApi3") {
     return schema;
   }
-  if (def.keyType?._def.typeName === z10.ZodFirstPartyTypeKind.ZodString && def.keyType._def.checks?.length) {
+  if (def.keyType?._def.typeName === z3.ZodFirstPartyTypeKind.ZodString && def.keyType._def.checks?.length) {
     const { type, ...keyType } = parseStringDef(def.keyType._def, refs);
     return {
       ...schema,
       propertyNames: keyType
     };
-  } else if (def.keyType?._def.typeName === z10.ZodFirstPartyTypeKind.ZodEnum) {
+  } else if (def.keyType?._def.typeName === z3.ZodFirstPartyTypeKind.ZodEnum) {
     return {
       ...schema,
       propertyNames: {
         enum: def.keyType._def.values
       }
     };
-  } else if (def.keyType?._def.typeName === z10.ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === z10.ZodFirstPartyTypeKind.ZodString && def.keyType._def.type._def.checks?.length) {
+  } else if (def.keyType?._def.typeName === z3.ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === z3.ZodFirstPartyTypeKind.ZodString && def.keyType._def.type._def.checks?.length) {
     const { type, ...keyType } = parseBrandedDef(def.keyType._def, refs);
     return {
       ...schema,
@@ -21525,73 +21527,73 @@ var parseReadonlyDef = (def, refs) => {
 };
 var selectParser = (def, typeName, refs) => {
   switch (typeName) {
-    case z10.ZodFirstPartyTypeKind.ZodString:
+    case z3.ZodFirstPartyTypeKind.ZodString:
       return parseStringDef(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodNumber:
+    case z3.ZodFirstPartyTypeKind.ZodNumber:
       return parseNumberDef(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodObject:
+    case z3.ZodFirstPartyTypeKind.ZodObject:
       return parseObjectDef(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodBigInt:
+    case z3.ZodFirstPartyTypeKind.ZodBigInt:
       return parseBigintDef(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodBoolean:
+    case z3.ZodFirstPartyTypeKind.ZodBoolean:
       return parseBooleanDef();
-    case z10.ZodFirstPartyTypeKind.ZodDate:
+    case z3.ZodFirstPartyTypeKind.ZodDate:
       return parseDateDef(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodUndefined:
+    case z3.ZodFirstPartyTypeKind.ZodUndefined:
       return parseUndefinedDef(refs);
-    case z10.ZodFirstPartyTypeKind.ZodNull:
+    case z3.ZodFirstPartyTypeKind.ZodNull:
       return parseNullDef(refs);
-    case z10.ZodFirstPartyTypeKind.ZodArray:
+    case z3.ZodFirstPartyTypeKind.ZodArray:
       return parseArrayDef(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodUnion:
-    case z10.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
+    case z3.ZodFirstPartyTypeKind.ZodUnion:
+    case z3.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
       return parseUnionDef(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodIntersection:
+    case z3.ZodFirstPartyTypeKind.ZodIntersection:
       return parseIntersectionDef(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodTuple:
+    case z3.ZodFirstPartyTypeKind.ZodTuple:
       return parseTupleDef(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodRecord:
+    case z3.ZodFirstPartyTypeKind.ZodRecord:
       return parseRecordDef(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodLiteral:
+    case z3.ZodFirstPartyTypeKind.ZodLiteral:
       return parseLiteralDef(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodEnum:
+    case z3.ZodFirstPartyTypeKind.ZodEnum:
       return parseEnumDef(def);
-    case z10.ZodFirstPartyTypeKind.ZodNativeEnum:
+    case z3.ZodFirstPartyTypeKind.ZodNativeEnum:
       return parseNativeEnumDef(def);
-    case z10.ZodFirstPartyTypeKind.ZodNullable:
+    case z3.ZodFirstPartyTypeKind.ZodNullable:
       return parseNullableDef(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodOptional:
+    case z3.ZodFirstPartyTypeKind.ZodOptional:
       return parseOptionalDef(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodMap:
+    case z3.ZodFirstPartyTypeKind.ZodMap:
       return parseMapDef(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodSet:
+    case z3.ZodFirstPartyTypeKind.ZodSet:
       return parseSetDef(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodLazy:
+    case z3.ZodFirstPartyTypeKind.ZodLazy:
       return () => def.getter()._def;
-    case z10.ZodFirstPartyTypeKind.ZodPromise:
+    case z3.ZodFirstPartyTypeKind.ZodPromise:
       return parsePromiseDef(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodNaN:
-    case z10.ZodFirstPartyTypeKind.ZodNever:
+    case z3.ZodFirstPartyTypeKind.ZodNaN:
+    case z3.ZodFirstPartyTypeKind.ZodNever:
       return parseNeverDef(refs);
-    case z10.ZodFirstPartyTypeKind.ZodEffects:
+    case z3.ZodFirstPartyTypeKind.ZodEffects:
       return parseEffectsDef(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodAny:
+    case z3.ZodFirstPartyTypeKind.ZodAny:
       return parseAnyDef(refs);
-    case z10.ZodFirstPartyTypeKind.ZodUnknown:
+    case z3.ZodFirstPartyTypeKind.ZodUnknown:
       return parseUnknownDef(refs);
-    case z10.ZodFirstPartyTypeKind.ZodDefault:
+    case z3.ZodFirstPartyTypeKind.ZodDefault:
       return parseDefaultDef(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodBranded:
+    case z3.ZodFirstPartyTypeKind.ZodBranded:
       return parseBrandedDef(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodReadonly:
+    case z3.ZodFirstPartyTypeKind.ZodReadonly:
       return parseReadonlyDef(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodCatch:
+    case z3.ZodFirstPartyTypeKind.ZodCatch:
       return parseCatchDef(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodPipeline:
+    case z3.ZodFirstPartyTypeKind.ZodPipeline:
       return parsePipelineDef(def, refs);
-    case z10.ZodFirstPartyTypeKind.ZodFunction:
-    case z10.ZodFirstPartyTypeKind.ZodVoid:
-    case z10.ZodFirstPartyTypeKind.ZodSymbol:
+    case z3.ZodFirstPartyTypeKind.ZodFunction:
+    case z3.ZodFirstPartyTypeKind.ZodVoid:
+    case z3.ZodFirstPartyTypeKind.ZodSymbol:
       return void 0;
     default:
       return /* @__PURE__ */ ((_) => void 0)();
@@ -26572,30 +26574,33 @@ const fromCoreUserMessageToUIMessage = (coreUserMessage) => {
   };
 };
 
-const useChat = ({ agentId, resourceId, initializeMessages }) => {
-  const extractRunIdFromMessages = (messages2) => {
-    for (const message of messages2) {
-      const pendingToolApprovals = message.metadata?.pendingToolApprovals;
-      if (pendingToolApprovals && typeof pendingToolApprovals === "object") {
-        const suspensionData = Object.values(pendingToolApprovals)[0];
-        if (suspensionData?.runId) {
-          return suspensionData.runId;
-        }
+const extractRunIdFromMessages = (messages) => {
+  for (const message of messages) {
+    const pendingToolApprovals = message.metadata?.pendingToolApprovals;
+    if (pendingToolApprovals && typeof pendingToolApprovals === "object") {
+      const suspensionData = Object.values(pendingToolApprovals)[0];
+      if (suspensionData?.runId) {
+        return suspensionData.runId;
       }
     }
-    return void 0;
-  };
-  const initialMessages = initializeMessages?.() || [];
-  const initialRunId = extractRunIdFromMessages(initialMessages);
-  const _currentRunId = react.useRef(initialRunId);
+  }
+  return void 0;
+};
+const useChat = ({ agentId, resourceId, initialMessages }) => {
+  const _currentRunId = react.useRef(void 0);
   const _onChunk = react.useRef(void 0);
   const _networkRunId = react.useRef(void 0);
   const _onNetworkChunk = react.useRef(void 0);
-  const [messages, setMessages] = react.useState(() => resolveInitialMessages(initialMessages));
+  const [messages, setMessages] = react.useState([]);
   const [toolCallApprovals, setToolCallApprovals] = react.useState({});
   const [networkToolCallApprovals, setNetworkToolCallApprovals] = react.useState({});
   const baseClient = useMastraClient();
   const [isRunning, setIsRunning] = react.useState(false);
+  react.useEffect(() => {
+    const formattedMessages = resolveInitialMessages(initialMessages || []);
+    setMessages(formattedMessages);
+    _currentRunId.current = extractRunIdFromMessages(formattedMessages);
+  }, [initialMessages]);
   const generate = async ({
     coreUserMessages,
     requestContext,
@@ -27746,4 +27751,4 @@ exports.useCreateWorkflowRun = useCreateWorkflowRun;
 exports.useEntity = useEntity;
 exports.useMastraClient = useMastraClient;
 exports.useStreamWorkflow = useStreamWorkflow;
-//# sourceMappingURL=index-CZvmoC3g.cjs.map
+//# sourceMappingURL=index-DUTv-1fm.cjs.map