veryfront 0.1.209 → 0.1.211

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

@@ -99,6 +99,59 @@ export function captureStreamedToolCallInput(toolCall) {
         ...(error ? { parseError: error } : {}),
     };
 }
+/**
+ * A streamed tool call is "incomplete" when the provider stream terminated
+ * (abort, stall, timeout, transport error) before the SDK emitted the
+ * finalizing `tool-call` event that sets `inputAvailable: true`. In that state
+ * `arguments` only holds partial JSON fragments from `tool-input-delta` events,
+ * so the tool call is NOT a committed model choice and must not be parsed or
+ * executed. This is semantically distinct from a parse failure on a finalized
+ * tool call (`inputAvailable: true` but malformed JSON — which only happens on
+ * genuine provider bugs) and needs to be reported as a stream-termination
+ * error rather than a tool-argument error.
+ */
+export function isStreamedToolCallIncomplete(toolCall) {
+    return toolCall.inputAvailable !== true;
+}
+/**
+ * Classify and build the persisted `MessagePart` for a single streamed tool
+ * call. Pure function — no logging, no SSE, no memory. Callers decide what to
+ * do with the result so this stays unit-testable.
+ *
+ * The resulting `part` is always pushed into the assistant message so the
+ * conversation history is transparent: even incomplete tool calls leave a
+ * visible trace with their partial `inputText`. What differs is the caller's
+ * error-surfacing behavior (log warning, SSE event, tool-result error).
+ */
+export function materializeStreamedToolCall(tc) {
+    const basePart = {
+        type: `tool-${tc.name}`,
+        toolCallId: tc.id,
+        toolName: tc.name,
+        args: {},
+        ...(tc.arguments.length > 0 ? { inputText: tc.arguments } : {}),
+    };
+    if (isStreamedToolCallIncomplete(tc)) {
+        return {
+            kind: "incomplete",
+            part: basePart,
+            partialArgumentsLength: tc.arguments.length,
+            partialArgumentsPreview: tc.arguments.slice(0, 200),
+        };
+    }
+    const capturedInput = captureStreamedToolCallInput(tc);
+    const part = {
+        type: `tool-${tc.name}`,
+        toolCallId: tc.id,
+        toolName: tc.name,
+        args: capturedInput.args,
+        ...(capturedInput.inputText ? { inputText: capturedInput.inputText } : {}),
+    };
+    if (capturedInput.parseError) {
+        return { kind: "parse-error", part, parseError: capturedInput.parseError };
+    }
+    return { kind: "complete", part };
+}
 function isToolResultPart(part) {
     return part.type === "tool-result" && "result" in part;
 }
@@ -649,20 +702,35 @@ export class AgentRuntime {
             if (state.accumulatedText)
                 streamParts.push({ type: "text", text: state.accumulatedText });
             for (const tc of state.toolCalls.values()) {
-                const capturedInput = captureStreamedToolCallInput(tc);
-                if (capturedInput.parseError) {
+                const materialized = materializeStreamedToolCall(tc);
+                streamParts.push(materialized.part);
+                if (materialized.kind === "incomplete") {
+                    // Stream terminated before the provider emitted the finalizing
+                    // `tool-call` event for this block. The model never committed this
+                    // tool use. Surface the failure via SSE so the live client can
+                    // react, and leave the partial fragment under `inputText` in the
+                    // persisted part above so the history is replayable and transparent.
+                    logger.warn("Streamed tool call terminated before tool-call event", {
+                        toolCallId: tc.id,
+                        toolName: tc.name,
+                        partialArgumentsLength: materialized.partialArgumentsLength,
+                        partialArgumentsPreview: materialized.partialArgumentsPreview,
+                    });
+                    const dynamicIncomplete = isDynamicTool(tc.name);
+                    sendSSE(controller, encoder, {
+                        type: "tool-input-error",
+                        toolCallId: tc.id,
+                        errorText: `Stream terminated before tool-call event fired for "${tc.name}". ` +
+                            `Received ${materialized.partialArgumentsLength} chars of partial tool-input deltas.`,
+                        ...(dynamicIncomplete ? { dynamic: true } : {}),
+                    });
+                }
+                else if (materialized.kind === "parse-error") {
                     logger.warn("Failed to parse streamed tool arguments", {
                         toolCallId: tc.id,
-                        error: capturedInput.parseError,
+                        error: materialized.parseError,
                     });
                 }
-                streamParts.push({
-                    type: `tool-${tc.name}`,
-                    toolCallId: tc.id,
-                    toolName: tc.name,
-                    args: capturedInput.args,
-                    ...(capturedInput.inputText ? { inputText: capturedInput.inputText } : {}),
-                });
             }
             const assistantMessage = {
                 id: `msg_${Date.now()}_${step}`,
@@ -711,6 +779,23 @@ export class AgentRuntime {
                 streamedToolCalls.some((tc) => tc.name === LOAD_SKILL_TOOL_ID);
             for (const tc of streamedToolCalls) {
                 throwIfAborted(abortSignal);
+                if (isStreamedToolCallIncomplete(tc)) {
+                    // Stream ended before the provider finalized this tool call. We
+                    // cannot execute it — record a distinct stream-termination error
+                    // (not a tool-argument parse error) so the parent step and any
+                    // upstream orchestrator (e.g. the child-fork watchdog) see a
+                    // completed step with a clearly-labelled failure and can recover.
+                    const incompleteToolCall = {
+                        id: tc.id,
+                        name: tc.name,
+                        args: {},
+                        ...(tc.arguments.length > 0 ? { inputText: tc.arguments } : {}),
+                        status: "pending",
+                    };
+                    await this.recordToolError(incompleteToolCall, `Stream terminated before tool-call event fired for "${tc.name}". ` +
+                        `Received ${tc.arguments.length} chars of partial tool-input deltas.`, controller, encoder, currentMessages, toolCalls);
+                    continue;
+                }
                 const capturedInput = captureStreamedToolCallInput(tc);
                 const toolCall = {
                     id: tc.id,

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

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.1.209";
+export declare const VERSION = "0.1.211";
 //# 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.209";
+export const VERSION = "0.1.211";

package/package.json

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

package/src/cli/mcp/advanced-tools.ts

@@ -21,6 +21,9 @@ import {
   vfListLocalProjects,
   vfListRoutes,
 } from "./tools/project-tools.js";
+import { vfBuild } from "./tools/build-tool.js";
+import { vfRunLint } from "./tools/run-lint-tool.js";
+import { vfRunTests } from "./tools/run-tests-tool.js";
 import { vfGetConventions, vfScaffold } from "./tools/scaffold-tools.js";
 import { vfGetSkillReference, vfGetSkills } from "./tools/skill-tools.js";
 import { cicdTools } from "./tools/cicd-tools.js";
@@ -44,8 +47,11 @@ export const advancedTools: MCPTool[] = [
   vfPreviewRoute,
   vfGetDebugContext,
   vfGetComponentTree,
+  vfBuild,
   vfHotReload,
   vfTriggerHmr,
   vfWaitForReady,
+  vfRunLint,
   vfGetFlywheelStatus,
+  vfRunTests,
 ];

package/src/cli/mcp/standalone.ts

@@ -411,6 +411,62 @@ export class StandaloneMCPServer {
           }
         },
       },
+      {
+        name: "vf_run_tests",
+        description: "Run the project's test suite and get structured pass/fail results. " +
+          "Returns a summary with total, passed, failed, skipped counts and failure details " +
+          "including file path, test name, error message, and line number. " +
+          "Do not use for lint checks — use vf_run_lint instead.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            filter: {
+              type: "string",
+              description: "Filter tests by name pattern",
+            },
+            parallel: {
+              type: "boolean",
+              description: "Run tests in parallel",
+            },
+            timeout: {
+              type: "number",
+              description:
+                "Maximum time to wait for test completion in milliseconds (default: 300000)",
+            },
+          },
+        },
+        async execute(args) {
+          const { executeTests } = await import("./tools/run-tests-tool.js");
+          return executeTests({
+            filter: args.filter as string | undefined,
+            parallel: args.parallel as boolean | undefined,
+            timeout: args.timeout as number | undefined,
+          });
+        },
+      },
+      {
+        name: "vf_run_lint",
+        description:
+          "Run the linter. Returns structured diagnostics with file, line, column, rule code, and message. " +
+          "Do not use for test results — use vf_run_tests instead. " +
+          "Do not use for compile/runtime errors — use vf_get_errors instead.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            timeout: {
+              type: "number",
+              description:
+                "Maximum time to wait for lint completion in milliseconds (default: 120000)",
+            },
+          },
+        },
+        async execute(args) {
+          const { executeLint } = await import("./tools/run-lint-tool.js");
+          return executeLint({
+            timeout: args.timeout as number | undefined,
+          });
+        },
+      },
       ...this.createContext7Tools(),
     ];
   }

package/src/cli/mcp/tools/build-tool.ts

@@ -0,0 +1,115 @@
+/**
+ * MCP tool for production builds.
+ */
+
+import { z } from "zod";
+import { cwd } from "../../../src/platform/index.js";
+import { join } from "../../../src/platform/compat/path/index.js";
+import { buildProduction } from "../../../src/build/index.js";
+import { withSpan } from "../../../src/observability/tracing/otlp-setup.js";
+import type { MCPTool } from "../tools.js";
+
+// ============================================================================
+// Tool: vf_build
+// ============================================================================
+
+const buildInput = z.object({
+  outputDir: z
+    .string()
+    .optional()
+    .describe("Output directory for the build. Defaults to '<projectDir>/dist'."),
+  splitting: z
+    .boolean()
+    .optional()
+    .default(true)
+    .describe("Enable code splitting. Defaults to true."),
+  compress: z
+    .boolean()
+    .optional()
+    .default(true)
+    .describe("Enable compression (gzip/brotli). Defaults to true."),
+  ssg: z
+    .boolean()
+    .optional()
+    .default(true)
+    .describe("Enable static site generation. Defaults to true."),
+  dryRun: z
+    .boolean()
+    .optional()
+    .default(false)
+    .describe("Preview the build without writing files to disk. Defaults to false."),
+});
+
+type BuildInput = z.infer<typeof buildInput>;
+
+interface BuildResult {
+  success: boolean;
+  pages?: number;
+  chunks?: number;
+  assets?: number;
+  totalSize?: number;
+  duration_ms?: number;
+  outputDir?: string;
+  dryRun?: boolean;
+  ssgPaths?: string[];
+  error?: string;
+}
+
+export const vfBuild: MCPTool<BuildInput, BuildResult> = {
+  name: "vf_build",
+  title: "Production Build",
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+  },
+  description: "Use this when you need to run a production build for the current project. " +
+    "Bundles, optimises, and writes output to the dist directory. " +
+    "Use dryRun=true to preview the build without writing files. " +
+    "Do not use for development — use the dev server tools instead. " +
+    "Do not use for lint checks — use vf_run_lint instead.",
+  inputSchema: buildInput,
+  execute: (input) =>
+    withSpan(
+      "cli.mcp.tool.vf_build",
+      async () => {
+        const projectDir = cwd();
+        const outputDir = input.outputDir ?? join(projectDir, "dist");
+        const startTime = Date.now();
+
+        try {
+          const stats = await buildProduction({
+            projectDir,
+            outputDir,
+            enableSplitting: input.splitting,
+            enableCompression: input.compress,
+            ssg: input.ssg,
+            dryRun: input.dryRun,
+          });
+
+          const duration_ms = Date.now() - startTime;
+
+          return {
+            success: true,
+            pages: stats.pages,
+            chunks: stats.chunks,
+            assets: stats.assets,
+            totalSize: stats.totalSize,
+            duration_ms,
+            outputDir,
+            dryRun: input.dryRun,
+            ssgPaths: stats.ssgPaths,
+          };
+        } catch (error) {
+          const duration_ms = Date.now() - startTime;
+          return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+            duration_ms,
+          };
+        }
+      },
+      { "tool.dryRun": input.dryRun },
+    ),
+};

package/src/cli/mcp/tools/run-lint-tool.ts

@@ -0,0 +1,69 @@
+/**
+ * MCP tool: vf_run_lint
+ *
+ * Runs the linter via subprocess and returns structured diagnostics.
+ * Reuses parseLintJsonOutput from the CLI lint command.
+ */
+import * as dntShim from "../../../_dnt.shims.js";
+
+
+import { z } from "zod";
+import type { MCPTool } from "../tools.js";
+import { type LintResult, parseLintJsonOutput } from "../../commands/lint/command.js";
+
+const runLintInput = z.object({
+  timeout: z.number().optional().default(120000).describe(
+    "Maximum time to wait for lint completion in milliseconds. Defaults to 120000 (2 minutes).",
+  ),
+});
+
+type RunLintInput = z.infer<typeof runLintInput>;
+
+/** Spawn deno lint and return structured results. Exported for standalone reuse. */
+export async function executeLint(
+  input: { timeout?: number } = {},
+): Promise<LintResult> {
+  const cmd = new dntShim.Deno.Command("deno", {
+    args: ["lint", "--json"],
+    stdout: "piped",
+    stderr: "piped",
+  });
+
+  const child = cmd.spawn();
+  const timeoutMs = input.timeout ?? 120000;
+
+  const result = await Promise.race([
+    child.output(),
+    new Promise<never>((_, reject) => {
+      const timer = dntShim.setTimeout(() => {
+        try {
+          child.kill();
+        } catch {
+          // Process may have already exited
+        }
+        reject(new Error(`Lint execution timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      dntShim.Deno.unrefTimer(timer);
+    }),
+  ]);
+
+  const stdout = new TextDecoder().decode(result.stdout);
+  return parseLintJsonOutput(stdout, result.code);
+}
+
+export const vfRunLint: MCPTool<RunLintInput, LintResult> = {
+  name: "vf_run_lint",
+  title: "Run Lint",
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+  },
+  description: "Use this when you need to check for lint issues in the project. " +
+    "Returns structured diagnostics with file path, line, column, rule code, and message for each issue. " +
+    "Do not use for test results — use vf_run_tests instead. " +
+    "Do not use for compile/runtime errors — use vf_get_errors instead.",
+  inputSchema: runLintInput,
+  execute: (input) => executeLint(input),
+};

package/src/cli/mcp/tools/run-tests-tool.ts

@@ -0,0 +1,101 @@
+/**
+ * MCP tool: vf_run_tests
+ *
+ * Runs the project test suite via subprocess and returns structured results.
+ * Reuses parseTestOutput from the CLI test command.
+ */
+import * as dntShim from "../../../_dnt.shims.js";
+
+
+import { z } from "zod";
+import type { MCPTool } from "../../../src/mcp/index.js";
+import { parseTestOutput, type TestResult } from "../../commands/test/command.js";
+
+const runTestsInput = z.object({
+  filter: z.string().optional().describe(
+    "Filter tests by name pattern. Example: 'router' to run only tests matching 'router'.",
+  ),
+  parallel: z.boolean().optional().default(false).describe(
+    "Run tests in parallel. Defaults to false.",
+  ),
+  timeout: z.number().optional().default(300000).describe(
+    "Maximum time to wait for test completion in milliseconds. Defaults to 300000 (5 minutes).",
+  ),
+});
+
+type RunTestsInput = z.infer<typeof runTestsInput>;
+
+/** Build the deno test command args from input options. */
+export function buildTestArgs(input: { filter?: string; parallel?: boolean }): string[] {
+  return [
+    "test",
+    "--no-check",
+    "--allow-all",
+    "--unstable-worker-options",
+    "--unstable-net",
+    ...(input.parallel ? ["--parallel"] : []),
+    ...(input.filter ? [`--filter=${input.filter}`] : []),
+  ];
+}
+
+/** Env vars required for deterministic test runs. */
+export const TEST_ENV: Record<string, string> = {
+  VF_DISABLE_LRU_INTERVAL: "1",
+  SSR_TRANSFORM_PER_PROJECT_LIMIT: "0",
+  REVALIDATION_PER_PROJECT_LIMIT: "0",
+  NODE_ENV: "production",
+  LOG_FORMAT: "text",
+};
+
+/** Spawn deno test and return structured results. Exported for standalone reuse. */
+export async function executeTests(
+  input: { filter?: string; parallel?: boolean; timeout?: number },
+): Promise<TestResult> {
+  const cmd = new dntShim.Deno.Command("deno", {
+    args: buildTestArgs(input),
+    stdout: "piped",
+    stderr: "piped",
+    env: TEST_ENV,
+  });
+
+  const child = cmd.spawn();
+  const timeoutMs = input.timeout ?? 300000;
+
+  const result = await Promise.race([
+    child.output(),
+    new Promise<never>((_, reject) => {
+      const timer = dntShim.setTimeout(() => {
+        try {
+          child.kill();
+        } catch {
+          // Process may have already exited
+        }
+        reject(new Error(`Test execution timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      // Don't prevent process exit while waiting
+      dntShim.Deno.unrefTimer(timer);
+    }),
+  ]);
+
+  const stdout = new TextDecoder().decode(result.stdout);
+  const stderr = new TextDecoder().decode(result.stderr);
+  return parseTestOutput(stdout + "\n" + stderr, result.code);
+}
+
+export const vfRunTests: MCPTool<RunTestsInput, TestResult> = {
+  name: "vf_run_tests",
+  title: "Run Tests",
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+  },
+  description:
+    "Use this when you need to run the project's test suite and get structured pass/fail results. " +
+    "Returns a summary with total, passed, failed, skipped counts and failure details including " +
+    "file path, test name, error message, and line number. " +
+    "Do not use for lint checks — use vf_run_lint instead.",
+  inputSchema: runTestsInput,
+  execute: (input) => executeTests(input),
+};

package/src/deno.js

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

package/src/src/agent/data-stream.ts

@@ -26,14 +26,41 @@ export function stripLeadingEmptyObjectPlaceholder(rawArgs: string): string {
 }
 
 export function mergeToolInputDelta(currentArguments: string, nextDelta: string): string {
+  const normalizedDelta = nextDelta.trimStart();
+  const candidateDeltas = normalizedDelta.startsWith('"')
+    ? [normalizedDelta, `{${normalizedDelta}`]
+    : [normalizedDelta];
+
   if (currentArguments === "{}") {
-    const normalizedDelta = nextDelta.trimStart();
-    if (normalizedDelta.startsWith("{")) {
-      return normalizedDelta;
+    for (const candidate of candidateDeltas) {
+      if (candidate.startsWith("{")) {
+        return candidate;
+      }
+    }
+  }
+
+  if (nextDelta.length === 0) {
+    return currentArguments;
+  }
+
+  if (currentArguments.length === 0) {
+    return nextDelta;
+  }
+
+  for (const candidate of candidateDeltas) {
+    if (candidate === currentArguments || currentArguments.includes(candidate)) {
+      return currentArguments;
     }
 
-    if (normalizedDelta.startsWith('"')) {
-      return `{${normalizedDelta}`;
+    if (candidate.startsWith(currentArguments)) {
+      return candidate;
+    }
+
+    const maxOverlap = Math.min(currentArguments.length, candidate.length);
+    for (let overlap = maxOverlap; overlap > 0; overlap--) {
+      if (currentArguments.endsWith(candidate.slice(0, overlap))) {
+        return currentArguments + candidate.slice(overlap);
+      }
     }
   }