@voltagent/core 0.1.25 → 0.1.26

package/dist/index.js

@@ -1420,51 +1420,109 @@ app.openapi(streamRoute, (c) => __async(void 0, null, function* () {
     const stream = new ReadableStream({
       start(controller) {
         return __async(this, null, function* () {
+          var _a2;
           try {
+            let streamClosed = false;
+            const safeEnqueue = /* @__PURE__ */ __name((data) => {
+              if (!streamClosed) {
+                try {
+                  controller.enqueue(new TextEncoder().encode(data));
+                } catch (e) {
+                  console.error("Failed to enqueue data:", e);
+                  streamClosed = true;
+                }
+              }
+            }, "safeEnqueue");
+            const safeClose = /* @__PURE__ */ __name(() => {
+              if (!streamClosed) {
+                try {
+                  controller.close();
+                  streamClosed = true;
+                } catch (e) {
+                  console.error("Failed to close controller:", e);
+                }
+              }
+            }, "safeClose");
             const response = yield agent.streamText(input, __spreadProps(__spreadValues({}, options), {
               provider: {
                 maxTokens: options.maxTokens,
-                temperature: options.temperature
+                temperature: options.temperature,
+                // Add onError callback to handle streaming errors
+                onError: (error2) => __async(this, null, function* () {
+                  var _a3;
+                  const errorData = {
+                    error: (_a3 = error2 == null ? void 0 : error2.message) != null ? _a3 : "Streaming failed",
+                    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                    type: "error",
+                    code: error2.code || "STREAM_ERROR"
+                  };
+                  const errorMessage = `data: ${JSON.stringify(errorData)}
+
+`;
+                  safeEnqueue(errorMessage);
+                  safeClose();
+                })
               }
             }));
             try {
-              for (var iter = __forAwait(response.textStream), more, temp, error; more = !(temp = yield iter.next()).done; more = false) {
-                const chunk = temp.value;
-                const data = {
-                  text: chunk,
+              try {
+                for (var iter = __forAwait(response.textStream), more, temp, error; more = !(temp = yield iter.next()).done; more = false) {
+                  const chunk = temp.value;
+                  if (streamClosed)
+                    break;
+                  const data = {
+                    text: chunk,
+                    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                    type: "text"
+                  };
+                  const sseMessage = `data: ${JSON.stringify(data)}
+
+`;
+                  safeEnqueue(sseMessage);
+                }
+              } catch (temp) {
+                error = [temp];
+              } finally {
+                try {
+                  more && (temp = iter.return) && (yield temp.call(iter));
+                } finally {
+                  if (error)
+                    throw error[0];
+                }
+              }
+              if (!streamClosed) {
+                const completionData = {
+                  done: true,
                   timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-                  type: "text"
+                  type: "completion"
                 };
-                const sseMessage = `data: ${JSON.stringify(data)}
+                const completionMessage = `data: ${JSON.stringify(completionData)}
 
 `;
-                controller.enqueue(new TextEncoder().encode(sseMessage));
+                safeEnqueue(completionMessage);
+                safeClose();
               }
-            } catch (temp) {
-              error = [temp];
-            } finally {
-              try {
-                more && (temp = iter.return) && (yield temp.call(iter));
-              } finally {
-                if (error)
-                  throw error[0];
-              }
-            }
-            const completionData = {
-              done: true,
-              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-              type: "completion"
-            };
-            const completionMessage = `data: ${JSON.stringify(completionData)}
+            } catch (iterationError) {
+              console.error("Error during stream iteration:", iterationError);
+              const errorData = {
+                error: (_a2 = iterationError == null ? void 0 : iterationError.message) != null ? _a2 : "Stream iteration failed",
+                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                type: "error",
+                code: "ITERATION_ERROR"
+              };
+              const errorMessage = `data: ${JSON.stringify(errorData)}
 
 `;
-            controller.enqueue(new TextEncoder().encode(completionMessage));
-            controller.close();
+              safeEnqueue(errorMessage);
+              safeClose();
+            }
           } catch (error2) {
+            console.error("Error during stream setup:", error2);
             const errorData = {
-              error: error2 instanceof Error ? error2.message : "Streaming failed",
+              error: error2 instanceof Error ? error2.message : "Stream setup failed",
               timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-              type: "error"
+              type: "error",
+              code: "SETUP_ERROR"
             };
             const errorMessage = `data: ${JSON.stringify(errorData)}
 
@@ -1472,12 +1530,12 @@ app.openapi(streamRoute, (c) => __async(void 0, null, function* () {
             try {
               controller.enqueue(new TextEncoder().encode(errorMessage));
             } catch (e) {
-              console.error("Failed to enqueue error message:", e);
+              console.error("Failed to enqueue setup error message:", e);
             }
             try {
               controller.close();
             } catch (e) {
-              console.error("Failed to close controller after error:", e);
+              console.error("Failed to close controller after setup error:", e);
             }
           }
         });
@@ -1553,56 +1611,125 @@ app.openapi(streamObjectRoute, (c) => __async(void 0, null, function* () {
       options = {}
     } = c.req.valid("json");
     const schemaInZodObject = (0, import_zod_from_json_schema.convertJsonSchemaToZod)(schema);
-    const agentStream = yield agent.streamObject(input, schemaInZodObject, options);
     const sseStream = new ReadableStream({
       start(controller) {
         return __async(this, null, function* () {
-          const reader = agentStream.objectStream.getReader();
+          var _a2;
           try {
-            while (true) {
-              const { done, value } = yield reader.read();
-              if (done) {
-                const completionData = {
-                  done: true,
-                  type: "completion",
-                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            let streamClosed = false;
+            const safeEnqueue = /* @__PURE__ */ __name((data) => {
+              if (!streamClosed) {
+                try {
+                  controller.enqueue(new TextEncoder().encode(data));
+                } catch (e) {
+                  console.error("Failed to enqueue data:", e);
+                  streamClosed = true;
+                }
+              }
+            }, "safeEnqueue");
+            const safeClose = /* @__PURE__ */ __name(() => {
+              if (!streamClosed) {
+                try {
+                  controller.close();
+                  streamClosed = true;
+                } catch (e) {
+                  console.error("Failed to close controller:", e);
+                }
+              }
+            }, "safeClose");
+            const agentStream = yield agent.streamObject(input, schemaInZodObject, __spreadProps(__spreadValues({}, options), {
+              provider: __spreadProps(__spreadValues({}, options.provider), {
+                // Add onError callback to handle streaming errors
+                onError: (error) => __async(this, null, function* () {
+                  var _a3;
+                  console.error("Object stream error occurred:", error);
+                  const errorData = {
+                    error: (_a3 = error == null ? void 0 : error.message) != null ? _a3 : "Object streaming failed",
+                    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                    type: "error",
+                    code: error.code || "STREAM_ERROR"
+                  };
+                  const errorMessage = `data: ${JSON.stringify(errorData)}
+
+`;
+                  safeEnqueue(errorMessage);
+                  safeClose();
+                })
+              })
+            }));
+            const reader = agentStream.objectStream.getReader();
+            try {
+              while (true) {
+                if (streamClosed)
+                  break;
+                const { done, value } = yield reader.read();
+                if (done) {
+                  if (!streamClosed) {
+                    const completionData = {
+                      done: true,
+                      type: "completion",
+                      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                    };
+                    const completionMessage = `data: ${JSON.stringify(completionData)}
+
+`;
+                    safeEnqueue(completionMessage);
+                    safeClose();
+                  }
+                  break;
+                }
+                const objectData = {
+                  object: value,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                  type: "object"
                 };
-                controller.enqueue(`data: ${JSON.stringify(completionData)}
+                const sseMessage = `data: ${JSON.stringify(objectData)}
 
-`);
-                break;
+`;
+                safeEnqueue(sseMessage);
               }
-              controller.enqueue(`data: ${JSON.stringify(value)}
+            } catch (iterationError) {
+              console.error("Error during object stream iteration:", iterationError);
+              const errorData = {
+                error: (_a2 = iterationError == null ? void 0 : iterationError.message) != null ? _a2 : "Object stream iteration failed",
+                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                type: "error",
+                code: "ITERATION_ERROR"
+              };
+              const errorMessage = `data: ${JSON.stringify(errorData)}
 
-`);
+`;
+              safeEnqueue(errorMessage);
+              safeClose();
+            } finally {
+              reader.releaseLock();
             }
-            controller.close();
           } catch (error) {
+            console.error("Error during object stream setup:", error);
             const errorData = {
-              error: error instanceof Error ? error.message : "Object streaming failed",
+              error: error instanceof Error ? error.message : "Object stream setup failed",
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
               type: "error",
-              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              code: "SETUP_ERROR"
             };
-            try {
-              controller.enqueue(`data: ${JSON.stringify(errorData)}
+            const errorMessage = `data: ${JSON.stringify(errorData)}
 
-`);
+`;
+            try {
+              controller.enqueue(new TextEncoder().encode(errorMessage));
             } catch (e) {
-              console.error("Failed to enqueue error message:", e);
+              console.error("Failed to enqueue setup error message:", e);
             }
             try {
               controller.close();
             } catch (e) {
-              console.error("Failed to close controller after error:", e);
+              console.error("Failed to close controller after setup error:", e);
             }
-          } finally {
-            reader.releaseLock();
           }
         });
       },
       cancel(reason) {
         console.log("Object Stream cancelled:", reason);
-        agentStream.cancel(reason);
       }
     });
     return c.body(sseStream, {