veryfront 0.0.27 → 0.0.29

package/dist/ai/index.js

@@ -1709,7 +1709,7 @@ var BYTES_PER_MB = 1024 * 1024;
 // deno.json
 var deno_default = {
   name: "veryfront",
-  version: "0.0.27",
+  version: "0.0.29",
   nodeModulesDir: "auto",
   exports: {
     ".": "./src/index.ts",
@@ -2388,6 +2388,7 @@ var AgentRuntime = class {
   }
   /**
    * Stream a response
+   * Returns a ReadableStream compatible with Vercel AI SDK Data Stream Protocol
    */
   async stream(messages, _context, callbacks) {
     for (const msg of messages) {
@@ -2397,10 +2398,18 @@ var AgentRuntime = class {
     const systemPrompt = await this.resolveSystemPrompt();
     const { provider, model } = getProviderFromModel(this.config.model);
     const encoder = new TextEncoder();
+    const messageId = `msg_${Date.now()}`;
     return new ReadableStream({
       start: async (controller) => {
         try {
           this.status = "streaming";
+          const startEvent = JSON.stringify({
+            type: "start",
+            messageId
+          });
+          controller.enqueue(encoder.encode(`data: ${startEvent}
+
+`));
           const response = await this.executeAgentLoopStreaming(
             provider,
             model,
@@ -2408,24 +2417,25 @@ var AgentRuntime = class {
             memoryMessages,
             controller,
             encoder,
-            callbacks
+            callbacks,
+            messageId
           );
-          const statusData = JSON.stringify({
-            type: "status",
-            status: "completed",
+          const finishEvent = JSON.stringify({
+            type: "finish",
             usage: response.usage
           });
-          controller.enqueue(encoder.encode(`data: ${statusData}
+          controller.enqueue(encoder.encode(`data: ${finishEvent}
 
 `));
+          controller.enqueue(encoder.encode("data: [DONE]\n\n"));
           controller.close();
         } catch (error) {
           this.status = "error";
-          const errorData = JSON.stringify({
+          const errorEvent = JSON.stringify({
             type: "error",
             error: error instanceof Error ? error.message : String(error)
           });
-          controller.enqueue(encoder.encode(`data: ${errorData}
+          controller.enqueue(encoder.encode(`data: ${errorEvent}
 
 `));
           controller.close();
@@ -2578,8 +2588,9 @@ var AgentRuntime = class {
   }
   /**
    * Execute agent loop with streaming
+   * Uses Vercel AI SDK Data Stream Protocol format
    */
-  async executeAgentLoopStreaming(provider, model, systemPrompt, messages, controller, encoder, callbacks) {
+  async executeAgentLoopStreaming(provider, model, systemPrompt, messages, controller, encoder, callbacks, messageId) {
     const capabilities = getPlatformCapabilities();
     const maxSteps = this.getMaxSteps(capabilities.maxAgentSteps);
     const toolCalls = [];
@@ -2656,11 +2667,11 @@ var AgentRuntime = class {
         switch (event.type) {
           case "content": {
             accumulatedText += event.content;
-            const chunkData = JSON.stringify({
-              type: "chunk",
-              content: event.content
+            const textDeltaEvent = JSON.stringify({
+              type: "text-delta",
+              textDelta: event.content
             });
-            controller.enqueue(encoder.encode(`data: ${chunkData}
+            controller.enqueue(encoder.encode(`data: ${textDeltaEvent}
 
 `));
             if (callbacks?.onChunk) {
@@ -2675,12 +2686,28 @@ var AgentRuntime = class {
                 name: event.toolCall.name,
                 arguments: ""
               });
+              const toolStartEvent = JSON.stringify({
+                type: "tool-call-streaming-start",
+                toolCallId: event.toolCall.id,
+                toolName: event.toolCall.name
+              });
+              controller.enqueue(encoder.encode(`data: ${toolStartEvent}
+
+`));
             }
             break;
           case "tool_call_delta":
             if (event.id && streamToolCalls.has(event.id)) {
               const tc = streamToolCalls.get(event.id);
               tc.arguments += event.arguments;
+              const toolDeltaEvent = JSON.stringify({
+                type: "tool-call-delta",
+                toolCallId: event.id,
+                argsTextDelta: event.arguments
+              });
+              controller.enqueue(encoder.encode(`data: ${toolDeltaEvent}
+
+`));
             }
             break;
           case "tool_call_complete":
@@ -2690,6 +2717,16 @@ var AgentRuntime = class {
                 name: event.toolCall.name,
                 arguments: event.toolCall.arguments
               });
+              const { args } = parseStreamToolArgs(event.toolCall.arguments);
+              const toolCallEvent = JSON.stringify({
+                type: "tool-call",
+                toolCallId: event.toolCall.id,
+                toolName: event.toolCall.name,
+                args
+              });
+              controller.enqueue(encoder.encode(`data: ${toolCallEvent}
+
+`));
             }
             break;
           case "finish":
@@ -2788,15 +2825,13 @@ var AgentRuntime = class {
             if (callbacks?.onToolCall) {
               callbacks.onToolCall(toolCall);
             }
-            const toolCallData = JSON.stringify({
-              type: "tool_call",
-              toolCall: {
-                id: toolCall.id,
-                name: toolCall.name,
-                args: toolCall.args
-              }
+            const toolCallEvent = JSON.stringify({
+              type: "tool-call",
+              toolCallId: toolCall.id,
+              toolName: toolCall.name,
+              args: toolCall.args
             });
-            controller.enqueue(encoder.encode(`data: ${toolCallData}
+            controller.enqueue(encoder.encode(`data: ${toolCallEvent}
 
 `));
             const result = await executeTool(tc.name, toolCall.args, {
@@ -2806,15 +2841,12 @@ var AgentRuntime = class {
             toolCall.result = result;
             toolCall.executionTime = Date.now() - startTime;
             toolCalls.push(toolCall);
-            const toolResultData = JSON.stringify({
-              type: "tool_result",
-              toolCall: {
-                id: toolCall.id,
-                name: toolCall.name,
-                result
-              }
+            const toolResultEvent = JSON.stringify({
+              type: "tool-result",
+              toolCallId: toolCall.id,
+              result
             });
-            controller.enqueue(encoder.encode(`data: ${toolResultData}
+            controller.enqueue(encoder.encode(`data: ${toolResultEvent}
 
 `));
             const toolResultMessage = {
@@ -3214,6 +3246,8 @@ function createAgentStreamResult(stream) {
           "Content-Type": "text/event-stream",
           "Cache-Control": "no-cache",
           "Connection": "keep-alive",
+          // Required header for Vercel AI SDK Data Stream Protocol v1
+          "x-vercel-ai-ui-message-stream": "v1",
           ...options?.headers
         }
       });
@@ -3274,7 +3308,9 @@ ${compatibility.warnings.join("\n")}`
         headers: {
           "Content-Type": "text/event-stream",
           "Cache-Control": "no-cache",
-          "Connection": "keep-alive"
+          "Connection": "keep-alive",
+          // Required header for Vercel AI SDK Data Stream Protocol v1
+          "x-vercel-ai-ui-message-stream": "v1"
         }
       });
     },