veryfront 0.1.151 → 0.1.154

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

@@ -15,6 +15,7 @@ import { serverLogger } from "../../utils/index.js";
 import { isAnyDebugEnabled } from "../../utils/constants/env.js";
 import { setActiveSpanAttributes, withSpan } from "../../observability/tracing/otlp-setup.js";
 import { getHostEnv } from "../../platform/compat/process.js";
+import { stringifyToolError, throwIfAborted } from "./error-utils.js";
 
 const logger = serverLogger.component("agent");
 
@@ -84,39 +85,6 @@ function normalizeToolInputObject(input: unknown): Record<string, unknown> {
   return {};
 }
 
-function createAbortError(reason?: unknown): Error {
-  if (reason instanceof Error) {
-    return reason;
-  }
-
-  return new DOMException(
-    typeof reason === "string" && reason.length > 0 ? reason : "The operation was aborted",
-    "AbortError",
-  );
-}
-
-function throwIfAborted(abortSignal?: AbortSignal): void {
-  if (abortSignal?.aborted) {
-    throw createAbortError(abortSignal.reason);
-  }
-}
-
-function stringifyToolError(output: unknown): string {
-  if (typeof output === "string" && output.length > 0) {
-    return output;
-  }
-
-  if (output instanceof Error && typeof output.message === "string" && output.message.length > 0) {
-    return output.message;
-  }
-
-  try {
-    return JSON.stringify(output);
-  } catch {
-    return String(output);
-  }
-}
-
 function summarizeDebugValue(value: unknown): unknown {
   if (value instanceof Error) {
     return {

package/src/src/agent/runtime/error-utils.ts

@@ -0,0 +1,32 @@
+export function createAbortError(reason?: unknown): Error {
+  if (reason instanceof Error) {
+    return reason;
+  }
+
+  return new DOMException(
+    typeof reason === "string" && reason.length > 0 ? reason : "The operation was aborted",
+    "AbortError",
+  );
+}
+
+export function throwIfAborted(abortSignal?: AbortSignal): void {
+  if (abortSignal?.aborted) {
+    throw createAbortError(abortSignal.reason);
+  }
+}
+
+export function stringifyToolError(error: unknown): string {
+  if (typeof error === "string" && error.length > 0) {
+    return error;
+  }
+
+  if (error instanceof Error && typeof error.message === "string" && error.message.length > 0) {
+    return error.message;
+  }
+
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return String(error);
+  }
+}

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

@@ -100,6 +100,7 @@ import {
 } from "../../skill/allowed-tools.js";
 import { resolveConfiguredAgentModel, resolveRuntimeModel } from "./model-resolution.js";
 import type { RuntimeGenerateToolResult } from "./runtime-tool-types.js";
+import { stringifyToolError, throwIfAborted } from "./error-utils.js";
 
 const logger = serverLogger.component("agent");
 const LOAD_SKILL_TOOL_ID = "load-skill";
@@ -108,23 +109,6 @@ type RuntimeToolFilterConfig = AgentConfig & {
   __vfAllowedRemoteTools?: string[];
 };
 
-function createAbortError(reason?: unknown): Error {
-  if (reason instanceof Error) {
-    return reason;
-  }
-
-  return new DOMException(
-    typeof reason === "string" && reason.length > 0 ? reason : "The operation was aborted",
-    "AbortError",
-  );
-}
-
-function throwIfAborted(abortSignal?: AbortSignal): void {
-  if (abortSignal?.aborted) {
-    throw createAbortError(abortSignal.reason);
-  }
-}
-
 function isAbortError(error: unknown, abortSignal?: AbortSignal): boolean {
   if (abortSignal?.aborted && error === abortSignal.reason) {
     return true;
@@ -133,22 +117,6 @@ function isAbortError(error: unknown, abortSignal?: AbortSignal): boolean {
   return error instanceof DOMException && error.name === "AbortError";
 }
 
-function stringifyToolError(error: unknown): string {
-  if (typeof error === "string" && error.length > 0) {
-    return error;
-  }
-
-  if (error instanceof Error && typeof error.message === "string" && error.message.length > 0) {
-    return error.message;
-  }
-
-  try {
-    return JSON.stringify(error);
-  } catch {
-    return String(error);
-  }
-}
-
 function getToolResultError(result: unknown): string | undefined {
   if (!result || typeof result !== "object" || !("error" in result)) {
     return undefined;

package/src/src/agent/runtime-ag-ui-contract.ts

@@ -0,0 +1,144 @@
+import { z } from "zod";
+
+const AGENT_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
+const MAX_TOOL_PARAMETERS_BYTES = 16_384;
+const MAX_CONTEXT_ITEM_BYTES = 16_384;
+const MAX_CONTEXT_TOTAL_BYTES = 65_536;
+const MAX_FORWARDED_PROPS_BYTES = 65_536;
+const MAX_RUNTIME_MESSAGES = 100;
+
+const encoder = new TextEncoder();
+
+function isWithinJsonSizeLimit(value: unknown, maxBytes: number): boolean {
+  try {
+    return encoder.encode(JSON.stringify(value)).byteLength <= maxBytes;
+  } catch {
+    return false;
+  }
+}
+
+export const AgUiRuntimeRunIdSchema = z.string().min(1).max(128).regex(AGENT_ID_PATTERN);
+
+export const AgUiRuntimeInjectedToolSchema = z.object({
+  name: z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(
+      /^[a-zA-Z][a-zA-Z0-9._:-]*$/,
+      "Tool names must start with a letter and use a valid client-tool format",
+    ),
+  description: z.string().max(1024).optional(),
+  parameters: z.record(z.string(), z.unknown()).optional().refine(
+    (value) => value === undefined || isWithinJsonSizeLimit(value, MAX_TOOL_PARAMETERS_BYTES),
+    { message: "Tool parameters must be less than 16 KB" },
+  ),
+});
+
+export const AgUiRuntimeContextItemSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("text"),
+    title: z.string().max(256).optional(),
+    text: z.string().max(MAX_CONTEXT_ITEM_BYTES),
+  }),
+  z.object({
+    type: z.literal("json"),
+    title: z.string().max(256).optional(),
+    data: z.record(z.string(), z.unknown()).refine(
+      (value) => isWithinJsonSizeLimit(value, MAX_CONTEXT_ITEM_BYTES),
+      { message: "JSON context item must be less than 16 KB" },
+    ),
+  }),
+  z.object({
+    type: z.literal("resource"),
+    title: z.string().max(256).optional(),
+    uri: z.string().max(2048),
+    mimeType: z.string().max(256).optional(),
+    text: z.string().max(MAX_CONTEXT_ITEM_BYTES).optional(),
+  }),
+]);
+
+const RuntimeMessageExtensionFieldsSchema = {
+  name: z.string().max(256).optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+  createdAt: z.string().optional(),
+} as const;
+
+export const AgUiRuntimeToolFunctionCallSchema = z.object({
+  name: AgUiRuntimeInjectedToolSchema.shape.name,
+  arguments: z.string().max(MAX_TOOL_PARAMETERS_BYTES),
+}).strict();
+
+export const AgUiRuntimeToolCallSchema = z.object({
+  id: z.string().min(1).max(128),
+  type: z.literal("function"),
+  function: AgUiRuntimeToolFunctionCallSchema,
+}).strict();
+
+export const AgUiRuntimeSystemMessageSchema = z.object({
+  id: z.string().min(1),
+  role: z.literal("system"),
+  content: z.string(),
+  ...RuntimeMessageExtensionFieldsSchema,
+}).strict();
+
+export const AgUiRuntimeUserMessageSchema = z.object({
+  id: z.string().min(1),
+  role: z.literal("user"),
+  content: z.string(),
+  ...RuntimeMessageExtensionFieldsSchema,
+}).strict();
+
+export const AgUiRuntimeAssistantMessageSchema = z.object({
+  id: z.string().min(1),
+  role: z.literal("assistant"),
+  content: z.string().optional(),
+  toolCalls: z.array(AgUiRuntimeToolCallSchema).optional(),
+  ...RuntimeMessageExtensionFieldsSchema,
+}).strict();
+
+export const AgUiRuntimeToolMessageSchema = z.object({
+  id: z.string().min(1),
+  role: z.literal("tool"),
+  toolCallId: z.string().min(1).max(128),
+  content: z.string(),
+  error: z.string().optional(),
+  ...RuntimeMessageExtensionFieldsSchema,
+}).strict();
+
+export const AgUiRuntimeMessageSchema = z.discriminatedUnion("role", [
+  AgUiRuntimeSystemMessageSchema,
+  AgUiRuntimeUserMessageSchema,
+  AgUiRuntimeAssistantMessageSchema,
+  AgUiRuntimeToolMessageSchema,
+]);
+
+export const AgUiRuntimeContextSchema = z.union([
+  z.object({
+    description: z.string().max(1024),
+    value: z.string().max(MAX_CONTEXT_ITEM_BYTES),
+  }),
+  AgUiRuntimeContextItemSchema,
+]);
+
+export const AgUiRuntimeRequestSchema = z.object({
+  threadId: z.string().uuid(),
+  runId: AgUiRuntimeRunIdSchema,
+  parentRunId: AgUiRuntimeRunIdSchema.optional(),
+  state: z.unknown().optional(),
+  messages: z.array(AgUiRuntimeMessageSchema).max(MAX_RUNTIME_MESSAGES),
+  tools: z.array(AgUiRuntimeInjectedToolSchema).max(50).default([]),
+  context: z.array(AgUiRuntimeContextSchema).max(10).default([]).refine(
+    (value) => isWithinJsonSizeLimit(value, MAX_CONTEXT_TOTAL_BYTES),
+    { message: "context must be less than 64 KB total" },
+  ),
+  forwardedProps: z.record(z.string(), z.unknown()).optional().refine(
+    (value) => value === undefined || isWithinJsonSizeLimit(value, MAX_FORWARDED_PROPS_BYTES),
+    { message: "forwardedProps must be less than 64 KB" },
+  ),
+});
+
+export type AgUiRuntimeInjectedTool = z.infer<typeof AgUiRuntimeInjectedToolSchema>;
+export type AgUiRuntimeContextItem = z.infer<typeof AgUiRuntimeContextItemSchema>;
+export type AgUiRuntimeMessage = z.infer<typeof AgUiRuntimeMessageSchema>;
+export type AgUiRuntimeRequest = z.infer<typeof AgUiRuntimeRequestSchema>;

package/src/src/internal-agents/schema.ts

@@ -1,9 +1,17 @@
 import { z } from "zod";
+import {
+  AgUiRuntimeContextItemSchema,
+  AgUiRuntimeContextSchema,
+  AgUiRuntimeInjectedToolSchema,
+  type AgUiRuntimeMessage,
+  AgUiRuntimeMessageSchema,
+  type AgUiRuntimeRequest,
+  AgUiRuntimeRequestSchema,
+  AgUiRuntimeRunIdSchema,
+  AgUiRuntimeToolCallSchema,
+} from "../agent/runtime-ag-ui-contract.js";
 
 const AGENT_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
-const MAX_TOOL_PARAMETERS_BYTES = 16_384;
-const MAX_CONTEXT_ITEM_BYTES = 16_384;
-const MAX_CONTEXT_TOTAL_BYTES = 65_536;
 const MAX_FORWARDED_PROPS_BYTES = 65_536;
 const MAX_TOOL_RESULT_BYTES = 65_536;
 const MAX_RUNTIME_MESSAGES = 100;
@@ -18,51 +26,10 @@ function isWithinJsonSizeLimit(value: unknown, maxBytes: number): boolean {
   }
 }
 
-export const RunIdSchema = z.string().min(1).max(128).regex(AGENT_ID_PATTERN);
+export const RunIdSchema = AgUiRuntimeRunIdSchema;
 
 export const AgentIdSchema = z.string().min(1).max(128).regex(AGENT_ID_PATTERN);
 
-export const ClientToolNameSchema = z
-  .string()
-  .min(1)
-  .max(128)
-  .regex(
-    /^[a-zA-Z][a-zA-Z0-9._:-]*$/,
-    "Tool names must start with a letter and use a valid client-tool format",
-  );
-
-export const RuntimeInjectedToolSchema = z.object({
-  name: ClientToolNameSchema,
-  description: z.string().max(1024).optional(),
-  parameters: z.record(z.string(), z.unknown()).optional().refine(
-    (value) => value === undefined || isWithinJsonSizeLimit(value, MAX_TOOL_PARAMETERS_BYTES),
-    { message: "Tool parameters must be less than 16 KB" },
-  ),
-});
-
-export const RuntimeContextItemSchema = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("text"),
-    title: z.string().max(256).optional(),
-    text: z.string().max(MAX_CONTEXT_ITEM_BYTES),
-  }),
-  z.object({
-    type: z.literal("json"),
-    title: z.string().max(256).optional(),
-    data: z.record(z.string(), z.unknown()).refine(
-      (value) => isWithinJsonSizeLimit(value, MAX_CONTEXT_ITEM_BYTES),
-      { message: "JSON context item must be less than 16 KB" },
-    ),
-  }),
-  z.object({
-    type: z.literal("resource"),
-    title: z.string().max(256).optional(),
-    uri: z.string().max(2048),
-    mimeType: z.string().max(256).optional(),
-    text: z.string().max(MAX_CONTEXT_ITEM_BYTES).optional(),
-  }),
-]);
-
 export const RuntimeAgentSourceContextSchema = z.discriminatedUnion("type", [
   z.object({
     type: z.literal("branch"),
@@ -79,85 +46,11 @@ export const RuntimeAgentSourceContextSchema = z.discriminatedUnion("type", [
   }),
 ]);
 
-const RuntimeMessageExtensionFieldsSchema = {
-  name: z.string().max(256).optional(),
-  metadata: z.record(z.string(), z.unknown()).optional(),
-  createdAt: z.string().optional(),
-} as const;
-
-export const RuntimeToolFunctionCallSchema = z.object({
-  name: ClientToolNameSchema,
-  arguments: z.string().max(MAX_TOOL_PARAMETERS_BYTES),
-}).strict();
-
-export const RuntimeToolCallSchema = z.object({
-  id: z.string().min(1).max(128),
-  type: z.literal("function"),
-  function: RuntimeToolFunctionCallSchema,
-}).strict();
-
-export const RuntimeSystemMessageSchema = z.object({
-  id: z.string().min(1),
-  role: z.literal("system"),
-  content: z.string(),
-  ...RuntimeMessageExtensionFieldsSchema,
-}).strict();
-
-export const RuntimeUserMessageSchema = z.object({
-  id: z.string().min(1),
-  role: z.literal("user"),
-  content: z.string(),
-  ...RuntimeMessageExtensionFieldsSchema,
-}).strict();
-
-export const RuntimeAssistantMessageSchema = z.object({
-  id: z.string().min(1),
-  role: z.literal("assistant"),
-  content: z.string().optional(),
-  toolCalls: z.array(RuntimeToolCallSchema).optional(),
-  ...RuntimeMessageExtensionFieldsSchema,
-}).strict();
-
-export const RuntimeToolMessageSchema = z.object({
-  id: z.string().min(1),
-  role: z.literal("tool"),
-  toolCallId: z.string().min(1).max(128),
-  content: z.string(),
-  error: z.string().optional(),
-  ...RuntimeMessageExtensionFieldsSchema,
-}).strict();
-
-export const RuntimeMessageSchema = z.discriminatedUnion("role", [
-  RuntimeSystemMessageSchema,
-  RuntimeUserMessageSchema,
-  RuntimeAssistantMessageSchema,
-  RuntimeToolMessageSchema,
-]);
-
-export const RuntimeContextSchema = z.union([
-  z.object({
-    description: z.string().max(1024),
-    value: z.string().max(MAX_CONTEXT_ITEM_BYTES),
-  }),
-  RuntimeContextItemSchema,
-]);
-
-export const RuntimeRunAgentInputSchema = z.object({
-  threadId: z.string().uuid(),
-  runId: RunIdSchema,
-  parentRunId: RunIdSchema.optional(),
-  state: z.unknown().optional(),
-  messages: z.array(RuntimeMessageSchema).max(MAX_RUNTIME_MESSAGES),
-  tools: z.array(RuntimeInjectedToolSchema).max(50).default([]),
-  context: z.array(RuntimeContextSchema).max(10).default([]).refine(
-    (value) => isWithinJsonSizeLimit(value, MAX_CONTEXT_TOTAL_BYTES),
-    { message: "context must be less than 64 KB total" },
-  ),
-  forwardedProps: z.record(z.string(), z.unknown()).optional().refine(
-    (value) => value === undefined || isWithinJsonSizeLimit(value, MAX_FORWARDED_PROPS_BYTES),
-    { message: "forwardedProps must be less than 64 KB" },
-  ),
-});
+export const RuntimeInjectedToolSchema = AgUiRuntimeInjectedToolSchema;
+export const RuntimeContextItemSchema = AgUiRuntimeContextItemSchema;
+export const RuntimeMessageSchema = AgUiRuntimeMessageSchema;
+export const RuntimeContextSchema = AgUiRuntimeContextSchema;
+export const RuntimeRunAgentInputSchema = AgUiRuntimeRequestSchema;
 
 export const InternalAgentCompatibilityMessageSchema = z.object({
   id: z.string().min(1),
@@ -178,7 +71,7 @@ export const InternalAgentStreamRequestSchema = z.object({
   ),
   tools: z.array(RuntimeInjectedToolSchema).max(50).default([]),
   context: z.array(RuntimeContextSchema).max(10).default([]).refine(
-    (value) => isWithinJsonSizeLimit(value, MAX_CONTEXT_TOTAL_BYTES),
+    (value) => isWithinJsonSizeLimit(value, 65_536),
     { message: "context must be less than 64 KB total" },
   ),
   agentSource: RuntimeAgentSourceContextSchema.optional(),
@@ -188,7 +81,7 @@ export const InternalAgentStreamRequestSchema = z.object({
   ),
 });
 
-type RuntimeMessage = z.infer<typeof RuntimeMessageSchema>;
+type RuntimeMessage = AgUiRuntimeMessage;
 type InternalAgentCompatibilityMessage = z.infer<typeof InternalAgentCompatibilityMessageSchema>;
 
 function extractToolArgs(
@@ -243,7 +136,7 @@ function isCanonicalToolCallPart(part: Record<string, unknown>): boolean {
 
 function getToolCallShape(
   part: Record<string, unknown>,
-): z.infer<typeof RuntimeToolCallSchema> | null {
+): z.infer<typeof AgUiRuntimeToolCallSchema> | null {
   const id = getPartString(part, "toolCallId", "tool_call_id", "id");
   const name = getPartString(part, "toolName", "tool_name", "name");
 
@@ -357,7 +250,7 @@ function toRuntimeMessage(
 
 export function toRuntimeRunAgentInput(
   input: z.infer<typeof InternalAgentStreamRequestSchema>,
-): z.infer<typeof RuntimeRunAgentInputSchema> {
+): AgUiRuntimeRequest {
   return {
     threadId: input.threadId,
     runId: input.runId,
@@ -385,6 +278,6 @@ export const ResumeSignalSchema = z.discriminatedUnion("type", [
 export type RuntimeInjectedTool = z.infer<typeof RuntimeInjectedToolSchema>;
 export type RuntimeContextItem = z.infer<typeof RuntimeContextItemSchema>;
 export type RuntimeAgentSourceContext = z.infer<typeof RuntimeAgentSourceContextSchema>;
-export type RuntimeRunAgentInput = z.infer<typeof RuntimeRunAgentInputSchema>;
+export type RuntimeRunAgentInput = AgUiRuntimeRequest;
 export type InternalAgentStreamRequest = z.infer<typeof InternalAgentStreamRequestSchema>;
 export type ResumeSignal = z.infer<typeof ResumeSignalSchema>;

package/src/src/provider/runtime-loader.ts

@@ -732,14 +732,14 @@ function buildAnthropicGenerateResult(payload: unknown): {
   };
 }
 
-function parseAnthropicSseChunk(chunk: string): {
+function parseSseChunk(chunk: string): {
   events: Array<unknown | "[DONE]">;
   remainder: string;
 } {
-  const blocks = chunk.split("\n\n");
+  const blocks = chunk.split(/\r?\n\r?\n/);
   const remainder = blocks.pop() ?? "";
   const events = blocks.flatMap((block) => {
-    const dataLines = block.split("\n")
+    const dataLines = block.split(/\r?\n/)
       .filter((line) => line.startsWith("data:"))
       .map((line) => line.slice(5).trimStart());
 
@@ -773,7 +773,7 @@ async function* streamAnthropicCompatibleParts(
 
   for await (const chunk of stream) {
     buffer += decoder.decode(chunk, { stream: true });
-    const parsed = parseAnthropicSseChunk(buffer);
+    const parsed = parseSseChunk(buffer);
     buffer = parsed.remainder;
 
     for (const event of parsed.events) {
@@ -912,7 +912,7 @@ async function* streamAnthropicCompatibleParts(
   }
 
   if (buffer.trim().length > 0) {
-    const parsed = parseAnthropicSseChunk(`${buffer}\n\n`);
+    const parsed = parseSseChunk(`${buffer}\n\n`);
     for (const event of parsed.events) {
       if (event === "[DONE]") {
         continue;
@@ -1313,7 +1313,7 @@ async function* streamGoogleCompatibleParts(
 
   for await (const chunk of stream) {
     buffer += decoder.decode(chunk, { stream: true });
-    const parsed = parseOpenAISseChunk(buffer);
+    const parsed = parseSseChunk(buffer);
     buffer = parsed.remainder;
 
     for (const event of parsed.events) {
@@ -1367,7 +1367,7 @@ async function* streamGoogleCompatibleParts(
   }
 
   if (buffer.trim().length > 0) {
-    const parsed = parseOpenAISseChunk(`${buffer}\n\n`);
+    const parsed = parseSseChunk(`${buffer}\n\n`);
     for (const event of parsed.events) {
       if (event === "[DONE]") {
         continue;
@@ -1430,36 +1430,6 @@ function buildOpenAIGenerateResult(payload: unknown): {
   };
 }
 
-function parseOpenAISseChunk(chunk: string): {
-  events: Array<unknown | "[DONE]">;
-  remainder: string;
-} {
-  const blocks = chunk.split("\n\n");
-  const remainder = blocks.pop() ?? "";
-  const events = blocks.flatMap((block) => {
-    const dataLines = block.split("\n")
-      .filter((line) => line.startsWith("data:"))
-      .map((line) => line.slice(5).trimStart());
-
-    if (!dataLines.length) {
-      return [];
-    }
-
-    const payload = dataLines.join("\n").trim();
-    if (payload === "[DONE]") {
-      return ["[DONE]" as const];
-    }
-
-    try {
-      return [JSON.parse(payload) as unknown];
-    } catch {
-      return [];
-    }
-  });
-
-  return { events, remainder };
-}
-
 async function* streamOpenAICompatibleParts(
   stream: ReadableStream<Uint8Array>,
 ): AsyncIterable<unknown> {
@@ -1471,7 +1441,7 @@ async function* streamOpenAICompatibleParts(
 
   for await (const chunk of stream) {
     buffer += decoder.decode(chunk, { stream: true });
-    const parsed = parseOpenAISseChunk(buffer);
+    const parsed = parseSseChunk(buffer);
     buffer = parsed.remainder;
 
     for (const event of parsed.events) {
@@ -1545,7 +1515,7 @@ async function* streamOpenAICompatibleParts(
   }
 
   if (buffer.trim().length > 0) {
-    const parsed = parseOpenAISseChunk(`${buffer}\n\n`);
+    const parsed = parseSseChunk(`${buffer}\n\n`);
     for (const event of parsed.events) {
       if (event === "[DONE]") {
         continue;

package/src/src/routing/api/module-loader/loader.ts

@@ -355,31 +355,45 @@ function createImportMapPlugin(
 
       build.onLoad(
         { filter: /.*/, namespace: "import-map" },
-        wrapWithCurrentContext(async (args) => {
-          try {
-            const { filePath, contents } = await readFileWithExtensions(
-              adapter,
-              args.path,
-              FILE_EXTENSIONS,
-              projectDir,
-            );
-
-            return {
-              contents,
-              loader: getLoaderForFile(filePath),
-              resolveDir: pathHelper.dirname(filePath),
-            };
-          } catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
-            logger.error(`Failed to load file via import map: ${args.path}`, error);
-            return { errors: [{ text: `Failed to load: ${msg}` }] };
-          }
+        createNamespaceOnLoadHandler({
+          adapter,
+          projectDir,
+          errorLabel: "file via import map",
         }),
       );
     },
   };
 }
 
+function createNamespaceOnLoadHandler(options: {
+  adapter: RuntimeAdapter;
+  projectDir: string;
+  errorLabel: string;
+}) {
+  const { adapter, projectDir, errorLabel } = options;
+
+  return wrapWithCurrentContext(async (args: { path: string }) => {
+    try {
+      const { filePath, contents } = await readFileWithExtensions(
+        adapter,
+        args.path,
+        FILE_EXTENSIONS,
+        projectDir,
+      );
+
+      return {
+        contents,
+        loader: getLoaderForFile(filePath),
+        resolveDir: pathHelper.dirname(filePath),
+      };
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      logger.error(`Failed to load ${errorLabel}: ${args.path}`, error);
+      return { errors: [{ text: `Failed to load: ${msg}` }] };
+    }
+  });
+}
+
 /** Resolves relative imports through the adapter's virtual FS for remote projects. */
 function createAdapterResolvePlugin(
   adapter: RuntimeAdapter,
@@ -420,25 +434,10 @@ function createAdapterResolvePlugin(
       // cannot resolve the per-project adapter and all file reads fail silently.
       build.onLoad(
         { filter: /.*/, namespace: "vf-adapter" },
-        wrapWithCurrentContext(async (args) => {
-          try {
-            const { filePath, contents } = await readFileWithExtensions(
-              adapter,
-              args.path,
-              FILE_EXTENSIONS,
-              projectDir,
-            );
-
-            return {
-              contents,
-              loader: getLoaderForFile(filePath),
-              resolveDir: pathHelper.dirname(filePath),
-            };
-          } catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
-            logger.error(`Failed to load via adapter: ${args.path}`, error);
-            return { errors: [{ text: `Failed to load: ${msg}` }] };
-          }
+        createNamespaceOnLoadHandler({
+          adapter,
+          projectDir,
+          errorLabel: "via adapter",
         }),
       );
     },

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