veryfront 0.1.146 → 0.1.147

package/src/src/mcp/task-store.ts

@@ -0,0 +1,137 @@
+import * as dntShim from "../../_dnt.shims.js";
+export interface Task {
+  taskId: string;
+  status: "working" | "input_required" | "completed" | "failed" | "cancelled";
+  statusMessage?: string;
+  createdAt: string;
+  lastUpdatedAt: string;
+  ttl: number;
+  pollInterval?: number;
+}
+
+const TERMINAL_STATUSES = new Set(["completed", "failed", "cancelled"]);
+const DEFAULT_POLL_INTERVAL = 2000;
+const SWEEP_INTERVAL_MS = 30_000;
+const MAX_TASKS = 1000;
+
+export class TaskStore {
+  private tasks = new Map<string, Task>();
+  private results = new Map<string, unknown>();
+  private lastSweep = 0;
+
+  create(ttl: number): Task {
+    this.lazySweep();
+    if (this.tasks.size >= MAX_TASKS) {
+      this.evictOldest();
+    }
+
+    const now = new Date().toISOString();
+    const task: Task = {
+      taskId: dntShim.crypto.randomUUID(),
+      status: "working",
+      createdAt: now,
+      lastUpdatedAt: now,
+      ttl,
+      pollInterval: DEFAULT_POLL_INTERVAL,
+    };
+    this.tasks.set(task.taskId, task);
+    return task;
+  }
+
+  get(taskId: string): Task | undefined {
+    const task = this.tasks.get(taskId);
+    if (task && this.isExpired(task)) {
+      this.tasks.delete(taskId);
+      this.results.delete(taskId);
+      return undefined;
+    }
+    return task;
+  }
+
+  complete(taskId: string, result: unknown): void {
+    const task = this.tasks.get(taskId);
+    if (!task || TERMINAL_STATUSES.has(task.status)) return;
+    task.status = "completed";
+    task.lastUpdatedAt = new Date().toISOString();
+    this.results.set(taskId, result);
+  }
+
+  fail(taskId: string, message: string): void {
+    const task = this.tasks.get(taskId);
+    if (!task || TERMINAL_STATUSES.has(task.status)) return;
+    task.status = "failed";
+    task.statusMessage = message;
+    task.lastUpdatedAt = new Date().toISOString();
+  }
+
+  cancel(taskId: string): boolean {
+    const task = this.tasks.get(taskId);
+    if (!task || TERMINAL_STATUSES.has(task.status)) return false;
+    task.status = "cancelled";
+    task.statusMessage = "The task was cancelled by request.";
+    task.lastUpdatedAt = new Date().toISOString();
+    return true;
+  }
+
+  getResult(taskId: string): unknown | undefined {
+    const task = this.get(taskId);
+    if (!task || !TERMINAL_STATUSES.has(task.status)) return undefined;
+    return this.results.get(taskId);
+  }
+
+  list(): Task[] {
+    this.lazySweep();
+    return Array.from(this.tasks.values());
+  }
+
+  clear(): void {
+    this.tasks.clear();
+    this.results.clear();
+  }
+
+  private isExpired(task: Task): boolean {
+    return Date.now() - new Date(task.createdAt).getTime() > task.ttl;
+  }
+
+  private lazySweep(): void {
+    const now = Date.now();
+    if (now - this.lastSweep < SWEEP_INTERVAL_MS) return;
+    this.lastSweep = now;
+    this.sweep();
+  }
+
+  private sweep(): void {
+    for (const [id, task] of this.tasks) {
+      if (this.isExpired(task)) {
+        this.tasks.delete(id);
+        this.results.delete(id);
+      }
+    }
+  }
+
+  private evictOldest(): void {
+    // Evict the oldest terminal task, or the oldest task overall
+    let oldestTerminal: string | undefined;
+    let oldestAny: string | undefined;
+    let oldestTerminalTime = Infinity;
+    let oldestAnyTime = Infinity;
+
+    for (const [id, task] of this.tasks) {
+      const created = new Date(task.createdAt).getTime();
+      if (created < oldestAnyTime) {
+        oldestAnyTime = created;
+        oldestAny = id;
+      }
+      if (TERMINAL_STATUSES.has(task.status) && created < oldestTerminalTime) {
+        oldestTerminalTime = created;
+        oldestTerminal = id;
+      }
+    }
+
+    const toEvict = oldestTerminal ?? oldestAny;
+    if (toEvict) {
+      this.tasks.delete(toEvict);
+      this.results.delete(toEvict);
+    }
+  }
+}

package/src/src/modules/react-loader/ssr-module-loader/cache/memory.ts

@@ -74,10 +74,12 @@ const RATE_LIMIT_BYPASS_PROJECTS = new Set(["__single__"]);
 
 /**
  * Project ID prefixes that bypass per-project rate limiting.
- * - "local-": Used for compiled binary CLI, local filesystem projects, and tests
+ * - "local-": Used for compiled binary CLI, local filesystem projects
  *   where there's no multi-tenancy and noisy-neighbor protection isn't needed.
+ * - "test_": Used by integration tests (TestContext.projectId) where there's
+ *   no multi-tenancy concern and rate limiting causes flaky failures under CI load.
  */
-const RATE_LIMIT_BYPASS_PREFIXES = ["local-"];
+const RATE_LIMIT_BYPASS_PREFIXES = ["local-", "test_"];
 
 /**
  * Attempt to acquire a project-level transform slot immediately.

package/src/src/server/handlers/request/agent-stream.handler.ts

@@ -24,8 +24,9 @@ import {
   agentRunSessionManager,
 } from "../../../internal-agents/session-manager.js";
 import {
+  InternalAgentStreamRequestSchema,
   type RuntimeAgentSourceContext,
-  RuntimeRunAgentInputSchema,
+  toRuntimeRunAgentInput,
 } from "../../../internal-agents/schema.js";
 import { BaseHandler } from "../response/base.js";
 import type { HandlerContext, HandlerMetadata, HandlerPriority, HandlerResult } from "../types.js";
@@ -162,7 +163,7 @@ export class AgentStreamHandler extends BaseHandler {
           req,
           INTERNAL_AGENT_STREAM_MAX_BODY_BYTES,
         );
-        const payload = RuntimeRunAgentInputSchema.parse(JSON.parse(rawBody));
+        const payload = InternalAgentStreamRequestSchema.parse(JSON.parse(rawBody));
         await verifyControlPlaneRequest(req, ctx, rawBody, {
           expectedSubject: payload.runId,
           expectedSurface: "studio",
@@ -195,8 +196,9 @@ export class AgentStreamHandler extends BaseHandler {
               return this.respond(builder.json({ error: "Agent not found" }, 404));
             }
 
+            const runtimeInput = toRuntimeRunAgentInput(payload);
             const response = await createRuntimeAgentStreamResponse(
-              payload,
+              runtimeInput,
               agent as Agent,
               this.deps,
             );

package/src/src/tool/remote-mcp.ts

@@ -23,6 +23,10 @@ interface JsonRpcCallToolContentItem {
   text?: unknown;
 }
 
+interface SseEvent {
+  data: string[];
+}
+
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null;
 }
@@ -126,6 +130,67 @@ function extractJsonRpcErrorMessage(payload: Record<string, unknown>): string {
   return "Remote MCP server returned an error";
 }
 
+function parseSseEvents(text: string): SseEvent[] {
+  const events: SseEvent[] = [];
+  let currentEvent: SseEvent = { data: [] };
+
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rawLine.trimEnd();
+
+    if (line.length === 0) {
+      if (currentEvent.data.length > 0) {
+        events.push(currentEvent);
+      }
+      currentEvent = { data: [] };
+      continue;
+    }
+
+    if (line.startsWith(":")) {
+      continue;
+    }
+
+    if (line.startsWith("data:")) {
+      currentEvent.data.push(line.slice(5).trimStart());
+    }
+  }
+
+  if (currentEvent.data.length > 0) {
+    events.push(currentEvent);
+  }
+
+  return events;
+}
+
+function parseJsonRpcSsePayload(text: string): unknown {
+  const parsedPayloads = parseSseEvents(text)
+    .map((event) => parseJsonText(event.data.join("\n")))
+    .filter((payload): payload is unknown => payload !== undefined);
+
+  const jsonRpcPayload = parsedPayloads.find(
+    (payload) => isRecord(payload) && ("result" in payload || "error" in payload),
+  );
+
+  if (jsonRpcPayload !== undefined) {
+    return jsonRpcPayload;
+  }
+
+  if (parsedPayloads.length > 0) {
+    return parsedPayloads[0];
+  }
+
+  throw new Error("Remote MCP SSE response did not include a JSON-RPC payload");
+}
+
+async function parseJsonRpcResponse(response: dntShim.Response): Promise<unknown> {
+  const contentType = response.headers.get("content-type")?.toLowerCase() ?? "";
+
+  if (contentType.includes("text/event-stream")) {
+    return parseJsonRpcSsePayload(await response.text());
+  }
+
+  return await response.json();
+}
+
 async function resolveValue<T>(
   value: ResolvableValue<T>,
   context?: ToolExecutionContext,
@@ -143,9 +208,29 @@ async function resolveHeaders(
   const resolvedHeaders = headers ? await resolveValue(headers, context) : undefined;
   const finalHeaders = new dntShim.Headers(resolvedHeaders);
   finalHeaders.set("Content-Type", "application/json");
+  finalHeaders.set("Accept", mergeAcceptHeader(finalHeaders.get("Accept")));
   return finalHeaders;
 }
 
+function mergeAcceptHeader(existingAccept: string | null): string {
+  const requiredTypes = ["application/json", "text/event-stream"];
+  const existingTypes = (existingAccept ?? "")
+    .split(",")
+    .map((entry) => entry.trim())
+    .filter((entry) => entry.length > 0);
+  const existingKeys = new Set(
+    existingTypes.map((entry) => entry.split(";")[0]?.trim().toLowerCase()).filter(Boolean),
+  );
+
+  for (const requiredType of requiredTypes) {
+    if (!existingKeys.has(requiredType)) {
+      existingTypes.push(requiredType);
+    }
+  }
+
+  return existingTypes.join(", ");
+}
+
 async function postJsonRpc(
   endpoint: string,
   headers: dntShim.Headers,
@@ -165,7 +250,7 @@ async function postJsonRpc(
     );
   }
 
-  return await response.json();
+  return await parseJsonRpcResponse(response);
 }
 
 function getJsonRpcResult(payload: unknown): unknown {

package/src/src/tool/types.ts

@@ -61,6 +61,8 @@ export interface ToolExecutionContext {
   projectId?: string;
   /** End-user identity for per-user token resolution in integration tools */
   endUserId?: string;
+  /** Progress token for sending progress notifications (MCP 2025-11-25) */
+  progressToken?: string | number;
   /** Additional context */
   [key: string]: unknown;
   /** Blob storage access (if configured in workflow) */

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.146";
+export const VERSION = "0.1.147";