veryfront 0.0.73 → 0.0.74

package/dist/ai/index.js

@@ -79,19 +79,69 @@ function getEnvironmentVariable(name) {
   }
   return void 0;
 }
+function isProductionEnvironment() {
+  return getEnvironmentVariable("NODE_ENV") === "production";
+}
 
 // src/core/utils/logger/logger.ts
 var cachedLogLevel;
+var cachedLogFormat;
 function resolveLogLevel(force = false) {
   if (force || cachedLogLevel === void 0) {
     cachedLogLevel = getDefaultLevel();
   }
   return cachedLogLevel;
 }
-var ConsoleLogger = class {
-  constructor(prefix, level = resolveLogLevel()) {
+function resolveLogFormat(force = false) {
+  if (force || cachedLogFormat === void 0) {
+    cachedLogFormat = getDefaultFormat();
+  }
+  return cachedLogFormat;
+}
+function getDefaultFormat() {
+  const envFormat = getEnvironmentVariable("LOG_FORMAT");
+  if (envFormat === "json" || envFormat === "text") {
+    return envFormat;
+  }
+  return isProductionEnvironment() ? "json" : "text";
+}
+function serializeError(err) {
+  if (err instanceof Error) {
+    return {
+      name: err.name,
+      message: err.message,
+      stack: err.stack
+    };
+  }
+  if (err !== void 0 && err !== null) {
+    return {
+      name: "UnknownError",
+      message: String(err)
+    };
+  }
+  return void 0;
+}
+function extractContext(args) {
+  let context;
+  let error;
+  for (const arg of args) {
+    if (arg instanceof Error) {
+      error = serializeError(arg);
+    } else if (typeof arg === "object" && arg !== null && !Array.isArray(arg)) {
+      context = { ...context, ...arg };
+    }
+  }
+  return { context, error };
+}
+var ConsoleLogger = class _ConsoleLogger {
+  constructor(prefix, level = resolveLogLevel(), format = resolveLogFormat(), boundContext) {
     this.prefix = prefix;
     this.level = level;
+    this.format = format;
+    this.boundContext = {};
+    if (boundContext) {
+      this.boundContext = boundContext;
+    }
   }
   setLevel(level) {
     this.level = level;
@@ -99,36 +149,88 @@ var ConsoleLogger = class {
   getLevel() {
     return this.level;
   }
-  debug(message, ...args) {
-    if (this.level <= 0 /* DEBUG */) {
-      console.debug(`[${this.prefix}] DEBUG: ${message}`, ...args);
+  setFormat(format) {
+    this.format = format;
+  }
+  getFormat() {
+    return this.format;
+  }
+  /**
+   * Create a child logger with additional bound context.
+   */
+  child(context) {
+    return new _ConsoleLogger(this.prefix, this.level, this.format, {
+      ...this.boundContext,
+      ...context
+    });
+  }
+  formatJson(level, message, args) {
+    const { context, error } = extractContext(args);
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      service: this.prefix.toLowerCase(),
+      message
+    };
+    const mergedContext = { ...this.boundContext, ...context };
+    if (Object.keys(mergedContext).length > 0) {
+      if ("requestId" in mergedContext) {
+        entry.requestId = String(mergedContext.requestId);
+        delete mergedContext.requestId;
+      }
+      if ("traceId" in mergedContext) {
+        entry.traceId = String(mergedContext.traceId);
+        delete mergedContext.traceId;
+      }
+      if ("projectSlug" in mergedContext) {
+        entry.projectSlug = String(mergedContext.projectSlug);
+        delete mergedContext.projectSlug;
+      }
+      if ("durationMs" in mergedContext) {
+        entry.durationMs = Number(mergedContext.durationMs);
+        delete mergedContext.durationMs;
+      }
+      if (Object.keys(mergedContext).length > 0) {
+        entry.context = mergedContext;
+      }
+    }
+    if (error) {
+      entry.error = error;
     }
+    return JSON.stringify(entry);
   }
-  info(message, ...args) {
-    if (this.level <= 1 /* INFO */) {
-      console.log(`[${this.prefix}] ${message}`, ...args);
+  log(level, logLevel, consoleFn, message, args) {
+    if (this.level > logLevel)
+      return;
+    if (this.format === "json") {
+      consoleFn(this.formatJson(level, message, args));
+    } else {
+      const prefix = level === "info" ? "" : ` ${level.toUpperCase()}:`;
+      consoleFn(`[${this.prefix}]${prefix} ${message}`, ...args);
     }
   }
+  debug(message, ...args) {
+    this.log("debug", 0 /* DEBUG */, console.debug, message, args);
+  }
+  info(message, ...args) {
+    this.log("info", 1 /* INFO */, console.log, message, args);
+  }
   warn(message, ...args) {
-    if (this.level <= 2 /* WARN */) {
-      console.warn(`[${this.prefix}] WARN: ${message}`, ...args);
-    }
+    this.log("warn", 2 /* WARN */, console.warn, message, args);
   }
   error(message, ...args) {
-    if (this.level <= 3 /* ERROR */) {
-      console.error(`[${this.prefix}] ERROR: ${message}`, ...args);
-    }
+    this.log("error", 3 /* ERROR */, console.error, message, args);
   }
   async time(label, fn) {
     const start = performance.now();
     try {
       const result = await fn();
-      const end = performance.now();
-      this.debug(`${label} completed in ${(end - start).toFixed(2)}ms`);
+      const durationMs = performance.now() - start;
+      this.debug(`${label} completed`, { durationMs: Math.round(durationMs) });
       return result;
     } catch (error) {
-      const end = performance.now();
-      this.error(`${label} failed after ${(end - start).toFixed(2)}ms`, error);
+      const durationMs = performance.now() - start;
+      this.error(`${label} failed`, { durationMs: Math.round(durationMs) }, error);
       throw error;
     }
   }
@@ -171,6 +273,7 @@ var serverLogger = createLogger("SERVER");
 var rendererLogger = createLogger("RENDERER");
 var bundlerLogger = createLogger("BUNDLER");
 var agentLogger = createLogger("AGENT");
+var proxyLogger = createLogger("PROXY");
 var logger = createLogger("VERYFRONT");
 
 // src/ai/providers/base.ts
@@ -191,8 +294,30 @@ var OpenAIStreamChunkSchema = z.object({
     finish_reason: z.string().nullable()
   })).min(1)
 });
+var OpenAICompletionResponseSchema = z.object({
+  id: z.string(),
+  choices: z.array(z.object({
+    message: z.object({
+      role: z.string(),
+      content: z.string().nullable().optional(),
+      tool_calls: z.array(z.object({
+        id: z.string(),
+        type: z.literal("function"),
+        function: z.object({
+          name: z.string(),
+          arguments: z.string()
+        })
+      })).optional()
+    }),
+    finish_reason: z.string().nullable()
+  })).min(1),
+  usage: z.object({
+    prompt_tokens: z.number(),
+    completion_tokens: z.number(),
+    total_tokens: z.number()
+  }).optional()
+});
 var BaseProvider = class {
-  config;
   constructor(config) {
     this.config = config;
     this.validateConfig();
@@ -231,7 +356,17 @@ var BaseProvider = class {
       }));
     }
     const data = await response.json();
-    return this.transformResponse(data);
+    const parseResult = OpenAICompletionResponseSchema.safeParse(data);
+    if (!parseResult.success) {
+      agentLogger.warn(`${this.name}: Invalid response structure`, {
+        errors: parseResult.error.flatten()
+      });
+      throw toError(createError({
+        type: "agent",
+        message: `${this.name}: Invalid response structure from provider`
+      }));
+    }
+    return this.transformResponse(parseResult.data);
   }
   /**
    * Stream a completion
@@ -407,12 +542,9 @@ var OpenAIResponseSchema = z2.object({
   }).optional()
 });
 var OpenAIProvider = class extends BaseProvider {
-  name = "openai";
-  apiKey;
-  baseURL;
-  organizationId;
   constructor(config) {
     super(config);
+    this.name = "openai";
     this.apiKey = config.apiKey;
     this.baseURL = config.baseURL || "https://api.openai.com/v1";
     this.organizationId = config.organizationId;
@@ -515,11 +647,9 @@ var OpenAIProvider = class extends BaseProvider {
 
 // src/ai/providers/anthropic.ts
 var AnthropicProvider = class extends BaseProvider {
-  name = "anthropic";
-  apiKey;
-  baseURL;
   constructor(config) {
     super(config);
+    this.name = "anthropic";
     this.apiKey = config.apiKey;
     this.baseURL = config.baseURL || "https://api.anthropic.com";
   }
@@ -817,11 +947,9 @@ var GoogleResponseSchema = z3.object({
   }).optional()
 });
 var GoogleProvider = class extends BaseProvider {
-  name = "google";
-  apiKey;
-  baseURL;
   constructor(config) {
     super(config);
+    this.name = "google";
     this.apiKey = config.apiKey;
     this.baseURL = config.baseURL || "https://generativelanguage.googleapis.com/v1beta";
   }
@@ -943,9 +1071,11 @@ function getEnv(key) {
 
 // src/ai/providers/factory.ts
 var ProviderRegistry = class {
-  providers = /* @__PURE__ */ new Map();
-  config = {};
-  autoInitialized = false;
+  constructor() {
+    this.providers = /* @__PURE__ */ new Map();
+    this.config = {};
+    this.autoInitialized = false;
+  }
   /**
    * Auto-initialize providers from environment variables
    * This is called lazily when a provider is first requested
@@ -1369,7 +1499,9 @@ function generateToolId() {
   return `tool_${Date.now()}_${toolIdCounter++}`;
 }
 var ToolRegistryClass = class {
-  tools = /* @__PURE__ */ new Map();
+  constructor() {
+    this.tools = /* @__PURE__ */ new Map();
+  }
   register(id, toolInstance) {
     if (this.tools.has(id)) {
       agentLogger.debug(`Tool "${id}" is already registered. Overwriting.`);
@@ -1629,7 +1761,9 @@ function patternToId(pattern) {
   return pattern.replace(/^\//, "").replace(/\//g, "_").replace(/:/g, "");
 }
 var ResourceRegistryClass = class {
-  resources = /* @__PURE__ */ new Map();
+  constructor() {
+    this.resources = /* @__PURE__ */ new Map();
+  }
   /**
    * Register a resource
    */
@@ -1725,7 +1859,9 @@ function interpolateVariables(template, variables) {
   });
 }
 var PromptRegistryClass = class {
-  prompts = /* @__PURE__ */ new Map();
+  constructor() {
+    this.prompts = /* @__PURE__ */ new Map();
+  }
   /**
    * Register a prompt
    */
@@ -1856,7 +1992,9 @@ function createWorkflow(config) {
   };
 }
 var AgentRegistryClass = class {
-  agents = /* @__PURE__ */ new Map();
+  constructor() {
+    this.agents = /* @__PURE__ */ new Map();
+  }
   /**
    * Register an agent
    */
@@ -1931,6 +2069,9 @@ var veryfrontConfigSchema = z5.object({
   }).partial().optional(),
   router: z5.enum(["app", "pages"]).optional(),
   defaultLayout: z5.string().optional(),
+  layout: z5.string().optional(),
+  provider: z5.string().optional(),
+  app: z5.string().optional(),
   theme: z5.object({ colors: z5.record(z5.string()).optional() }).partial().optional(),
   build: z5.object({
     outDir: z5.string().optional(),
@@ -2026,6 +2167,8 @@ var veryfrontConfigSchema = z5.object({
       apiBaseUrl: z5.string().url(),
       apiToken: z5.string(),
       projectSlug: z5.string(),
+      proxyMode: z5.boolean().optional(),
+      productionMode: z5.boolean().optional(),
       cache: z5.object({
         enabled: z5.boolean().optional(),
         ttl: z5.number().int().positive().optional(),
@@ -2087,6 +2230,9 @@ function findUnknownTopLevelKeys(input) {
     "experimental",
     "router",
     "defaultLayout",
+    "layout",
+    "provider",
+    "app",
     "theme",
     "build",
     "cache",
@@ -2104,12 +2250,12 @@ function findUnknownTopLevelKeys(input) {
 }
 
 // src/core/config/loader.ts
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 
 // deno.json
 var deno_default = {
   name: "veryfront",
-  version: "0.0.73",
+  version: "0.0.74",
   nodeModulesDir: "auto",
   exclude: [
     "npm/",
@@ -2194,12 +2340,12 @@ var deno_default = {
     csstype: "https://esm.sh/csstype@3.2.3",
     "@types/react": "https://esm.sh/@types/react@18.3.27?deps=csstype@3.2.3",
     "@types/react-dom": "https://esm.sh/@types/react-dom@18.3.7?deps=csstype@3.2.3",
-    react: "https://esm.sh/react@18.3.1",
-    "react-dom": "https://esm.sh/react-dom@18.3.1",
-    "react-dom/server": "https://esm.sh/react-dom@18.3.1/server",
-    "react-dom/client": "https://esm.sh/react-dom@18.3.1/client",
-    "react/jsx-runtime": "https://esm.sh/react@18.3.1/jsx-runtime",
-    "react/jsx-dev-runtime": "https://esm.sh/react@18.3.1/jsx-dev-runtime",
+    react: "npm:react@18.3.1",
+    "react-dom": "npm:react-dom@18.3.1",
+    "react-dom/server": "npm:react-dom@18.3.1/server.node",
+    "react-dom/client": "npm:react-dom@18.3.1/client",
+    "react/jsx-runtime": "npm:react@18.3.1/jsx-runtime",
+    "react/jsx-dev-runtime": "npm:react@18.3.1/jsx-dev-runtime",
     "@mdx-js/mdx": "npm:@mdx-js/mdx@3.0.0",
     "@mdx-js/react": "npm:@mdx-js/react@3.0.0",
     "unist-util-visit": "npm:unist-util-visit@5.0.0",
@@ -2209,27 +2355,36 @@ var deno_default = {
     "remark-frontmatter": "npm:remark-frontmatter@5.0.0",
     "rehype-highlight": "npm:rehype-highlight@7.0.2",
     "rehype-slug": "npm:rehype-slug@6.0.0",
-    esbuild: "https://deno.land/x/esbuild@v0.20.1/wasm.js",
-    "esbuild/mod.js": "https://deno.land/x/esbuild@v0.20.1/mod.js",
+    esbuild: "npm:esbuild@0.20.2",
+    "esbuild/mod.js": "npm:esbuild@0.20.2",
     "es-module-lexer": "npm:es-module-lexer@1.5.0",
-    zod: "npm:zod@3.23.8",
+    zod: "npm:zod@3.25.76",
     "mime-types": "npm:mime-types@2.1.35",
     mdast: "npm:@types/mdast@4.0.3",
     hast: "npm:@types/hast@3.0.3",
     unist: "npm:@types/unist@3.0.2",
     unified: "npm:unified@11.0.5",
-    ai: "https://esm.sh/ai@5.0.76?deps=react@18.3.1,react-dom@18.3.1",
-    "ai/react": "https://esm.sh/@ai-sdk/react@2.0.1?deps=react@18.3.1,react-dom@18.3.1",
-    "@ai-sdk/react": "https://esm.sh/@ai-sdk/react@2.0.1?deps=react@18.3.1,react-dom@18.3.1",
+    ai: "npm:ai@5.0.76",
+    "ai/react": "npm:@ai-sdk/react@2.0.1",
+    "@ai-sdk/react": "npm:@ai-sdk/react@2.0.1",
     "@ai-sdk/openai": "https://esm.sh/@ai-sdk/openai@2.0.1",
     "@ai-sdk/anthropic": "https://esm.sh/@ai-sdk/anthropic@2.0.1",
     unocss: "https://esm.sh/unocss@0.59.0",
     "@unocss/core": "https://esm.sh/@unocss/core@0.59.0",
     "@unocss/preset-wind": "https://esm.sh/@unocss/preset-wind@0.59.0",
+    "next-themes": "npm:next-themes@0.3.0",
     redis: "npm:redis",
     pg: "npm:pg",
     "@opentelemetry/api": "npm:@opentelemetry/api@1",
-    "@opentelemetry/core": "npm:@opentelemetry/core@1"
+    "@opentelemetry/core": "npm:@opentelemetry/core@1",
+    "@opentelemetry/sdk-trace-base": "npm:@opentelemetry/sdk-trace-base@1",
+    "@opentelemetry/exporter-trace-otlp-http": "npm:@opentelemetry/exporter-trace-otlp-http@0.57",
+    "@opentelemetry/resources": "npm:@opentelemetry/resources@1",
+    "@opentelemetry/semantic-conventions": "npm:@opentelemetry/semantic-conventions@1",
+    "@babel/parser": "npm:@babel/parser@7.26.3",
+    "@babel/traverse": "npm:@babel/traverse@7.26.3",
+    "@babel/generator": "npm:@babel/generator@7.26.3",
+    "@babel/types": "npm:@babel/types@7.26.3"
   },
   compilerOptions: {
     jsx: "react-jsx",
@@ -2237,7 +2392,7 @@ var deno_default = {
     strict: true,
     noImplicitAny: true,
     noUncheckedIndexedAccess: true,
-    types: [],
+    types: ["npm:@types/react@18"],
     lib: [
       "deno.window",
       "dom",
@@ -2252,9 +2407,9 @@ var deno_default = {
     build: "deno compile --allow-all --output ../../bin/veryfront src/cli/main.ts",
     "build:npm": "deno run -A scripts/build-npm.ts",
     release: "deno run -A scripts/release.ts",
-    test: "DENO_JOBS=1 deno test --parallel --fail-fast --allow-all --unstable-worker-options --unstable-net",
-    "test:unit": "DENO_JOBS=1 deno test --parallel --allow-all --v8-flags=--max-old-space-size=8192 --ignore=tests --unstable-worker-options --unstable-net",
-    "test:integration": "DENO_JOBS=1 deno test --parallel --fail-fast --allow-all tests --unstable-worker-options --unstable-net",
+    test: "VF_DISABLE_LRU_INTERVAL=1 DENO_JOBS=1 deno test --parallel --fail-fast --allow-all --unstable-worker-options --unstable-net",
+    "test:unit": "VF_DISABLE_LRU_INTERVAL=1 DENO_JOBS=1 deno test --parallel --allow-all --v8-flags=--max-old-space-size=8192 --ignore=tests,src/ai/workflow/__tests__ --unstable-worker-options --unstable-net",
+    "test:integration": "VF_DISABLE_LRU_INTERVAL=1 DENO_JOBS=1 deno test --parallel --fail-fast --allow-all tests --unstable-worker-options --unstable-net",
     "test:coverage": "rm -rf coverage && DENO_JOBS=1 deno test --parallel --fail-fast --allow-all --coverage=coverage --unstable-worker-options --unstable-net || exit 1",
     "test:coverage:unit": "rm -rf coverage && DENO_JOBS=1 deno test --parallel --fail-fast --allow-all --coverage=coverage --ignore=tests --unstable-worker-options --unstable-net || exit 1",
     "test:coverage:integration": "rm -rf coverage && DENO_JOBS=1 deno test --parallel --fail-fast --allow-all --coverage=coverage tests --unstable-worker-options --unstable-net || exit 1",
@@ -2316,6 +2471,7 @@ var deno_default = {
 
 // src/core/utils/version.ts
 var VERSION = getEnv("VERYFRONT_VERSION") || (typeof deno_default.version === "string" ? deno_default.version : "0.0.0");
+var SERVER_START_TIME = Date.now();
 
 // src/core/utils/constants/cdn.ts
 var ESM_CDN_BASE = "https://esm.sh";
@@ -2431,6 +2587,166 @@ var DEV_SERVER_ENDPOINTS = {
   ERROR_OVERLAY: INTERNAL_ENDPOINTS.ERROR_OVERLAY
 };
 
+// src/platform/compat/fs.ts
+var NodeFileSystem = class {
+  constructor() {
+    this.fs = null;
+    this.os = null;
+    this.path = null;
+    this.initialized = false;
+  }
+  async ensureInitialized() {
+    if (this.initialized)
+      return;
+    if (!isNode) {
+      throw toError(createError({
+        type: "not_supported",
+        message: "Node.js fs modules not available",
+        feature: "Node.js"
+      }));
+    }
+    const [fsModule, osModule, pathModule] = await Promise.all([
+      import("node:fs/promises"),
+      import("node:os"),
+      import("node:path")
+    ]);
+    this.fs = fsModule;
+    this.os = osModule;
+    this.path = pathModule;
+    this.initialized = true;
+  }
+  async readTextFile(path) {
+    await this.ensureInitialized();
+    return await this.fs.readFile(path, { encoding: "utf8" });
+  }
+  async readFile(path) {
+    await this.ensureInitialized();
+    return await this.fs.readFile(path);
+  }
+  async writeTextFile(path, data) {
+    await this.ensureInitialized();
+    await this.fs.writeFile(path, data, { encoding: "utf8" });
+  }
+  async writeFile(path, data) {
+    await this.ensureInitialized();
+    await this.fs.writeFile(path, data);
+  }
+  async exists(path) {
+    await this.ensureInitialized();
+    try {
+      await this.fs.access(path);
+      return true;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return false;
+      }
+      throw error;
+    }
+  }
+  async stat(path) {
+    await this.ensureInitialized();
+    const stat = await this.fs.stat(path);
+    return {
+      isFile: stat.isFile(),
+      isDirectory: stat.isDirectory(),
+      isSymlink: stat.isSymbolicLink(),
+      size: stat.size,
+      mtime: stat.mtime
+    };
+  }
+  async mkdir(path, options) {
+    await this.ensureInitialized();
+    await this.fs.mkdir(path, { recursive: options?.recursive ?? false });
+  }
+  async *readDir(path) {
+    await this.ensureInitialized();
+    const entries = await this.fs.readdir(path, { withFileTypes: true });
+    for (const entry of entries) {
+      yield {
+        name: entry.name,
+        isFile: entry.isFile(),
+        isDirectory: entry.isDirectory()
+      };
+    }
+  }
+  async remove(path, options) {
+    await this.ensureInitialized();
+    await this.fs.rm(path, {
+      recursive: options?.recursive ?? false,
+      force: options?.recursive ?? false
+    });
+  }
+  async makeTempDir(options) {
+    await this.ensureInitialized();
+    const tempDir = this.path.join(
+      this.os.tmpdir(),
+      `${options?.prefix ?? "tmp-"}${Math.random().toString(36).substring(2, 8)}`
+    );
+    await this.fs.mkdir(tempDir, { recursive: true });
+    return tempDir;
+  }
+};
+var DenoFileSystem = class {
+  async readTextFile(path) {
+    return await Deno.readTextFile(path);
+  }
+  async readFile(path) {
+    return await Deno.readFile(path);
+  }
+  async writeTextFile(path, data) {
+    await Deno.writeTextFile(path, data);
+  }
+  async writeFile(path, data) {
+    await Deno.writeFile(path, data);
+  }
+  async exists(path) {
+    try {
+      await Deno.stat(path);
+      return true;
+    } catch (error) {
+      if (error instanceof Deno.errors.NotFound) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  async stat(path) {
+    const stat = await Deno.stat(path);
+    return {
+      isFile: stat.isFile,
+      isDirectory: stat.isDirectory,
+      isSymlink: stat.isSymlink,
+      size: stat.size,
+      mtime: stat.mtime
+    };
+  }
+  async mkdir(path, options) {
+    await Deno.mkdir(path, { recursive: options?.recursive ?? false });
+  }
+  async *readDir(path) {
+    for await (const entry of Deno.readDir(path)) {
+      yield {
+        name: entry.name,
+        isFile: entry.isFile,
+        isDirectory: entry.isDirectory
+      };
+    }
+  }
+  async remove(path, options) {
+    await Deno.remove(path, { recursive: options?.recursive ?? false });
+  }
+  async makeTempDir(options) {
+    return await Deno.makeTempDir({ prefix: options?.prefix });
+  }
+};
+function createFileSystem() {
+  if (isDeno) {
+    return new DenoFileSystem();
+  } else {
+    return new NodeFileSystem();
+  }
+}
+
 // src/core/config/loader.ts
 function getDefaultImportMapForConfig() {
   return { imports: getReactImportMap(REACT_DEFAULT_VERSION) };
@@ -2567,7 +2883,62 @@ var ConfigValidationError = class extends Error {
     this.name = "ConfigValidationError";
   }
 };
-async function loadAndMergeConfig(configPath, projectDir) {
+function isVirtualFilesystem(adapter) {
+  const wrappedAdapter = adapter?.fs?.fsAdapter;
+  const adapterName = wrappedAdapter?.constructor?.name;
+  return adapterName === "VeryfrontFSAdapter";
+}
+async function loadConfigFromVirtualFS(configPath, projectDir, adapter) {
+  const fs2 = createFileSystem();
+  const content = await adapter.fs.readFile(configPath);
+  const source = typeof content === "string" ? content : new TextDecoder().decode(content);
+  serverLogger.debug(`[CONFIG] Loading config from virtual FS: ${configPath}`);
+  const isTsx = configPath.endsWith(".tsx");
+  const loader = isTsx ? "tsx" : configPath.endsWith(".ts") ? "ts" : "js";
+  const { build } = await import("esbuild");
+  const result = await build({
+    bundle: false,
+    // Config files shouldn't need bundling
+    write: false,
+    format: "esm",
+    platform: "neutral",
+    target: "es2022",
+    stdin: {
+      contents: source,
+      loader,
+      resolveDir: dirname(configPath),
+      sourcefile: configPath
+    }
+  });
+  if (result.errors && result.errors.length > 0) {
+    const first = result.errors[0]?.text || "unknown error";
+    throw new ConfigValidationError(`Failed to transpile config: ${first}`);
+  }
+  const js = result.outputFiles?.[0]?.text ?? "export default {}";
+  const tempDir = await fs2.makeTempDir({ prefix: "vf-config-" });
+  const tempFile = join(tempDir, "config.mjs");
+  try {
+    await fs2.writeTextFile(tempFile, js);
+    const configModule = await import(`file://${tempFile}?v=${Date.now()}`);
+    const userConfig = configModule.default || configModule;
+    if (userConfig === null || typeof userConfig !== "object" || Array.isArray(userConfig)) {
+      throw new ConfigValidationError(
+        `Expected object, received ${userConfig === null ? "null" : typeof userConfig}`
+      );
+    }
+    validateCorsConfig(userConfig);
+    validateConfigShape(userConfig);
+    const merged = mergeConfigs(userConfig);
+    configCacheByProject.set(projectDir, { revision: cacheRevision, config: merged });
+    return merged;
+  } finally {
+    await fs2.remove(tempDir, { recursive: true });
+  }
+}
+async function loadAndMergeConfig(configPath, projectDir, adapter) {
+  if (isVirtualFilesystem(adapter)) {
+    return loadConfigFromVirtualFS(configPath, projectDir, adapter);
+  }
   try {
     const configUrl = `file://${configPath}?t=${Date.now()}-${crypto.randomUUID()}`;
     const configModule = await import(configUrl);
@@ -2603,7 +2974,7 @@ async function getConfig(projectDir, adapter) {
     if (!exists)
       continue;
     try {
-      const merged = await loadAndMergeConfig(configPath, projectDir);
+      const merged = await loadAndMergeConfig(configPath, projectDir, adapter);
       if (merged)
         return merged;
     } catch (error) {
@@ -2672,266 +3043,108 @@ function createMockAdapter() {
           throw toError(createError({
             type: "file",
             message: `File not found: ${path}`
-          }));
-        }
-        return Promise.resolve(new TextEncoder().encode(content));
-      },
-      writeFile: (path, content) => {
-        files.set(path, content);
-        return Promise.resolve();
-      },
-      exists: (path) => {
-        if (files.has(path))
-          return Promise.resolve(true);
-        if (directories.has(path))
-          return Promise.resolve(true);
-        for (const filePath of files.keys()) {
-          if (filePath.startsWith(path + "/"))
-            return Promise.resolve(true);
-        }
-        return Promise.resolve(false);
-      },
-      readDir: async function* (path) {
-        const entries = /* @__PURE__ */ new Map();
-        for (const filePath of files.keys()) {
-          if (filePath.startsWith(path + "/")) {
-            const relativePath = filePath.slice(path.length + 1);
-            const parts = relativePath.split("/");
-            const name = parts[0];
-            if (!entries.has(name)) {
-              entries.set(name, {
-                isFile: parts.length === 1,
-                isDirectory: parts.length > 1
-              });
-            }
-          }
-        }
-        for (const [name, meta] of entries.entries()) {
-          yield { name, ...meta, isSymlink: false };
-        }
-      },
-      stat: (path) => {
-        if (files.has(path)) {
-          const content = files.get(path);
-          return Promise.resolve({
-            size: content.length,
-            isFile: true,
-            isDirectory: false,
-            isSymlink: false,
-            mtime: /* @__PURE__ */ new Date()
-          });
-        }
-        if (directories.has(path)) {
-          return Promise.resolve({
-            size: 0,
-            isFile: false,
-            isDirectory: true,
-            isSymlink: false,
-            mtime: /* @__PURE__ */ new Date()
-          });
-        }
-        for (const filePath of files.keys()) {
-          if (filePath.startsWith(path + "/")) {
-            return Promise.resolve({
-              size: 0,
-              isFile: false,
-              isDirectory: true,
-              isSymlink: false,
-              mtime: /* @__PURE__ */ new Date()
-            });
-          }
-        }
-        return Promise.reject(new Error(`Path not found: ${path}`));
-      },
-      mkdir: (_path) => Promise.resolve(),
-      remove: (_path) => Promise.resolve(),
-      makeTempDir: (prefix) => Promise.resolve(`/tmp/${prefix}-${Math.random().toString(36).slice(2)}`),
-      watch: () => ({
-        async *[Symbol.asyncIterator]() {
-          yield { kind: "any", paths: [] };
-        },
-        close: () => {
-        }
-      })
-    },
-    env: {
-      get: (key) => envVars.get(key),
-      set: (key, value) => envVars.set(key, value),
-      toObject: () => Object.fromEntries(envVars)
-    },
-    server: {
-      upgradeWebSocket: (_request) => {
-        throw new Error(
-          "WebSocket upgrade not available in mock adapter. The mock adapter is designed for unit testing filesystem and environment operations. For WebSocket testing, use integration tests with the actual Deno/Node/Bun adapter, or mock the WebSocket behavior at a higher level in your tests."
-        );
-      }
-    },
-    features: {
-      websocket: false,
-      http2: false,
-      workers: false,
-      jsx: false,
-      typescript: false
-    }
-  };
-}
-
-// src/platform/compat/fs.ts
-var NodeFileSystem = class {
-  fs = null;
-  os = null;
-  path = null;
-  initialized = false;
-  async ensureInitialized() {
-    if (this.initialized)
-      return;
-    if (!isNode) {
-      throw toError(createError({
-        type: "not_supported",
-        message: "Node.js fs modules not available",
-        feature: "Node.js"
-      }));
-    }
-    const [fsModule, osModule, pathModule] = await Promise.all([
-      import("node:fs/promises"),
-      import("node:os"),
-      import("node:path")
-    ]);
-    this.fs = fsModule;
-    this.os = osModule;
-    this.path = pathModule;
-    this.initialized = true;
-  }
-  async readTextFile(path) {
-    await this.ensureInitialized();
-    return await this.fs.readFile(path, { encoding: "utf8" });
-  }
-  async readFile(path) {
-    await this.ensureInitialized();
-    return await this.fs.readFile(path);
-  }
-  async writeTextFile(path, data) {
-    await this.ensureInitialized();
-    await this.fs.writeFile(path, data, { encoding: "utf8" });
-  }
-  async writeFile(path, data) {
-    await this.ensureInitialized();
-    await this.fs.writeFile(path, data);
-  }
-  async exists(path) {
-    await this.ensureInitialized();
-    try {
-      await this.fs.access(path);
-      return true;
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        return false;
-      }
-      throw error;
-    }
-  }
-  async stat(path) {
-    await this.ensureInitialized();
-    const stat = await this.fs.stat(path);
-    return {
-      isFile: stat.isFile(),
-      isDirectory: stat.isDirectory(),
-      isSymlink: stat.isSymbolicLink(),
-      size: stat.size,
-      mtime: stat.mtime
-    };
-  }
-  async mkdir(path, options) {
-    await this.ensureInitialized();
-    await this.fs.mkdir(path, { recursive: options?.recursive ?? false });
-  }
-  async *readDir(path) {
-    await this.ensureInitialized();
-    const entries = await this.fs.readdir(path, { withFileTypes: true });
-    for (const entry of entries) {
-      yield {
-        name: entry.name,
-        isFile: entry.isFile(),
-        isDirectory: entry.isDirectory()
-      };
-    }
-  }
-  async remove(path, options) {
-    await this.ensureInitialized();
-    await this.fs.rm(path, {
-      recursive: options?.recursive ?? false,
-      force: options?.recursive ?? false
-    });
-  }
-  async makeTempDir(options) {
-    await this.ensureInitialized();
-    const tempDir = this.path.join(
-      this.os.tmpdir(),
-      `${options?.prefix ?? "tmp-"}${Math.random().toString(36).substring(2, 8)}`
-    );
-    await this.fs.mkdir(tempDir, { recursive: true });
-    return tempDir;
-  }
-};
-var DenoFileSystem = class {
-  async readTextFile(path) {
-    return await Deno.readTextFile(path);
-  }
-  async readFile(path) {
-    return await Deno.readFile(path);
-  }
-  async writeTextFile(path, data) {
-    await Deno.writeTextFile(path, data);
-  }
-  async writeFile(path, data) {
-    await Deno.writeFile(path, data);
-  }
-  async exists(path) {
-    try {
-      await Deno.stat(path);
-      return true;
-    } catch (error) {
-      if (error instanceof Deno.errors.NotFound) {
-        return false;
+          }));
+        }
+        return Promise.resolve(new TextEncoder().encode(content));
+      },
+      writeFile: (path, content) => {
+        files.set(path, content);
+        return Promise.resolve();
+      },
+      exists: (path) => {
+        if (files.has(path))
+          return Promise.resolve(true);
+        if (directories.has(path))
+          return Promise.resolve(true);
+        for (const filePath of files.keys()) {
+          if (filePath.startsWith(path + "/"))
+            return Promise.resolve(true);
+        }
+        return Promise.resolve(false);
+      },
+      readDir: async function* (path) {
+        const entries = /* @__PURE__ */ new Map();
+        for (const filePath of files.keys()) {
+          if (filePath.startsWith(path + "/")) {
+            const relativePath = filePath.slice(path.length + 1);
+            const parts = relativePath.split("/");
+            const name = parts[0];
+            if (!entries.has(name)) {
+              entries.set(name, {
+                isFile: parts.length === 1,
+                isDirectory: parts.length > 1
+              });
+            }
+          }
+        }
+        for (const [name, meta] of entries.entries()) {
+          yield { name, ...meta, isSymlink: false };
+        }
+      },
+      stat: (path) => {
+        if (files.has(path)) {
+          const content = files.get(path);
+          return Promise.resolve({
+            size: content.length,
+            isFile: true,
+            isDirectory: false,
+            isSymlink: false,
+            mtime: /* @__PURE__ */ new Date()
+          });
+        }
+        if (directories.has(path)) {
+          return Promise.resolve({
+            size: 0,
+            isFile: false,
+            isDirectory: true,
+            isSymlink: false,
+            mtime: /* @__PURE__ */ new Date()
+          });
+        }
+        for (const filePath of files.keys()) {
+          if (filePath.startsWith(path + "/")) {
+            return Promise.resolve({
+              size: 0,
+              isFile: false,
+              isDirectory: true,
+              isSymlink: false,
+              mtime: /* @__PURE__ */ new Date()
+            });
+          }
+        }
+        return Promise.reject(new Error(`Path not found: ${path}`));
+      },
+      mkdir: (_path) => Promise.resolve(),
+      remove: (_path) => Promise.resolve(),
+      makeTempDir: (prefix) => Promise.resolve(`/tmp/${prefix}-${Math.random().toString(36).slice(2)}`),
+      watch: () => ({
+        async *[Symbol.asyncIterator]() {
+          yield { kind: "any", paths: [] };
+        },
+        close: () => {
+        }
+      })
+    },
+    env: {
+      get: (key) => envVars.get(key),
+      set: (key, value) => envVars.set(key, value),
+      toObject: () => Object.fromEntries(envVars)
+    },
+    server: {
+      upgradeWebSocket: (_request) => {
+        throw new Error(
+          "WebSocket upgrade not available in mock adapter. The mock adapter is designed for unit testing filesystem and environment operations. For WebSocket testing, use integration tests with the actual Deno/Node/Bun adapter, or mock the WebSocket behavior at a higher level in your tests."
+        );
       }
-      throw error;
-    }
-  }
-  async stat(path) {
-    const stat = await Deno.stat(path);
-    return {
-      isFile: stat.isFile,
-      isDirectory: stat.isDirectory,
-      isSymlink: stat.isSymlink,
-      size: stat.size,
-      mtime: stat.mtime
-    };
-  }
-  async mkdir(path, options) {
-    await Deno.mkdir(path, { recursive: options?.recursive ?? false });
-  }
-  async *readDir(path) {
-    for await (const entry of Deno.readDir(path)) {
-      yield {
-        name: entry.name,
-        isFile: entry.isFile,
-        isDirectory: entry.isDirectory
-      };
+    },
+    features: {
+      websocket: false,
+      http2: false,
+      workers: false,
+      jsx: false,
+      typescript: false
     }
-  }
-  async remove(path, options) {
-    await Deno.remove(path, { recursive: options?.recursive ?? false });
-  }
-  async makeTempDir(options) {
-    return await Deno.makeTempDir({ prefix: options?.prefix });
-  }
-};
-function createFileSystem() {
-  if (isDeno) {
-    return new DenoFileSystem();
-  } else {
-    return new NodeFileSystem();
-  }
+  };
 }
 
 // src/platform/compat/path-helper.ts
@@ -2949,7 +3162,7 @@ function getPathMod() {
     return pathMod;
   return nodePath;
 }
-var dirname = (path) => getPathMod().dirname(path);
+var dirname2 = (path) => getPathMod().dirname(path);
 var join2 = (...paths) => getPathMod().join(...paths);
 var resolve = (...paths) => getPathMod().resolve(...paths);
 var extname = (path) => getPathMod().extname(path);
@@ -2996,7 +3209,7 @@ function createFsAdapterPlugin(fsAdapter) {
       build.onResolve(
         { filter: /^\.\.?\// },
         async (args) => {
-          const importerDir = args.importer ? dirname(args.importer) : args.resolveDir;
+          const importerDir = args.importer ? dirname2(args.importer) : args.resolveDir;
           const basePath = resolve(importerDir, args.path);
           const resolvedPath = await resolveWithExtensions(basePath);
           if (resolvedPath) {
@@ -3023,7 +3236,7 @@ function createFsAdapterPlugin(fsAdapter) {
               contents: content,
               loader,
               // Set resolveDir for nested imports from this file
-              resolveDir: dirname(args.path)
+              resolveDir: dirname2(args.path)
             };
           } catch (error) {
             return {
@@ -3058,7 +3271,7 @@ async function importModule(file, context) {
   const isJsx = filePath.endsWith(".jsx");
   const loader = isTsx ? "tsx" : isJsx ? "jsx" : filePath.endsWith(".ts") ? "ts" : "js";
   const { build } = await import("esbuild");
-  const fileDir = dirname(filePath);
+  const fileDir = dirname2(filePath);
   const relativeImports = [];
   if (isDeno) {
     const relativeImportPattern = /from\s+["'](\.\.[^"']+)["']/g;
@@ -3522,9 +3735,8 @@ function generateId(prefix) {
 
 // src/ai/agent/memory.ts
 var ConversationMemory = class {
-  messages = [];
-  config;
   constructor(config) {
+    this.messages = [];
     this.config = config;
   }
   async add(message) {
@@ -3569,10 +3781,8 @@ var ConversationMemory = class {
   }
 };
 var BufferMemory = class {
-  messages = [];
-  config;
-  bufferSize;
   constructor(config) {
+    this.messages = [];
     this.config = config;
     this.bufferSize = config.maxMessages || 10;
   }
@@ -3606,11 +3816,9 @@ var BufferMemory = class {
   }
 };
 var SummaryMemory = class {
-  messages = [];
-  summary = "";
-  config;
-  summaryThreshold;
   constructor(config) {
+    this.messages = [];
+    this.summary = "";
     this.config = config;
     this.summaryThreshold = config.maxMessages || 20;
   }
@@ -3719,9 +3927,11 @@ var VERYFRONT_PATHS = {
 
 // src/core/utils/bundle-manifest.ts
 var InMemoryBundleManifestStore = class {
-  metadata = /* @__PURE__ */ new Map();
-  code = /* @__PURE__ */ new Map();
-  sourceIndex = /* @__PURE__ */ new Map();
+  constructor() {
+    this.metadata = /* @__PURE__ */ new Map();
+    this.code = /* @__PURE__ */ new Map();
+    this.sourceIndex = /* @__PURE__ */ new Map();
+  }
   getBundleMetadata(key) {
     const entry = this.metadata.get(key);
     if (!entry)
@@ -3812,6 +4022,9 @@ var InMemoryBundleManifestStore = class {
 };
 var manifestStore = new InMemoryBundleManifestStore();
 
+// src/core/utils/perf-timer.ts
+var enabled = typeof process !== "undefined" ? process.env?.VERYFRONT_PERF === "1" : typeof Deno !== "undefined" ? Deno.env.get("VERYFRONT_PERF") === "1" : false;
+
 // src/observability/tracing/config.ts
 var DEFAULT_CONFIG2 = {
   enabled: false,
@@ -4013,14 +4226,16 @@ var ContextPropagation = class {
 
 // src/observability/tracing/manager.ts
 var TracingManager = class {
-  state = {
-    initialized: false,
-    tracer: null,
-    api: null,
-    propagator: null
-  };
-  spanOps = null;
-  contextProp = null;
+  constructor() {
+    this.state = {
+      initialized: false,
+      tracer: null,
+      api: null,
+      propagator: null
+    };
+    this.spanOps = null;
+    this.contextProp = null;
+  }
   async initialize(config = {}, adapter) {
     if (this.state.initialized) {
       serverLogger.debug("[tracing] Already initialized");
@@ -4106,7 +4321,27 @@ async function withSpan(name, fn, options = {}) {
   );
 }
 
-// src/ai/agent/runtime.ts
+// src/ai/config/defaults.ts
+var AGENT_DEFAULTS = {
+  /** Maximum tokens for completion */
+  maxTokens: 4096,
+  /** Default temperature for generation */
+  temperature: 0.7,
+  /** Maximum agent loop steps */
+  maxSteps: 20,
+  /** Default memory type */
+  memoryType: "conversation",
+  /** Default memory max tokens */
+  memoryMaxTokens: 4e3
+};
+var STREAMING_DEFAULTS = {
+  /** Maximum buffer size for streaming (1MB) */
+  maxBufferSize: 1024 * 1024,
+  /** Chunk size for stream processing */
+  chunkSize: 16384
+};
+
+// src/ai/agent/streaming/stream-events.ts
 import { z as z6 } from "zod";
 var AgentStreamEventSchema = z6.discriminatedUnion("type", [
   z6.object({
@@ -4146,8 +4381,8 @@ var AgentStreamEventSchema = z6.discriminatedUnion("type", [
     })
   })
 ]);
-var DEFAULT_MAX_TOKENS = 4096;
-var DEFAULT_TEMPERATURE = 0.7;
+
+// src/ai/agent/message-converter.ts
 function convertMessageToProvider(msg) {
   const content = getTextFromParts(msg.parts);
   const providerMsg = {
@@ -4177,12 +4412,14 @@ function convertMessageToProvider(msg) {
   }
   return providerMsg;
 }
+
+// src/ai/agent/runtime.ts
+var DEFAULT_MAX_TOKENS = AGENT_DEFAULTS.maxTokens;
+var DEFAULT_TEMPERATURE = AGENT_DEFAULTS.temperature;
+var MAX_STREAM_BUFFER_SIZE = STREAMING_DEFAULTS.maxBufferSize;
 var AgentRuntime = class {
-  id;
-  config;
-  memory;
-  status = "idle";
   constructor(id, config) {
+    this.status = "idle";
     this.id = id;
     this.config = config;
     const memoryConfig = config.memory || { type: "conversation", maxTokens: 4e3 };
@@ -4610,6 +4847,10 @@ var AgentRuntime = class {
         if (done)
           break;
         partial += decoder.decode(value, { stream: true });
+        if (partial.length > MAX_STREAM_BUFFER_SIZE) {
+          serverLogger.warn("[AGENT] Stream buffer exceeded max size, truncating");
+          partial = partial.slice(-MAX_STREAM_BUFFER_SIZE / 2);
+        }
         const segments = partial.split("\n");
         partial = segments.pop() ?? "";
         const lines = segments.filter((line) => line.trim());
@@ -5166,7 +5407,6 @@ async function setupAI(options = {}) {
 
 // src/ai/mcp/server.ts
 var MCPServer = class {
-  config;
   constructor(config) {
     this.config = config;
   }
@@ -5477,9 +5717,8 @@ import { anthropic } from "@ai-sdk/anthropic";
 
 // src/ai/production/rate-limit/limiter.ts
 var FixedWindowLimiter = class {
-  requests = /* @__PURE__ */ new Map();
-  config;
   constructor(config) {
+    this.requests = /* @__PURE__ */ new Map();
     this.config = config;
   }
   check(identifier) {
@@ -5520,10 +5759,8 @@ var FixedWindowLimiter = class {
   }
 };
 var TokenBucketLimiter = class {
-  buckets = /* @__PURE__ */ new Map();
-  config;
-  refillRate;
   constructor(config) {
+    this.buckets = /* @__PURE__ */ new Map();
     this.config = config;
     this.refillRate = config.maxRequests / config.windowMs;
   }
@@ -5626,7 +5863,9 @@ function rateLimitMiddleware(config) {
 
 // src/ai/production/cache/cache.ts
 var MemoryCache = class {
-  cache = /* @__PURE__ */ new Map();
+  constructor() {
+    this.cache = /* @__PURE__ */ new Map();
+  }
   set(key, response) {
     this.cache.set(key, {
       response,
@@ -5657,9 +5896,8 @@ var MemoryCache = class {
   }
 };
 var LRUCache = class {
-  cache = /* @__PURE__ */ new Map();
-  maxSize;
   constructor(maxSize = 100) {
+    this.cache = /* @__PURE__ */ new Map();
     this.maxSize = maxSize;
   }
   set(key, response) {
@@ -5703,10 +5941,9 @@ var LRUCache = class {
   }
 };
 var TTLCache = class {
-  cache = /* @__PURE__ */ new Map();
-  ttl;
-  cleanupInterval = null;
   constructor(ttl = 3e5) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.cleanupInterval = null;
     this.ttl = ttl;
     this.startCleanup();
   }
@@ -5860,14 +6097,13 @@ function cacheMiddleware(config) {
 
 // src/ai/production/cost-tracking/tracker.ts
 var CostTracker = class {
-  records = [];
-  config;
-  dailyTotal = 0;
-  monthlyTotal = 0;
-  lastDayReset = Date.now();
-  lastMonthReset = Date.now();
-  resetInterval = null;
   constructor(config) {
+    this.records = [];
+    this.dailyTotal = 0;
+    this.monthlyTotal = 0;
+    this.lastDayReset = Date.now();
+    this.lastMonthReset = Date.now();
+    this.resetInterval = null;
     this.config = config;
     this.startPeriodicReset();
   }
@@ -6130,7 +6366,6 @@ var PII_PATTERNS = {
   creditCard: /\b\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b/g
 };
 var InputValidator = class {
-  config;
   constructor(config) {
     this.config = config || {};
   }
@@ -6190,7 +6425,6 @@ var InputValidator = class {
   }
 };
 var OutputFilter = class {
-  config;
   constructor(config) {
     this.config = config || {};
   }
@@ -6464,13 +6698,12 @@ function hasLockSupport(backend) {
 // src/ai/workflow/backends/memory.ts
 var DEFAULT_MAX_QUEUE_SIZE = 1e4;
 var MemoryBackend = class {
-  runs = /* @__PURE__ */ new Map();
-  checkpoints = /* @__PURE__ */ new Map();
-  approvals = /* @__PURE__ */ new Map();
-  queue = [];
-  locks = /* @__PURE__ */ new Map();
-  config;
   constructor(config = {}) {
+    this.runs = /* @__PURE__ */ new Map();
+    this.checkpoints = /* @__PURE__ */ new Map();
+    this.approvals = /* @__PURE__ */ new Map();
+    this.queue = [];
+    this.locks = /* @__PURE__ */ new Map();
     this.config = {
       prefix: "wf:",
       debug: false,
@@ -6801,7 +7034,6 @@ var MemoryBackend = class {
 
 // src/ai/workflow/executor/dag-executor.ts
 var DAGExecutor = class {
-  config;
   constructor(config) {
     this.config = {
       maxConcurrency: 10,
@@ -6944,9 +7176,16 @@ var DAGExecutor = class {
           context,
           nodeStates
         );
+      case "loop":
+        return await this.executeLoopNode(
+          node,
+          config,
+          context,
+          nodeStates
+        );
       default:
         throw new Error(
-          `Unknown node type "${config.type}" for node "${node.id}". Valid types are: step, parallel, map, branch, wait, subWorkflow`
+          `Unknown node type "${config.type}" for node "${node.id}". Valid types are: step, parallel, map, branch, wait, subWorkflow, loop`
         );
     }
   }
@@ -7104,6 +7343,155 @@ var DAGExecutor = class {
       waiting: result.waiting
     };
   }
+  /**
+   * Execute a loop node
+   */
+  async executeLoopNode(node, config, context, nodeStates) {
+    const startTime = Date.now();
+    const previousResults = [];
+    let iteration = 0;
+    let exitReason = "condition";
+    let lastError;
+    const existingLoopState = context[`${node.id}_loop_state`];
+    if (existingLoopState) {
+      iteration = existingLoopState.iteration;
+      previousResults.push(...existingLoopState.previousResults);
+    }
+    while (iteration < config.maxIterations) {
+      const loopContext = {
+        iteration,
+        totalIterations: iteration,
+        previousResults: [...previousResults],
+        isFirstIteration: iteration === 0,
+        isLastAllowedIteration: iteration === config.maxIterations - 1
+      };
+      const shouldContinue = await config.while(context, loopContext);
+      if (!shouldContinue) {
+        exitReason = "condition";
+        break;
+      }
+      const steps = typeof config.steps === "function" ? config.steps(context, loopContext) : config.steps;
+      const result = await this.execute(steps, {
+        id: `${node.id}_iter_${iteration}`,
+        workflowId: "",
+        status: "running",
+        input: context.input,
+        nodeStates: {},
+        currentNodes: [],
+        context: { ...context, _loop: loopContext },
+        checkpoints: [],
+        pendingApprovals: [],
+        createdAt: /* @__PURE__ */ new Date()
+      });
+      if (result.waiting) {
+        Object.assign(nodeStates, result.nodeStates);
+        const state2 = {
+          nodeId: node.id,
+          status: "running",
+          output: {
+            iteration,
+            waiting: true,
+            previousResults
+          },
+          attempt: 1,
+          startedAt: new Date(startTime)
+        };
+        return {
+          state: state2,
+          contextUpdates: {
+            ...result.context,
+            [`${node.id}_loop_state`]: { iteration, previousResults }
+          },
+          waiting: true
+        };
+      }
+      if (result.error) {
+        lastError = result.error;
+        exitReason = "error";
+        break;
+      }
+      previousResults.push(result.context);
+      Object.assign(context, result.context);
+      Object.assign(nodeStates, result.nodeStates);
+      if (config.delay && iteration < config.maxIterations - 1) {
+        const delayMs = typeof config.delay === "number" ? config.delay : this.parseDuration(config.delay);
+        await this.sleep(delayMs);
+      }
+      iteration++;
+    }
+    if (iteration >= config.maxIterations && exitReason !== "condition") {
+      exitReason = "maxIterations";
+    }
+    const finalLoopContext = {
+      iteration,
+      totalIterations: iteration,
+      previousResults,
+      isFirstIteration: false,
+      isLastAllowedIteration: true
+    };
+    let completionUpdates = {};
+    if (exitReason === "maxIterations" && config.onMaxIterations) {
+      completionUpdates = await config.onMaxIterations(context, finalLoopContext);
+    } else if (exitReason === "condition" && config.onComplete) {
+      completionUpdates = await config.onComplete(context, finalLoopContext);
+    }
+    const output = {
+      exitReason,
+      iterations: iteration,
+      previousResults,
+      ...completionUpdates
+    };
+    const state = {
+      nodeId: node.id,
+      status: exitReason === "error" ? "failed" : "completed",
+      output,
+      error: lastError,
+      attempt: 1,
+      startedAt: new Date(startTime),
+      completedAt: /* @__PURE__ */ new Date()
+    };
+    this.config.onNodeComplete?.(node.id, state);
+    return {
+      state,
+      contextUpdates: {
+        [node.id]: output,
+        ...completionUpdates
+      },
+      waiting: false
+    };
+  }
+  /**
+   * Parse duration string to milliseconds
+   */
+  parseDuration(duration) {
+    if (typeof duration === "number")
+      return duration;
+    const match = duration.match(/^(\d+)(ms|s|m|h|d)$/);
+    if (!match)
+      return 0;
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+    switch (unit) {
+      case "ms":
+        return value;
+      case "s":
+        return value * 1e3;
+      case "m":
+        return value * 60 * 1e3;
+      case "h":
+        return value * 60 * 60 * 1e3;
+      case "d":
+        return value * 24 * 60 * 60 * 1e3;
+      default:
+        return 0;
+    }
+  }
+  /**
+   * Sleep for specified milliseconds
+   */
+  sleep(ms) {
+    return new Promise((resolve2) => setTimeout(resolve2, ms));
+  }
   /**
    * Execute a step node
    */
@@ -7343,7 +7731,6 @@ var DAGExecutor = class {
 
 // src/ai/workflow/executor/checkpoint-manager.ts
 var CheckpointManager = class {
-  config;
   constructor(config) {
     this.config = {
       debug: false,
@@ -7499,9 +7886,14 @@ var CheckpointManager = class {
 };
 
 // src/ai/workflow/executor/step-executor.ts
+var DEFAULT_RETRY = {
+  maxAttempts: 1,
+  backoff: "exponential",
+  initialDelay: 1e3,
+  maxDelay: 3e4
+};
 var DEFAULT_STEP_TIMEOUT_MS = 5 * 60 * 1e3;
 var StepExecutor = class {
-  config;
   constructor(config = {}) {
     this.config = {
       defaultTimeout: DEFAULT_STEP_TIMEOUT_MS,
@@ -7509,7 +7901,7 @@ var StepExecutor = class {
     };
   }
   /**
-   * Execute a step node
+   * Execute a step node with retry support
    */
   async execute(node, context) {
     const startTime = Date.now();
@@ -7519,30 +7911,96 @@ var StepExecutor = class {
         `StepExecutor can only execute 'step' nodes, but node "${node.id}" has type '${config.type}'. This is likely a bug in the DAG executor routing.`
       );
     }
-    try {
-      const resolvedInput = await this.resolveInput(config.input, context);
-      this.config.onStepStart?.(node.id, resolvedInput);
-      const timeout = config.timeout ? parseDuration(config.timeout) : this.config.defaultTimeout;
-      const output = await this.executeWithTimeout(
-        () => this.executeStep(config, resolvedInput, context),
-        timeout,
-        node.id
-      );
-      this.config.onStepComplete?.(node.id, output);
-      return {
-        success: true,
-        output,
-        executionTime: Date.now() - startTime
-      };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      this.config.onStepError?.(node.id, error);
-      return {
-        success: false,
-        error: errorMessage,
-        executionTime: Date.now() - startTime
-      };
+    const retryConfig = { ...DEFAULT_RETRY, ...config.retry };
+    const maxAttempts = retryConfig.maxAttempts ?? 1;
+    let lastError;
+    let attempt = 0;
+    while (attempt < maxAttempts) {
+      attempt++;
+      try {
+        const resolvedInput = await this.resolveInput(config.input, context);
+        this.config.onStepStart?.(node.id, resolvedInput);
+        const timeout = config.timeout ? parseDuration(config.timeout) : this.config.defaultTimeout;
+        const output = await this.executeWithTimeout(
+          () => this.executeStep(config, resolvedInput, context),
+          timeout,
+          node.id
+        );
+        this.config.onStepComplete?.(node.id, output);
+        return {
+          success: true,
+          output,
+          executionTime: Date.now() - startTime
+        };
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        const shouldRetry = attempt < maxAttempts && this.isRetryableError(lastError, retryConfig);
+        if (shouldRetry) {
+          const delay2 = this.calculateRetryDelay(attempt, retryConfig);
+          await this.sleep(delay2);
+          continue;
+        }
+        this.config.onStepError?.(node.id, lastError);
+        return {
+          success: false,
+          error: lastError.message,
+          executionTime: Date.now() - startTime
+        };
+      }
+    }
+    return {
+      success: false,
+      error: lastError?.message ?? "Unknown error",
+      executionTime: Date.now() - startTime
+    };
+  }
+  /**
+   * Check if error is retryable
+   */
+  isRetryableError(error, config) {
+    if (config.retryIf) {
+      return config.retryIf(error);
     }
+    const retryablePatterns = [
+      /timeout/i,
+      /ECONNRESET/i,
+      /ECONNREFUSED/i,
+      /ETIMEDOUT/i,
+      /rate limit/i,
+      /429/,
+      /503/,
+      /502/
+    ];
+    return retryablePatterns.some((pattern) => pattern.test(error.message));
+  }
+  /**
+   * Calculate retry delay based on backoff strategy
+   */
+  calculateRetryDelay(attempt, config) {
+    const initialDelay = config.initialDelay ?? 1e3;
+    const maxDelay = config.maxDelay ?? 3e4;
+    let delay2;
+    switch (config.backoff) {
+      case "exponential":
+        delay2 = initialDelay * Math.pow(2, attempt - 1);
+        break;
+      case "linear":
+        delay2 = initialDelay * attempt;
+        break;
+      case "fixed":
+      default:
+        delay2 = initialDelay;
+        break;
+    }
+    const jitter = delay2 * 0.1 * (Math.random() * 2 - 1);
+    delay2 = Math.min(delay2 + jitter, maxDelay);
+    return Math.floor(delay2);
+  }
+  /**
+   * Sleep for specified milliseconds
+   */
+  sleep(ms) {
+    return new Promise((resolve2) => setTimeout(resolve2, ms));
   }
   /**
    * Resolve step input from context
@@ -7723,15 +8181,8 @@ var StepExecutor = class {
 
 // src/ai/workflow/executor/workflow-executor.ts
 var WorkflowExecutor = class _WorkflowExecutor {
-  config;
-  stepExecutor;
-  checkpointManager;
-  dagExecutor;
-  workflows = /* @__PURE__ */ new Map();
-  blobResolver;
-  /** Default lock duration: 30 seconds */
-  static DEFAULT_LOCK_DURATION = 3e4;
   constructor(config) {
+    this.workflows = /* @__PURE__ */ new Map();
     this.config = {
       maxConcurrency: 10,
       debug: false,
@@ -7767,6 +8218,10 @@ var WorkflowExecutor = class _WorkflowExecutor {
       };
     }
   }
+  static {
+    /** Default lock duration: 30 seconds */
+    this.DEFAULT_LOCK_DURATION = 3e4;
+  }
   /**
    * Register a workflow definition
    */
@@ -8121,10 +8576,8 @@ var WorkflowExecutor = class _WorkflowExecutor {
 
 // src/ai/workflow/runtime/approval-manager.ts
 var ApprovalManager = class {
-  config;
-  expirationTimer;
-  destroyed = false;
   constructor(config) {
+    this.destroyed = false;
     this.config = {
       expirationCheckInterval: 6e4,
       // Check every minute
@@ -8351,17 +8804,41 @@ var ApprovalManager = class {
 
 // src/ai/workflow/api/workflow-client.ts
 var WorkflowClient = class {
-  backend;
-  executor;
-  approvalManager;
-  debug;
   constructor(config = {}) {
     this.debug = config.debug ?? false;
     this.backend = config.backend ?? new MemoryBackend({ debug: this.debug });
     this.executor = new WorkflowExecutor({
       backend: this.backend,
       debug: this.debug,
-      ...config.executor
+      ...config.executor,
+      onWaiting: async (run, nodeId) => {
+        const nodeState = run.nodeStates[nodeId];
+        if (!nodeState?.input) {
+          if (this.debug) {
+            console.log(`[WorkflowClient] No wait config found for node: ${nodeId}`);
+          }
+          return;
+        }
+        const input = nodeState.input;
+        if (input.type !== "approval") {
+          return;
+        }
+        const waitConfig = {
+          type: "wait",
+          waitType: "approval",
+          message: input.message,
+          payload: input.payload
+        };
+        try {
+          await this.approvalManager.createApproval(run, nodeId, waitConfig, run.context);
+          if (this.debug) {
+            console.log(`[WorkflowClient] Created approval for node: ${nodeId}`);
+          }
+        } catch (error) {
+          console.error(`[WorkflowClient] Failed to create approval:`, error);
+        }
+        config.executor?.onWaiting?.(run, nodeId);
+      }
     });
     this.approvalManager = new ApprovalManager({
       backend: this.backend,