veryfront 0.1.199 → 0.1.201

package/esm/src/agent/runtime/index.js

@@ -299,12 +299,10 @@ export class AgentRuntime {
                             model: effectiveModel,
                         },
                     });
-                    sendSSE(controller, encoder, { type: "text-start", id: textPartId });
                     const response = await this.executeAgentLoopStreaming(systemPrompt, memoryMessages, controller, encoder, callbacks, textPartId, toolContext, context, resolvedModelString, languageModel, transport.headers, transport.providerOptions, maxOutputTokensOverride, streamAbortSignal);
                     throwIfAborted(streamAbortSignal);
                     callbacks?.onFinish?.(response);
                     throwIfAborted(streamAbortSignal);
-                    sendSSE(controller, encoder, { type: "text-end", id: textPartId });
                     sendSSE(controller, encoder, { type: "message-finish" });
                     closeSSEStream(controller);
                 }

package/esm/src/utils/version-constant.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.1.199";
+export declare const VERSION = "0.1.201";
 //# sourceMappingURL=version-constant.d.ts.map

package/esm/src/utils/version-constant.js

@@ -1,3 +1,3 @@
 // Keep in sync with deno.json version.
 // scripts/release.ts updates this constant during releases.
-export const VERSION = "0.1.199";
+export const VERSION = "0.1.201";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "veryfront",
-  "version": "0.1.199",
+  "version": "0.1.201",
   "description": "The simplest way to build AI-powered apps",
   "keywords": [
     "react",

package/src/cli/commands/knowledge/command.ts

@@ -3,6 +3,7 @@ import { z } from "zod";
 type SafeParseResult<T> = { success: true; data: T } | { success: false; error: z.ZodError };
 import { createFileSystem, getEnv } from "../../../src/platform/index.js";
 import { basename, extname, join, normalize, relative } from "../../../src/platform/compat/path/index.js";
+import { type CommandResult, runCommand } from "../../../src/platform/compat/process.js";
 import { withSpan } from "../../../src/observability/tracing/otlp-setup.js";
 import { cliLogger } from "../../utils/index.js";
 import { type ApiClient, createApiClient, resolveConfigWithAuth } from "../../shared/config.js";
@@ -485,6 +486,76 @@ export async function runKnowledgeParser(input: {
   return result;
 }
 
+function isMissingPythonExecutableError(error: unknown): boolean {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+
+  const errorWithCode = error as Error & { code?: unknown };
+  if (errorWithCode.code === "ENOENT") {
+    return true;
+  }
+
+  return error.name === "NotFound" ||
+    /\bENOENT\b/i.test(error.message) ||
+    /not found/i.test(error.message) ||
+    /no such file or directory/i.test(error.message);
+}
+
+export async function executeKnowledgeParserCommand(input: {
+  scriptPath: string;
+  inputJsonPath: string;
+  outputJsonPath: string;
+  env?: Record<string, string>;
+}, deps: {
+  runCommandFn?: (
+    cmd: string,
+    options: {
+      args: string[];
+      env?: Record<string, string>;
+      capture: true;
+    },
+  ) => Promise<CommandResult>;
+} = {}): Promise<void> {
+  const runCommandFn = deps.runCommandFn ?? runCommand;
+  let result: CommandResult;
+  try {
+    result = await runCommandFn("python3", {
+      args: [
+        input.scriptPath,
+        "--input-json",
+        input.inputJsonPath,
+        "--output-json",
+        input.outputJsonPath,
+      ],
+      ...(input.env ? { env: input.env } : {}),
+      capture: true,
+    });
+  } catch (error) {
+    if (isMissingPythonExecutableError(error)) {
+      throw new Error(
+        "python3 is required. Install python3 and the supported parser packages, or run the command inside the Veryfront sandbox.",
+      );
+    }
+    throw error;
+  }
+
+  if (result.success) {
+    return;
+  }
+
+  const stderr = result.stderr?.trim();
+  const stdout = result.stdout?.trim();
+
+  if (result.code === 1 && !stderr && !stdout) {
+    throw new Error(
+      "python3 is required. Install python3 and the supported parser packages, or run the command inside the Veryfront sandbox.",
+    );
+  }
+
+  throw new Error(stderr || stdout || "parser exited unsuccessfully");
+}
+
 export async function runKnowledgeParsers(input: {
   files: KnowledgeParserInput[];
   outputDir: string;
@@ -515,27 +586,12 @@ export async function runKnowledgeParsers(input: {
       );
       await dntShim.Deno.writeTextFile(scriptPath, knowledgeIngestPythonSource);
 
-      let result: dntShim.Deno.CommandOutput;
-      try {
-        result = await new dntShim.Deno.Command("python3", {
-          args: [scriptPath, "--input-json", inputJsonPath, "--output-json", outputJsonPath],
-          ...(input.env ? { env: input.env } : {}),
-          stdout: "piped",
-          stderr: "piped",
-        }).output();
-      } catch (error) {
-        if (error instanceof dntShim.Deno.errors.NotFound) {
-          throw new Error(
-            "python3 is required. Install python3 and the supported parser packages, or run the command inside the Veryfront sandbox.",
-          );
-        }
-        throw error;
-      }
-
-      if (result.code !== 0) {
-        const stderr = new TextDecoder().decode(result.stderr).trim();
-        throw new Error(stderr || "parser exited unsuccessfully");
-      }
+      await executeKnowledgeParserCommand({
+        scriptPath,
+        inputJsonPath,
+        outputJsonPath,
+        env: input.env,
+      });
 
       const raw = await dntShim.Deno.readTextFile(outputJsonPath);
       const parsed = JSON.parse(raw) as KnowledgeParserResult | KnowledgeParserResult[];

package/src/deno.js

@@ -1,6 +1,6 @@
 export default {
   "name": "veryfront",
-  "version": "0.1.199",
+  "version": "0.1.201",
   "license": "Apache-2.0",
   "nodeModulesDir": "auto",
   "exclude": [

package/src/src/agent/ag-ui-browser-encoder.ts

@@ -234,6 +234,28 @@ function createTextEvent(
   };
 }
 
+function closeOpenTextEvent(state: AgUiBrowserEncoderState): AgUiBrowserEncodedEvent[] {
+  if (!state.textOpen) {
+    return [];
+  }
+
+  state.textOpen = false;
+  return [createTextEvent(getMessageId(state, { type: "text-end" }), "TextMessageEnd")];
+}
+
+function closeOpenReasoningEvent(state: AgUiBrowserEncoderState): AgUiBrowserEncodedEvent[] {
+  if (state.reasoningMessageId === null) {
+    return [];
+  }
+
+  const messageId = state.reasoningMessageId;
+  state.reasoningMessageId = null;
+  return [{
+    event: "ReasoningMessageEnd",
+    payload: { messageId },
+  }];
+}
+
 export function mapRuntimeStreamEventToAgUiBrowserEvents(
   state: AgUiBrowserEncoderState,
   event: AgUiRuntimeStreamEvent,
@@ -254,33 +276,38 @@ export function mapRuntimeStreamEventToAgUiBrowserEvents(
       return [];
 
     case "text-start": {
+      const events = closeOpenReasoningEvent(state);
       if (state.textOpen) return [];
       const messageId = getMessageId(state, event);
       state.textOpen = true;
       state.sawVisibleOutput = true;
-      return [createTextEvent(messageId, "TextMessageStart")];
+      events.push(createTextEvent(messageId, "TextMessageStart"));
+      return events;
     }
 
     case "text-delta": {
+      const events = closeOpenReasoningEvent(state);
       const messageId = getMessageId(state, event);
       state.sawVisibleOutput = true;
       if (!state.textOpen) {
         state.textOpen = true;
-        return [
+        events.push(
           createTextEvent(messageId, "TextMessageStart"),
           createTextEvent(
             messageId,
             "TextMessageContent",
             typeof event.delta === "string" ? event.delta : "",
           ),
-        ];
+        );
+        return events;
       }
 
-      return [createTextEvent(
+      events.push(createTextEvent(
         messageId,
         "TextMessageContent",
         typeof event.delta === "string" ? event.delta : "",
-      )];
+      ));
+      return events;
     }
 
     case "text-end": {
@@ -289,13 +316,23 @@ export function mapRuntimeStreamEventToAgUiBrowserEvents(
       return [createTextEvent(getMessageId(state, event), "TextMessageEnd")];
     }
 
-    case "reasoning-start":
+    case "reasoning-start": {
+      const events = closeOpenTextEvent(state);
+      events.push(...closeOpenReasoningEvent(state));
       state.sawVisibleOutput = true;
-      return [createReasoningEvent(state, event, "ReasoningMessageStart")];
+      events.push(createReasoningEvent(state, event, "ReasoningMessageStart"));
+      return events;
+    }
 
-    case "reasoning-delta":
+    case "reasoning-delta": {
+      const events = closeOpenTextEvent(state);
       state.sawVisibleOutput = true;
-      return [createReasoningEvent(state, event, "ReasoningMessageContent")];
+      if (state.reasoningMessageId === null) {
+        events.push(createReasoningEvent(state, event, "ReasoningMessageStart"));
+      }
+      events.push(createReasoningEvent(state, event, "ReasoningMessageContent"));
+      return events;
+    }
 
     case "reasoning-end": {
       const reasoningEvent = createReasoningEvent(state, event, "ReasoningMessageEnd");
@@ -303,15 +340,21 @@ export function mapRuntimeStreamEventToAgUiBrowserEvents(
       return [reasoningEvent];
     }
 
-    case "tool-input-start":
+    case "tool-input-start": {
+      const events = [
+        ...closeOpenTextEvent(state),
+        ...closeOpenReasoningEvent(state),
+      ];
       state.sawVisibleOutput = true;
-      return [{
+      events.push({
         event: "ToolCallStart",
         payload: {
           toolCallId: event.toolCallId,
           toolCallName: event.toolName,
         },
-      }];
+      });
+      return events;
+    }
 
     case "tool-input-delta":
       state.sawVisibleOutput = true;
@@ -328,12 +371,20 @@ export function mapRuntimeStreamEventToAgUiBrowserEvents(
 
     case "tool-input-available": {
       state.sawVisibleOutput = true;
-      return completeToolInput(state, event);
+      return [
+        ...closeOpenTextEvent(state),
+        ...closeOpenReasoningEvent(state),
+        ...completeToolInput(state, event),
+      ];
     }
 
     case "tool-input-error": {
       state.sawVisibleOutput = true;
-      const events = completeToolInput(state, event);
+      const events = [
+        ...closeOpenTextEvent(state),
+        ...closeOpenReasoningEvent(state),
+        ...completeToolInput(state, event),
+      ];
       events.push({
         event: "ToolCallResult",
         payload: {
@@ -349,25 +400,45 @@ export function mapRuntimeStreamEventToAgUiBrowserEvents(
 
     case "tool-output-available":
       state.sawVisibleOutput = true;
-      return [createToolResultEvent(event.toolCallId, event.output)];
+      return [
+        ...closeOpenTextEvent(state),
+        ...closeOpenReasoningEvent(state),
+        createToolResultEvent(event.toolCallId, event.output),
+      ];
 
     case "tool-output-error":
       state.sawVisibleOutput = true;
-      return [createToolResultEvent(event.toolCallId, { error: event.errorText }, true)];
+      return [
+        ...closeOpenTextEvent(state),
+        ...closeOpenReasoningEvent(state),
+        createToolResultEvent(event.toolCallId, { error: event.errorText }, true),
+      ];
 
     case "tool-output-denied":
       state.sawVisibleOutput = true;
-      return [createToolResultEvent(event.toolCallId, { error: "Tool output denied" }, true)];
+      return [
+        ...closeOpenTextEvent(state),
+        ...closeOpenReasoningEvent(state),
+        createToolResultEvent(event.toolCallId, { error: "Tool output denied" }, true),
+      ];
 
     case "step-start":
     case "start-step":
       state.sawVisibleOutput = true;
-      return [createStepEvent(state, "StepStarted")];
+      return [
+        ...closeOpenTextEvent(state),
+        ...closeOpenReasoningEvent(state),
+        createStepEvent(state, "StepStarted"),
+      ];
 
     case "step-end":
     case "finish-step":
       state.sawVisibleOutput = true;
-      return [createStepEvent(state, "StepFinished")];
+      return [
+        ...closeOpenTextEvent(state),
+        ...closeOpenReasoningEvent(state),
+        createStepEvent(state, "StepFinished"),
+      ];
 
     case "data":
       applyDataMetadata(state, event);
@@ -375,12 +446,16 @@ export function mapRuntimeStreamEventToAgUiBrowserEvents(
 
     case "error":
       state.sawTerminalError = true;
-      return [{
-        event: "RunError",
-        payload: {
-          message: typeof event.error === "string" ? event.error : "Agent run failed",
+      return [
+        ...closeOpenTextEvent(state),
+        ...closeOpenReasoningEvent(state),
+        {
+          event: "RunError",
+          payload: {
+            message: typeof event.error === "string" ? event.error : "Agent run failed",
+          },
         },
-      }];
+      ];
 
     default:
       return [];
@@ -409,13 +484,8 @@ export function finalizeAgUiBrowserEvents(
   }
 
   const events: AgUiBrowserEncodedEvent[] = [];
-  if (state.textOpen) {
-    state.textOpen = false;
-    events.push({
-      event: "TextMessageEnd",
-      payload: { messageId: getMessageId(state, { type: "text-end" }) },
-    });
-  }
+  events.push(...closeOpenTextEvent(state));
+  events.push(...closeOpenReasoningEvent(state));
 
   events.push({
     event: "RunFinished",

package/src/src/agent/runtime/chat-stream-handler.ts

@@ -24,6 +24,7 @@ export interface StreamingToolCall {
   id: string;
   name: string;
   arguments: string;
+  inputAvailable?: boolean;
   providerExecuted?: boolean;
   dynamic?: boolean;
 }
@@ -157,6 +158,136 @@ export function processStream(
 ): Promise<void> {
   return withSpan("agent.runtime.processStream", async () => {
     let eventCount = 0;
+    let textOpen = false;
+    let activeReasoningId: string | null = null;
+
+    const normalizeReasoningId = (part: { id?: string }) =>
+      typeof part.id === "string" && part.id.length > 0 ? part.id : "reasoning";
+
+    const openTextSegment = () => {
+      if (textOpen) {
+        return;
+      }
+
+      textOpen = true;
+      sendSSE(controller, encoder, {
+        type: "text-start",
+        id: textPartId,
+      });
+    };
+
+    const closeTextSegment = () => {
+      if (!textOpen) {
+        return;
+      }
+
+      textOpen = false;
+      sendSSE(controller, encoder, {
+        type: "text-end",
+        id: textPartId,
+      });
+    };
+
+    const openReasoningSegment = (reasoningId: string) => {
+      if (activeReasoningId === reasoningId) {
+        return;
+      }
+
+      if (activeReasoningId !== null) {
+        sendSSE(controller, encoder, {
+          type: "reasoning-end",
+          id: activeReasoningId,
+        });
+      }
+
+      activeReasoningId = reasoningId;
+      sendSSE(controller, encoder, {
+        type: "reasoning-start",
+        id: reasoningId,
+      });
+    };
+
+    const closeReasoningSegment = () => {
+      if (activeReasoningId === null) {
+        return;
+      }
+
+      sendSSE(controller, encoder, {
+        type: "reasoning-end",
+        id: activeReasoningId,
+      });
+      activeReasoningId = null;
+    };
+
+    const ensureToolLifecycle = (part: {
+      toolCallId: string;
+      toolName: string;
+      input?: unknown;
+      providerExecuted?: boolean;
+      dynamic?: boolean;
+    }) => {
+      const dynamic = part.dynamic ?? isDynamicTool(part.toolName);
+      const existing = state.toolCalls.get(part.toolCallId);
+
+      if (!existing) {
+        const normalizedInput = parseToolInputObject(part.input);
+        state.toolCalls.set(part.toolCallId, {
+          id: part.toolCallId,
+          name: part.toolName,
+          arguments: normalizeToolInputString(part.input),
+          inputAvailable: true,
+          ...(part.providerExecuted !== undefined
+            ? { providerExecuted: part.providerExecuted }
+            : {}),
+          ...(dynamic ? { dynamic: true } : {}),
+        });
+        sendSSE(controller, encoder, {
+          type: "tool-input-start",
+          toolCallId: part.toolCallId,
+          toolName: part.toolName,
+          ...(dynamic ? { dynamic: true } : {}),
+        });
+        sendSSE(controller, encoder, {
+          type: "tool-input-available",
+          toolCallId: part.toolCallId,
+          toolName: part.toolName,
+          input: normalizedInput,
+          ...(part.providerExecuted !== undefined
+            ? { providerExecuted: part.providerExecuted }
+            : {}),
+          ...(dynamic ? { dynamic: true } : {}),
+        });
+        return;
+      }
+
+      if (existing.inputAvailable) {
+        return;
+      }
+
+      const resolvedArguments = part.input !== undefined
+        ? mergeToolCallInput(existing.arguments, normalizeToolInputString(part.input))
+        : existing.arguments;
+      const resolvedInput = parseToolInputObject(resolvedArguments);
+      existing.arguments = resolvedArguments;
+      existing.inputAvailable = true;
+      if (part.providerExecuted !== undefined) {
+        existing.providerExecuted = part.providerExecuted;
+      }
+      if (dynamic) {
+        existing.dynamic = true;
+      }
+
+      sendSSE(controller, encoder, {
+        type: "tool-input-available",
+        toolCallId: part.toolCallId,
+        toolName: existing.name,
+        input: resolvedInput,
+        ...(existing.providerExecuted !== undefined
+          ? { providerExecuted: existing.providerExecuted }
+          : {}),
+        ...(existing.dynamic ? { dynamic: true } : {}),
+      });
+    };
 
     throwIfAborted(abortSignal);
 
@@ -172,6 +303,8 @@ export function processStream(
 
       switch (typedPart.type) {
         case "text-delta": {
+          closeReasoningSegment();
+          openTextSegment();
           state.accumulatedText += typedPart.text;
           sendSSE(controller, encoder, {
             type: "text-delta",
@@ -183,36 +316,40 @@ export function processStream(
         }
 
         case "reasoning-start": {
-          sendSSE(controller, encoder, {
-            type: "reasoning-start",
-            id: typeof typedPart.id === "string" ? typedPart.id : "reasoning",
-          });
+          closeTextSegment();
+          openReasoningSegment(normalizeReasoningId(typedPart));
           break;
         }
 
         case "reasoning-delta": {
+          closeTextSegment();
+          openReasoningSegment(normalizeReasoningId(typedPart));
           sendSSE(controller, encoder, {
             type: "reasoning-delta",
-            id: typeof typedPart.id === "string" ? typedPart.id : "reasoning",
+            id: normalizeReasoningId(typedPart),
             delta: typeof typedPart.delta === "string" ? typedPart.delta : "",
           });
           break;
         }
 
         case "reasoning-end": {
-          sendSSE(controller, encoder, {
-            type: "reasoning-end",
-            id: typeof typedPart.id === "string" ? typedPart.id : "reasoning",
-          });
+          closeTextSegment();
+          if (activeReasoningId === null) {
+            activeReasoningId = normalizeReasoningId(typedPart);
+          }
+          closeReasoningSegment();
           break;
         }
 
         case "tool-input-start": {
+          closeTextSegment();
+          closeReasoningSegment();
           const toolId = typedPart.id;
           state.toolCalls.set(toolId, {
             id: toolId,
             name: typedPart.toolName,
             arguments: "",
+            inputAvailable: false,
             providerExecuted: typedPart.providerExecuted,
             dynamic: typedPart.dynamic,
           });
@@ -228,6 +365,7 @@ export function processStream(
         }
 
         case "tool-input-delta": {
+          closeReasoningSegment();
           const toolId = typedPart.id;
           const tc = state.toolCalls.get(toolId);
           if (!tc) break;
@@ -242,6 +380,8 @@ export function processStream(
         }
 
         case "tool-call": {
+          closeTextSegment();
+          closeReasoningSegment();
           // tool-call fires when the full tool call is available
           const toolId = typedPart.toolCallId;
           const inputStr = normalizeToolInputString(typedPart.input);
@@ -251,6 +391,7 @@ export function processStream(
             id: toolId,
             name: typedPart.toolName,
             arguments: resolvedArguments,
+            inputAvailable: true,
             providerExecuted: typedPart.providerExecuted,
             dynamic: typedPart.dynamic,
           });
@@ -271,6 +412,15 @@ export function processStream(
         }
 
         case "tool-result": {
+          closeTextSegment();
+          closeReasoningSegment();
+          ensureToolLifecycle({
+            toolCallId: typedPart.toolCallId,
+            toolName: typedPart.toolName,
+            input: typedPart.input,
+            providerExecuted: typedPart.providerExecuted,
+            dynamic: typedPart.dynamic,
+          });
           const isError = typedPart.isError === true;
           logProviderToolPart("tool-result", {
             toolCallId: typedPart.toolCallId,
@@ -328,6 +478,15 @@ export function processStream(
         }
 
         case "tool-error": {
+          closeTextSegment();
+          closeReasoningSegment();
+          ensureToolLifecycle({
+            toolCallId: typedPart.toolCallId,
+            toolName: typedPart.toolName,
+            input: typedPart.input,
+            providerExecuted: typedPart.providerExecuted,
+            dynamic: typedPart.dynamic,
+          });
           logProviderToolPart("tool-error", {
             toolCallId: typedPart.toolCallId,
             toolName: typedPart.toolName,
@@ -358,6 +517,8 @@ export function processStream(
         }
 
         case "finish": {
+          closeTextSegment();
+          closeReasoningSegment();
           state.finishReason = typedPart.finishReason ?? null;
           if (typedPart.totalUsage) {
             const input = typedPart.totalUsage.inputTokens ?? 0;
@@ -373,6 +534,8 @@ export function processStream(
         }
 
         case "error": {
+          closeTextSegment();
+          closeReasoningSegment();
           logger.warn("Runtime stream error:", typedPart.error);
           sendSSE(controller, encoder, {
             type: "error",

package/src/src/agent/runtime/index.ts

@@ -488,8 +488,6 @@ export class AgentRuntime {
               model: effectiveModel,
             },
           });
-          sendSSE(controller, encoder, { type: "text-start", id: textPartId });
-
           const response = await this.executeAgentLoopStreaming(
             systemPrompt,
             memoryMessages,
@@ -510,7 +508,6 @@ export class AgentRuntime {
           callbacks?.onFinish?.(response);
           throwIfAborted(streamAbortSignal);
 
-          sendSSE(controller, encoder, { type: "text-end", id: textPartId });
           sendSSE(controller, encoder, { type: "message-finish" });
           closeSSEStream(controller);
         } catch (error) {

package/src/src/utils/version-constant.ts

@@ -1,3 +1,3 @@
 // Keep in sync with deno.json version.
 // scripts/release.ts updates this constant during releases.
-export const VERSION = "0.1.199";
+export const VERSION = "0.1.201";