veryfront 0.0.12 → 0.0.13

package/dist/ai/index.js

@@ -1,5 +1,5 @@
 // src/ai/providers/openai.ts
-import { z } from "zod";
+import { z as z2 } from "zod";
 
 // src/core/errors/veryfront-error.ts
 function createError(error) {
@@ -135,6 +135,23 @@ var agentLogger = createLogger("AGENT");
 var logger = createLogger("VERYFRONT");
 
 // src/ai/providers/base.ts
+import { z } from "zod";
+var OpenAIStreamChunkSchema = z.object({
+  choices: z.array(z.object({
+    delta: z.object({
+      content: z.string().optional().nullable(),
+      tool_calls: z.array(z.object({
+        index: z.number().optional(),
+        id: z.string().optional(),
+        function: z.object({
+          name: z.string().optional(),
+          arguments: z.string().optional()
+        }).optional()
+      })).optional()
+    }),
+    finish_reason: z.string().nullable()
+  })).min(1)
+});
 var BaseProvider = class {
   constructor(config) {
     this.config = config;
@@ -238,8 +255,12 @@ var BaseProvider = class {
                   continue;
                 }
                 try {
-                  const parsed = JSON.parse(data);
-                  const choice = parsed.choices?.[0];
+                  const raw = JSON.parse(data);
+                  const result = OpenAIStreamChunkSchema.safeParse(raw);
+                  if (!result.success) {
+                    continue;
+                  }
+                  const choice = result.data.choices[0];
                   if (!choice)
                     continue;
                   const delta = choice.delta;
@@ -324,25 +345,25 @@ var BaseProvider = class {
 };
 
 // src/ai/providers/openai.ts
-var OpenAIToolCallSchema = z.object({
-  id: z.string(),
-  function: z.object({
-    name: z.string(),
-    arguments: z.string()
+var OpenAIToolCallSchema = z2.object({
+  id: z2.string(),
+  function: z2.object({
+    name: z2.string(),
+    arguments: z2.string()
   })
 });
-var OpenAIResponseSchema = z.object({
-  choices: z.array(z.object({
-    message: z.object({
-      content: z.string().nullable().optional(),
-      tool_calls: z.array(OpenAIToolCallSchema).optional()
+var OpenAIResponseSchema = z2.object({
+  choices: z2.array(z2.object({
+    message: z2.object({
+      content: z2.string().nullable().optional(),
+      tool_calls: z2.array(OpenAIToolCallSchema).optional()
     }),
-    finish_reason: z.string()
+    finish_reason: z2.string()
   })).min(1),
-  usage: z.object({
-    prompt_tokens: z.number().optional(),
-    completion_tokens: z.number().optional(),
-    total_tokens: z.number().optional()
+  usage: z2.object({
+    prompt_tokens: z2.number().optional(),
+    completion_tokens: z2.number().optional(),
+    total_tokens: z2.number().optional()
   }).optional()
 });
 var OpenAIProvider = class extends BaseProvider {
@@ -727,26 +748,26 @@ var AnthropicProvider = class extends BaseProvider {
 };
 
 // src/ai/providers/google.ts
-import { z as z2 } from "zod";
-var GoogleToolCallSchema = z2.object({
-  id: z2.string(),
-  function: z2.object({
-    name: z2.string(),
-    arguments: z2.union([z2.string(), z2.record(z2.unknown())])
+import { z as z3 } from "zod";
+var GoogleToolCallSchema = z3.object({
+  id: z3.string(),
+  function: z3.object({
+    name: z3.string(),
+    arguments: z3.union([z3.string(), z3.record(z3.unknown())])
   })
 });
-var GoogleResponseSchema = z2.object({
-  choices: z2.array(z2.object({
-    message: z2.object({
-      content: z2.string().nullable().optional(),
-      tool_calls: z2.array(GoogleToolCallSchema).optional()
+var GoogleResponseSchema = z3.object({
+  choices: z3.array(z3.object({
+    message: z3.object({
+      content: z3.string().nullable().optional(),
+      tool_calls: z3.array(GoogleToolCallSchema).optional()
     }),
-    finish_reason: z2.string()
+    finish_reason: z3.string()
   })).min(1),
-  usage: z2.object({
-    prompt_tokens: z2.number().optional(),
-    completion_tokens: z2.number().optional(),
-    total_tokens: z2.number().optional()
+  usage: z3.object({
+    prompt_tokens: z3.number().optional(),
+    completion_tokens: z3.number().optional(),
+    total_tokens: z3.number().optional()
   }).optional()
 });
 var GoogleProvider = class extends BaseProvider {
@@ -1688,7 +1709,7 @@ var BYTES_PER_MB = 1024 * 1024;
 // deno.json
 var deno_default = {
   name: "veryfront",
-  version: "0.0.12",
+  version: "0.0.13",
   nodeModulesDir: "auto",
   workspace: [
     "./examples/async-worker-redis",
@@ -2280,6 +2301,45 @@ async function withSpan(name, fn, options = {}) {
 }
 
 // src/ai/agent/runtime.ts
+import { z as z4 } from "zod";
+var AgentStreamEventSchema = z4.discriminatedUnion("type", [
+  z4.object({
+    type: z4.literal("content"),
+    content: z4.string()
+  }),
+  z4.object({
+    type: z4.literal("tool_call_start"),
+    toolCall: z4.object({
+      id: z4.string(),
+      name: z4.string()
+    })
+  }),
+  z4.object({
+    type: z4.literal("tool_call_delta"),
+    id: z4.string(),
+    arguments: z4.string()
+  }),
+  z4.object({
+    type: z4.literal("tool_call_complete"),
+    toolCall: z4.object({
+      id: z4.string(),
+      name: z4.string(),
+      arguments: z4.string()
+    })
+  }),
+  z4.object({
+    type: z4.literal("finish"),
+    finishReason: z4.string().nullable()
+  }),
+  z4.object({
+    type: z4.literal("usage"),
+    usage: z4.object({
+      promptTokens: z4.number().optional(),
+      completionTokens: z4.number().optional(),
+      totalTokens: z4.number().optional()
+    })
+  })
+]);
 var DEFAULT_MAX_TOKENS = 4096;
 var DEFAULT_TEMPERATURE = 0.7;
 var AgentRuntime = class {
@@ -2561,6 +2621,42 @@ var AgentRuntime = class {
       let accumulatedText = "";
       let finishReason = null;
       const streamToolCalls = /* @__PURE__ */ new Map();
+      const parseStreamToolArgs = (rawArgs) => {
+        try {
+          const parsed = typeof rawArgs === "string" ? JSON.parse(rawArgs) : rawArgs;
+          if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return { args: parsed };
+          }
+          return { args: {}, error: "Tool call arguments must be a JSON object" };
+        } catch (error) {
+          return {
+            args: {},
+            error: error instanceof Error ? error.message : String(error)
+          };
+        }
+      };
+      const recordToolError = async (toolCall, errorStr) => {
+        toolCall.status = "error";
+        toolCall.error = errorStr;
+        toolCalls.push(toolCall);
+        const errorData = JSON.stringify({
+          type: "error",
+          error: errorStr
+        });
+        controller.enqueue(encoder.encode(`data: ${errorData}
+
+`));
+        const errorMessage = {
+          id: `tool_error_${toolCall.id}`,
+          role: "tool",
+          content: `Error: ${errorStr}`,
+          toolCallId: toolCall.id,
+          toolCall,
+          timestamp: Date.now()
+        };
+        currentMessages.push(errorMessage);
+        await this.memory.add(errorMessage);
+      };
       const handleEvent = (event) => {
         switch (event.type) {
           case "content": {
@@ -2624,17 +2720,26 @@ var AgentRuntime = class {
         const lines = segments.filter((line) => line.trim());
         for (const line of lines) {
           try {
-            const event = JSON.parse(line);
-            handleEvent(event);
-          } catch {
+            const rawEvent = JSON.parse(line);
+            const parseResult = AgentStreamEventSchema.safeParse(rawEvent);
+            if (parseResult.success) {
+              handleEvent(parseResult.data);
+            } else {
+              serverLogger.warn("[AGENT] Invalid stream event received:", parseResult.error);
+            }
+          } catch (e) {
+            serverLogger.warn("[AGENT] Failed to parse stream line:", e);
             continue;
           }
         }
       }
       if (partial.trim()) {
         try {
-          const event = JSON.parse(partial);
-          handleEvent(event);
+          const rawEvent = JSON.parse(partial);
+          const parseResult = AgentStreamEventSchema.safeParse(rawEvent);
+          if (parseResult.success) {
+            handleEvent(parseResult.data);
+          }
         } catch {
         }
       }
@@ -2645,23 +2750,41 @@ var AgentRuntime = class {
         timestamp: Date.now()
       };
       if (streamToolCalls.size > 0) {
-        assistantMessage.toolCalls = Array.from(streamToolCalls.values()).map((tc) => ({
-          id: tc.id,
-          name: tc.name,
-          arguments: JSON.parse(tc.arguments)
-        }));
+        assistantMessage.toolCalls = Array.from(streamToolCalls.values()).map((tc) => {
+          const { args, error } = parseStreamToolArgs(tc.arguments);
+          if (error) {
+            serverLogger.warn("[AGENT] Failed to parse streamed tool arguments", {
+              toolCallId: tc.id,
+              error
+            });
+          }
+          return {
+            id: tc.id,
+            name: tc.name,
+            arguments: args
+          };
+        });
       }
       currentMessages.push(assistantMessage);
       await this.memory.add(assistantMessage);
       if (finishReason === "tool_calls" && streamToolCalls.size > 0) {
         this.status = "tool_execution";
         for (const tc of streamToolCalls.values()) {
+          const { args, error: argError } = parseStreamToolArgs(tc.arguments);
           const toolCall = {
             id: tc.id,
             name: tc.name,
-            args: JSON.parse(tc.arguments),
+            args,
             status: "pending"
           };
+          if (argError) {
+            serverLogger.warn("[AGENT] Invalid streamed tool arguments", {
+              toolCallId: tc.id,
+              error: argError
+            });
+            await recordToolError(toolCall, `Invalid tool arguments: ${argError}`);
+            continue;
+          }
           try {
             toolCall.status = "executing";
             const startTime = Date.now();
@@ -2708,26 +2831,8 @@ var AgentRuntime = class {
             currentMessages.push(toolResultMessage);
             await this.memory.add(toolResultMessage);
           } catch (error) {
-            toolCall.status = "error";
-            toolCall.error = error instanceof Error ? error.message : String(error);
-            toolCalls.push(toolCall);
-            const errorData = JSON.stringify({
-              type: "error",
-              error: toolCall.error
-            });
-            controller.enqueue(encoder.encode(`data: ${errorData}
-
-`));
-            const errorMessage = {
-              id: `tool_error_${tc.id}`,
-              role: "tool",
-              content: `Error: ${toolCall.error}`,
-              toolCallId: tc.id,
-              toolCall,
-              timestamp: Date.now()
-            };
-            currentMessages.push(errorMessage);
-            await this.memory.add(errorMessage);
+            const errorStr = error instanceof Error ? error.message : String(error);
+            await recordToolError(toolCall, errorStr);
           }
         }
         this.status = "thinking";
@@ -3178,13 +3283,13 @@ function generateAgentId() {
 }
 
 // src/ai/agent/composition.ts
-import { z as z3 } from "zod";
+import { z as z5 } from "zod";
 function agentAsTool(agent2, description) {
   return {
     id: `agent_${agent2.id}`,
     description,
-    inputSchema: z3.object({
-      input: z3.string().describe("Input for the agent")
+    inputSchema: z5.object({
+      input: z5.string().describe("Input for the agent")
     }),
     async execute({ input }) {
       const response = await agent2.generate({ input });
@@ -3264,125 +3369,138 @@ function getAgentsAsTools(descriptions) {
 }
 
 // src/core/config/schema.ts
-import { z as z4 } from "zod";
-var corsSchema = z4.union([z4.boolean(), z4.object({ origin: z4.string().optional() }).strict()]);
-var veryfrontConfigSchema = z4.object({
-  title: z4.string().optional(),
-  description: z4.string().optional(),
-  experimental: z4.object({
-    esmLayouts: z4.boolean().optional(),
-    precompileMDX: z4.boolean().optional()
+import { z as z6 } from "zod";
+var corsSchema = z6.union([z6.boolean(), z6.object({ origin: z6.string().optional() }).strict()]);
+var veryfrontConfigSchema = z6.object({
+  title: z6.string().optional(),
+  description: z6.string().optional(),
+  experimental: z6.object({
+    esmLayouts: z6.boolean().optional(),
+    precompileMDX: z6.boolean().optional()
   }).partial().optional(),
-  router: z4.enum(["app", "pages"]).optional(),
-  defaultLayout: z4.string().optional(),
-  theme: z4.object({ colors: z4.record(z4.string()).optional() }).partial().optional(),
-  build: z4.object({
-    outDir: z4.string().optional(),
-    trailingSlash: z4.boolean().optional(),
-    esbuild: z4.object({
-      wasmURL: z4.string().url().optional(),
-      worker: z4.boolean().optional()
+  router: z6.enum(["app", "pages"]).optional(),
+  defaultLayout: z6.string().optional(),
+  theme: z6.object({ colors: z6.record(z6.string()).optional() }).partial().optional(),
+  build: z6.object({
+    outDir: z6.string().optional(),
+    trailingSlash: z6.boolean().optional(),
+    esbuild: z6.object({
+      wasmURL: z6.string().url().optional(),
+      worker: z6.boolean().optional()
     }).partial().optional()
   }).partial().optional(),
-  cache: z4.object({
-    dir: z4.string().optional(),
-    bundleManifest: z4.object({
-      type: z4.enum(["redis", "kv", "memory"]).optional(),
-      redisUrl: z4.string().optional(),
-      keyPrefix: z4.string().optional(),
-      ttl: z4.number().int().positive().optional(),
-      enabled: z4.boolean().optional()
+  cache: z6.object({
+    dir: z6.string().optional(),
+    bundleManifest: z6.object({
+      type: z6.enum(["redis", "kv", "memory"]).optional(),
+      redisUrl: z6.string().optional(),
+      keyPrefix: z6.string().optional(),
+      ttl: z6.number().int().positive().optional(),
+      enabled: z6.boolean().optional()
     }).partial().optional()
   }).partial().optional(),
-  dev: z4.object({
-    port: z4.number().int().positive().optional(),
-    host: z4.string().optional(),
-    open: z4.boolean().optional(),
-    hmr: z4.boolean().optional(),
-    components: z4.array(z4.string()).optional()
+  dev: z6.object({
+    port: z6.number().int().positive().optional(),
+    host: z6.string().optional(),
+    open: z6.boolean().optional(),
+    hmr: z6.boolean().optional(),
+    components: z6.array(z6.string()).optional()
   }).partial().optional(),
-  resolve: z4.object({
-    importMap: z4.object({
-      imports: z4.record(z4.string()).optional(),
-      scopes: z4.record(z4.record(z4.string())).optional()
+  resolve: z6.object({
+    importMap: z6.object({
+      imports: z6.record(z6.string()).optional(),
+      scopes: z6.record(z6.record(z6.string())).optional()
     }).partial().optional()
   }).partial().optional(),
-  security: z4.object({
-    csp: z4.record(z4.array(z4.string())).optional(),
-    remoteHosts: z4.array(z4.string().url()).optional(),
+  security: z6.object({
+    csp: z6.record(z6.array(z6.string())).optional(),
+    remoteHosts: z6.array(z6.string().url()).optional(),
     cors: corsSchema.optional(),
-    coop: z4.enum(["same-origin", "same-origin-allow-popups", "unsafe-none"]).optional(),
-    corp: z4.enum(["same-origin", "same-site", "cross-origin"]).optional(),
-    coep: z4.enum(["require-corp", "unsafe-none"]).optional()
+    coop: z6.enum(["same-origin", "same-origin-allow-popups", "unsafe-none"]).optional(),
+    corp: z6.enum(["same-origin", "same-site", "cross-origin"]).optional(),
+    coep: z6.enum(["require-corp", "unsafe-none"]).optional()
   }).partial().optional(),
-  middleware: z4.object({
-    custom: z4.array(z4.function()).optional()
+  middleware: z6.object({
+    custom: z6.array(z6.function()).optional()
   }).partial().optional(),
-  theming: z4.object({
-    brandName: z4.string().optional(),
-    logoHtml: z4.string().optional()
+  theming: z6.object({
+    brandName: z6.string().optional(),
+    logoHtml: z6.string().optional()
   }).partial().optional(),
-  assetPipeline: z4.object({
-    images: z4.object({
-      enabled: z4.boolean().optional(),
-      formats: z4.array(z4.enum(["webp", "avif", "jpeg", "png"])).optional(),
-      sizes: z4.array(z4.number().int().positive()).optional(),
-      quality: z4.number().int().min(1).max(100).optional(),
-      inputDir: z4.string().optional(),
-      outputDir: z4.string().optional(),
-      preserveOriginal: z4.boolean().optional()
+  assetPipeline: z6.object({
+    images: z6.object({
+      enabled: z6.boolean().optional(),
+      formats: z6.array(z6.enum(["webp", "avif", "jpeg", "png"])).optional(),
+      sizes: z6.array(z6.number().int().positive()).optional(),
+      quality: z6.number().int().min(1).max(100).optional(),
+      inputDir: z6.string().optional(),
+      outputDir: z6.string().optional(),
+      preserveOriginal: z6.boolean().optional()
     }).partial().optional(),
-    css: z4.object({
-      enabled: z4.boolean().optional(),
-      minify: z4.boolean().optional(),
-      autoprefixer: z4.boolean().optional(),
-      purge: z4.boolean().optional(),
-      criticalCSS: z4.boolean().optional(),
-      inputDir: z4.string().optional(),
-      outputDir: z4.string().optional(),
-      browsers: z4.array(z4.string()).optional(),
-      purgeContent: z4.array(z4.string()).optional(),
-      sourceMap: z4.boolean().optional()
+    css: z6.object({
+      enabled: z6.boolean().optional(),
+      minify: z6.boolean().optional(),
+      autoprefixer: z6.boolean().optional(),
+      purge: z6.boolean().optional(),
+      criticalCSS: z6.boolean().optional(),
+      inputDir: z6.string().optional(),
+      outputDir: z6.string().optional(),
+      browsers: z6.array(z6.string()).optional(),
+      purgeContent: z6.array(z6.string()).optional(),
+      sourceMap: z6.boolean().optional()
     }).partial().optional()
   }).partial().optional(),
-  observability: z4.object({
-    tracing: z4.object({
-      enabled: z4.boolean().optional(),
-      exporter: z4.enum(["jaeger", "zipkin", "otlp", "console"]).optional(),
-      endpoint: z4.string().optional(),
-      serviceName: z4.string().optional(),
-      sampleRate: z4.number().min(0).max(1).optional()
+  observability: z6.object({
+    tracing: z6.object({
+      enabled: z6.boolean().optional(),
+      exporter: z6.enum(["jaeger", "zipkin", "otlp", "console"]).optional(),
+      endpoint: z6.string().optional(),
+      serviceName: z6.string().optional(),
+      sampleRate: z6.number().min(0).max(1).optional()
     }).partial().optional(),
-    metrics: z4.object({
-      enabled: z4.boolean().optional(),
-      exporter: z4.enum(["prometheus", "otlp", "console"]).optional(),
-      endpoint: z4.string().optional(),
-      prefix: z4.string().optional(),
-      collectInterval: z4.number().int().positive().optional()
+    metrics: z6.object({
+      enabled: z6.boolean().optional(),
+      exporter: z6.enum(["prometheus", "otlp", "console"]).optional(),
+      endpoint: z6.string().optional(),
+      prefix: z6.string().optional(),
+      collectInterval: z6.number().int().positive().optional()
     }).partial().optional()
   }).partial().optional(),
-  fs: z4.object({
-    type: z4.enum(["local", "veryfront-api", "memory"]).optional(),
-    local: z4.object({
-      baseDir: z4.string().optional()
+  fs: z6.object({
+    type: z6.enum(["local", "veryfront-api", "memory"]).optional(),
+    local: z6.object({
+      baseDir: z6.string().optional()
     }).partial().optional(),
-    veryfront: z4.object({
-      apiBaseUrl: z4.string().url(),
-      apiToken: z4.string(),
-      projectSlug: z4.string(),
-      cache: z4.object({
-        enabled: z4.boolean().optional(),
-        ttl: z4.number().int().positive().optional(),
-        maxSize: z4.number().int().positive().optional()
+    veryfront: z6.object({
+      apiBaseUrl: z6.string().url(),
+      apiToken: z6.string(),
+      projectSlug: z6.string(),
+      cache: z6.object({
+        enabled: z6.boolean().optional(),
+        ttl: z6.number().int().positive().optional(),
+        maxSize: z6.number().int().positive().optional()
       }).partial().optional(),
-      retry: z4.object({
-        maxRetries: z4.number().int().min(0).optional(),
-        initialDelay: z4.number().int().positive().optional(),
-        maxDelay: z4.number().int().positive().optional()
+      retry: z6.object({
+        maxRetries: z6.number().int().min(0).optional(),
+        initialDelay: z6.number().int().positive().optional(),
+        maxDelay: z6.number().int().positive().optional()
       }).partial().optional()
     }).partial().optional(),
-    memory: z4.object({
-      files: z4.record(z4.union([z4.string(), z4.instanceof(Uint8Array)])).optional()
+    memory: z6.object({
+      files: z6.record(z6.union([z6.string(), z6.instanceof(Uint8Array)])).optional()
+    }).partial().optional()
+  }).partial().optional(),
+  client: z6.object({
+    moduleResolution: z6.enum(["cdn", "self-hosted", "bundled"]).optional(),
+    cdn: z6.object({
+      provider: z6.enum(["esm.sh", "unpkg", "jsdelivr"]).optional(),
+      versions: z6.union([
+        z6.literal("auto"),
+        z6.object({
+          react: z6.string().optional(),
+          veryfront: z6.string().optional()
+        })
+      ]).optional()
     }).partial().optional()
   }).partial().optional()
 }).partial();
@@ -3428,7 +3546,8 @@ function findUnknownTopLevelKeys(input) {
     "theming",
     "assetPipeline",
     "observability",
-    "fs"
+    "fs",
+    "client"
   ]);
   return Object.keys(input).filter((k) => !known.has(k));
 }
@@ -3477,6 +3596,13 @@ var DEFAULT_CONFIG2 = {
   },
   resolve: {
     importMap: getDefaultImportMapForConfig()
+  },
+  client: {
+    moduleResolution: "cdn",
+    cdn: {
+      provider: "esm.sh",
+      versions: "auto"
+    }
   }
 };
 var configCacheByProject = /* @__PURE__ */ new Map();
@@ -3529,6 +3655,14 @@ function mergeConfigs(userConfig) {
     resolve: {
       ...DEFAULT_CONFIG2.resolve,
       ...userConfig.resolve
+    },
+    client: {
+      ...DEFAULT_CONFIG2.client,
+      ...userConfig.client,
+      cdn: {
+        ...DEFAULT_CONFIG2.client?.cdn,
+        ...userConfig.client?.cdn
+      }
     }
   };
   if (merged.resolve) {