veryfront 0.0.69 → 0.0.71

package/dist/ai/index.js

@@ -19,6 +19,11 @@ globalThis.Deno = globalThis.Deno || {
   }
 };
 
+// src/ai/types/agent.ts
+function getTextFromParts(parts) {
+  return parts.filter((p) => p.type === "text").map((p) => p.text).join("");
+}
+
 // src/ai/providers/openai.ts
 import { z as z2 } from "zod";
 
@@ -174,6 +179,7 @@ var OpenAIStreamChunkSchema = z.object({
   })).min(1)
 });
 var BaseProvider = class {
+  config;
   constructor(config) {
     this.config = config;
     this.validateConfig();
@@ -388,9 +394,12 @@ 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;
@@ -492,9 +501,11 @@ 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";
   }
@@ -792,9 +803,11 @@ 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";
   }
@@ -916,11 +929,9 @@ function getEnv(key) {
 
 // src/ai/providers/factory.ts
 var ProviderRegistry = class {
-  constructor() {
-    this.providers = /* @__PURE__ */ new Map();
-    this.config = {};
-    this.autoInitialized = false;
-  }
+  providers = /* @__PURE__ */ new Map();
+  config = {};
+  autoInitialized = false;
   /**
    * Auto-initialize providers from environment variables
    * This is called lazily when a provider is first requested
@@ -1259,6 +1270,7 @@ function tool(config) {
   }
   return {
     id,
+    type: "function",
     description: config.description,
     inputSchema: config.inputSchema,
     inputSchemaJson,
@@ -1288,14 +1300,62 @@ function tool(config) {
     mcp: config.mcp
   };
 }
+function dynamicTool(config) {
+  const id = config.id || generateToolId();
+  let inputSchemaJson;
+  const zodLikeSchema = config.inputSchema;
+  if (zodLikeSchema?._def?.typeName) {
+    try {
+      inputSchemaJson = zodToJsonSchema(config.inputSchema);
+      agentLogger.info(
+        `[DYNAMIC_TOOL] Converted schema for "${id}": ${Object.keys(inputSchemaJson.properties || {}).length} properties`
+      );
+    } catch {
+      inputSchemaJson = { type: "object", properties: {}, additionalProperties: true };
+      agentLogger.info(`[DYNAMIC_TOOL] Using permissive schema for "${id}"`);
+    }
+  } else if (zodLikeSchema?._def?.shape) {
+    try {
+      const shape = typeof zodLikeSchema._def.shape === "function" ? zodLikeSchema._def.shape() : zodLikeSchema._def.shape;
+      const properties = {};
+      for (const key of Object.keys(shape || {})) {
+        properties[key] = { type: "string" };
+      }
+      inputSchemaJson = {
+        type: "object",
+        properties,
+        additionalProperties: true
+      };
+      agentLogger.info(`[DYNAMIC_TOOL] Introspected schema for "${id}"`);
+    } catch {
+      inputSchemaJson = { type: "object", properties: {}, additionalProperties: true };
+    }
+  } else {
+    inputSchemaJson = { type: "object", properties: {}, additionalProperties: true };
+    agentLogger.info(`[DYNAMIC_TOOL] Using fully dynamic schema for "${id}"`);
+  }
+  return {
+    id,
+    type: "dynamic",
+    description: config.description,
+    inputSchema: config.inputSchema,
+    inputSchemaJson,
+    execute: async (input, context) => {
+      const result = await config.execute(input, context);
+      if (config.toModelOutput) {
+        return config.toModelOutput(result);
+      }
+      return result;
+    },
+    mcp: config.mcp
+  };
+}
 var toolIdCounter = 0;
 function generateToolId() {
   return `tool_${Date.now()}_${toolIdCounter++}`;
 }
 var ToolRegistryClass = class {
-  constructor() {
-    this.tools = /* @__PURE__ */ new Map();
-  }
+  tools = /* @__PURE__ */ new Map();
   register(id, toolInstance) {
     if (this.tools.has(id)) {
       agentLogger.debug(`Tool "${id}" is already registered. Overwriting.`);
@@ -1555,9 +1615,7 @@ function patternToId(pattern) {
   return pattern.replace(/^\//, "").replace(/\//g, "_").replace(/:/g, "");
 }
 var ResourceRegistryClass = class {
-  constructor() {
-    this.resources = /* @__PURE__ */ new Map();
-  }
+  resources = /* @__PURE__ */ new Map();
   /**
    * Register a resource
    */
@@ -1653,9 +1711,7 @@ function interpolateVariables(template, variables) {
   });
 }
 var PromptRegistryClass = class {
-  constructor() {
-    this.prompts = /* @__PURE__ */ new Map();
-  }
+  prompts = /* @__PURE__ */ new Map();
   /**
    * Register a prompt
    */
@@ -1733,6 +1789,7 @@ import { z as z4 } from "zod";
 function agentAsTool(agent2, description) {
   return {
     id: `agent_${agent2.id}`,
+    type: "function",
     description,
     inputSchema: z4.object({
       input: z4.string().describe("Input for the agent")
@@ -1785,9 +1842,7 @@ function createWorkflow(config) {
   };
 }
 var AgentRegistryClass = class {
-  constructor() {
-    this.agents = /* @__PURE__ */ new Map();
-  }
+  agents = /* @__PURE__ */ new Map();
   /**
    * Register an agent
    */
@@ -2040,7 +2095,7 @@ import { join } from "node:path";
 // deno.json
 var deno_default = {
   name: "veryfront",
-  version: "0.0.68",
+  version: "0.0.71",
   nodeModulesDir: "auto",
   exclude: [
     "npm/",
@@ -2709,12 +2764,10 @@ function createMockAdapter() {
 
 // src/platform/compat/fs.ts
 var NodeFileSystem = class {
-  constructor() {
-    this.fs = null;
-    this.os = null;
-    this.path = null;
-    this.initialized = false;
-  }
+  fs = null;
+  os = null;
+  path = null;
+  initialized = false;
   async ensureInitialized() {
     if (this.initialized)
       return;
@@ -3455,8 +3508,9 @@ function generateId(prefix) {
 
 // src/ai/agent/memory.ts
 var ConversationMemory = class {
+  messages = [];
+  config;
   constructor(config) {
-    this.messages = [];
     this.config = config;
   }
   async add(message) {
@@ -3494,15 +3548,17 @@ var ConversationMemory = class {
   }
   estimateTokens(messages) {
     const totalChars = messages.reduce(
-      (sum, msg) => sum + msg.content.length,
+      (sum, msg) => sum + getTextFromParts(msg.parts).length,
       0
     );
     return Math.ceil(totalChars / 4);
   }
 };
 var BufferMemory = class {
+  messages = [];
+  config;
+  bufferSize;
   constructor(config) {
-    this.messages = [];
     this.config = config;
     this.bufferSize = config.maxMessages || 10;
   }
@@ -3529,16 +3585,18 @@ var BufferMemory = class {
   }
   estimateTokens(messages) {
     const totalChars = messages.reduce(
-      (sum, msg) => sum + msg.content.length,
+      (sum, msg) => sum + getTextFromParts(msg.parts).length,
       0
     );
     return Math.ceil(totalChars / 4);
   }
 };
 var SummaryMemory = class {
+  messages = [];
+  summary = "";
+  config;
+  summaryThreshold;
   constructor(config) {
-    this.messages = [];
-    this.summary = "";
     this.config = config;
     this.summaryThreshold = config.maxMessages || 20;
   }
@@ -3554,8 +3612,8 @@ var SummaryMemory = class {
         {
           id: "summary",
           role: "system",
-          content: `Previous conversation summary:
-${this.summary}`,
+          parts: [{ type: "text", text: `Previous conversation summary:
+${this.summary}` }],
           timestamp: Date.now()
         },
         ...this.messages
@@ -3579,13 +3637,13 @@ ${this.summary}`,
   summarizeOldMessages() {
     const toSummarize = this.messages.slice(0, Math.floor(this.messages.length / 2));
     const remaining = this.messages.slice(Math.floor(this.messages.length / 2));
-    const topics = toSummarize.filter((m) => m.role === "user").map((m) => m.content.substring(0, 50)).join("; ");
+    const topics = toSummarize.filter((m) => m.role === "user").map((m) => getTextFromParts(m.parts).substring(0, 50)).join("; ");
     this.summary = `Discussed: ${topics}`;
     this.messages = remaining;
     return Promise.resolve();
   }
   estimateTokens(messages) {
-    const totalChars = messages.reduce((sum, msg) => sum + msg.content.length, 0) + this.summary.length;
+    const totalChars = messages.reduce((sum, msg) => sum + getTextFromParts(msg.parts).length, 0) + this.summary.length;
     return Math.ceil(totalChars / 4);
   }
 };
@@ -3647,11 +3705,9 @@ var VERYFRONT_PATHS = {
 
 // src/core/utils/bundle-manifest.ts
 var InMemoryBundleManifestStore = class {
-  constructor() {
-    this.metadata = /* @__PURE__ */ new Map();
-    this.code = /* @__PURE__ */ new Map();
-    this.sourceIndex = /* @__PURE__ */ new Map();
-  }
+  metadata = /* @__PURE__ */ new Map();
+  code = /* @__PURE__ */ new Map();
+  sourceIndex = /* @__PURE__ */ new Map();
   getBundleMetadata(key) {
     const entry = this.metadata.get(key);
     if (!entry)
@@ -3943,16 +3999,14 @@ var ContextPropagation = class {
 
 // src/observability/tracing/manager.ts
 var TracingManager = class {
-  constructor() {
-    this.state = {
-      initialized: false,
-      tracer: null,
-      api: null,
-      propagator: null
-    };
-    this.spanOps = null;
-    this.contextProp = null;
-  }
+  state = {
+    initialized: false,
+    tracer: null,
+    api: null,
+    propagator: null
+  };
+  spanOps = null;
+  contextProp = null;
   async initialize(config = {}, adapter) {
     if (this.state.initialized) {
       serverLogger.debug("[tracing] Already initialized");
@@ -4080,9 +4134,40 @@ var AgentStreamEventSchema = z6.discriminatedUnion("type", [
 ]);
 var DEFAULT_MAX_TOKENS = 4096;
 var DEFAULT_TEMPERATURE = 0.7;
+function convertMessageToProvider(msg) {
+  const content = getTextFromParts(msg.parts);
+  const providerMsg = {
+    role: msg.role,
+    content
+  };
+  const toolCallParts = msg.parts.filter(
+    (p) => p.type === "tool-call"
+  );
+  if (toolCallParts.length > 0) {
+    providerMsg.tool_calls = toolCallParts.map((tc) => ({
+      id: tc.toolCallId,
+      type: "function",
+      function: {
+        name: tc.toolName,
+        arguments: JSON.stringify(tc.args)
+      }
+    }));
+  }
+  const toolResultPart = msg.parts.find(
+    (p) => p.type === "tool-result"
+  );
+  if (toolResultPart && msg.role === "tool") {
+    providerMsg.tool_call_id = toolResultPart.toolCallId;
+    providerMsg.content = JSON.stringify(toolResultPart.result);
+  }
+  return providerMsg;
+}
 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 };
@@ -4150,7 +4235,8 @@ var AgentRuntime = class {
       start: async (controller) => {
         try {
           this.status = "streaming";
-          const startEvent = JSON.stringify({ type: "start" });
+          const messageId = `msg-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+          const startEvent = JSON.stringify({ type: "start", messageId });
           controller.enqueue(encoder.encode(`data: ${startEvent}
 
 `));
@@ -4224,26 +4310,7 @@ var AgentRuntime = class {
           return await provider.complete({
             model,
             system: systemPrompt,
-            messages: currentMessages.map((m) => {
-              const msg = {
-                role: m.role,
-                content: m.content
-              };
-              if (m.role === "assistant" && m.toolCalls) {
-                msg.tool_calls = m.toolCalls.map((tc) => ({
-                  id: tc.id,
-                  type: "function",
-                  function: {
-                    name: tc.name,
-                    arguments: JSON.stringify(tc.arguments)
-                  }
-                }));
-              }
-              if (m.role === "tool" && m.toolCallId) {
-                msg.tool_call_id = m.toolCallId;
-              }
-              return msg;
-            }),
+            messages: currentMessages.map((m) => convertMessageToProvider(m)),
             tools: tools.length > 0 ? tools : void 0,
             maxTokens: this.config.memory?.maxTokens || DEFAULT_MAX_TOKENS,
             temperature: DEFAULT_TEMPERATURE
@@ -4252,11 +4319,24 @@ var AgentRuntime = class {
         totalUsage.promptTokens += response.usage.promptTokens;
         totalUsage.completionTokens += response.usage.completionTokens;
         totalUsage.totalTokens += response.usage.totalTokens;
+        const assistantParts = [];
+        if (response.text) {
+          assistantParts.push({ type: "text", text: response.text });
+        }
+        if (response.toolCalls) {
+          for (const tc of response.toolCalls) {
+            assistantParts.push({
+              type: "tool-call",
+              toolCallId: tc.id,
+              toolName: tc.name,
+              args: tc.arguments
+            });
+          }
+        }
         const assistantMessage = {
           id: `msg_${Date.now()}_${step2}`,
           role: "assistant",
-          content: response.text,
-          toolCalls: response.toolCalls,
+          parts: assistantParts,
           timestamp: Date.now()
         };
         currentMessages.push(assistantMessage);
@@ -4290,9 +4370,12 @@ var AgentRuntime = class {
                 const toolResultMessage = {
                   id: `tool_${tc.id}`,
                   role: "tool",
-                  content: JSON.stringify(result),
-                  toolCallId: tc.id,
-                  toolCall,
+                  parts: [{
+                    type: "tool-result",
+                    toolCallId: tc.id,
+                    toolName: tc.name,
+                    result
+                  }],
                   timestamp: Date.now()
                 };
                 currentMessages.push(toolResultMessage);
@@ -4304,9 +4387,12 @@ var AgentRuntime = class {
                 const errorMessage = {
                   id: `tool_error_${tc.id}`,
                   role: "tool",
-                  content: `Error: ${toolCall.error}`,
-                  toolCallId: tc.id,
-                  toolCall,
+                  parts: [{
+                    type: "tool-result",
+                    toolCallId: tc.id,
+                    toolName: tc.name,
+                    result: { error: toolCall.error }
+                  }],
                   timestamp: Date.now()
                 };
                 currentMessages.push(errorMessage);
@@ -4329,8 +4415,9 @@ var AgentRuntime = class {
       }
       this.status = "completed";
       addSpanEvent(loopSpan, "max_steps_reached", { maxSteps });
+      const lastMsg = currentMessages[currentMessages.length - 1];
       return {
-        text: currentMessages[currentMessages.length - 1]?.content || "",
+        text: lastMsg ? getTextFromParts(lastMsg.parts) : "",
         messages: currentMessages,
         toolCalls,
         status: this.status,
@@ -4356,23 +4443,15 @@ var AgentRuntime = class {
       totalTokens: 0
     };
     for (let step2 = 0; step2 < maxSteps; step2++) {
+      const startStepEvent = JSON.stringify({ type: "start-step" });
+      controller.enqueue(encoder.encode(`data: ${startStepEvent}
+
+`));
       const tools = this.getAvailableTools();
       const stream = await provider.stream({
         model,
         system: systemPrompt,
-        messages: currentMessages.map((m) => ({
-          role: m.role,
-          content: m.content,
-          tool_calls: m.toolCalls?.map((tc) => ({
-            id: tc.id,
-            type: "function",
-            function: {
-              name: tc.name,
-              arguments: JSON.stringify(tc.arguments)
-            }
-          })),
-          tool_call_id: m.toolCallId
-        })),
+        messages: currentMessages.map((m) => convertMessageToProvider(m)),
         tools: tools.length > 0 ? tools : void 0,
         maxTokens: this.config.memory?.maxTokens || DEFAULT_MAX_TOKENS,
         temperature: DEFAULT_TEMPERATURE
@@ -4400,9 +4479,13 @@ var AgentRuntime = class {
         toolCall.status = "error";
         toolCall.error = errorStr;
         toolCalls.push(toolCall);
+        const errorTool = toolRegistry.get(toolCall.name);
+        const errorIsDynamic = errorTool?.type === "dynamic";
         const errorData = JSON.stringify({
-          type: "error",
-          error: errorStr
+          type: "tool-output-error",
+          toolCallId: toolCall.id,
+          errorText: errorStr,
+          ...errorIsDynamic && { dynamic: true }
         });
         controller.enqueue(encoder.encode(`data: ${errorData}
 
@@ -4410,9 +4493,12 @@ var AgentRuntime = class {
         const errorMessage = {
           id: `tool_error_${toolCall.id}`,
           role: "tool",
-          content: `Error: ${errorStr}`,
-          toolCallId: toolCall.id,
-          toolCall,
+          parts: [{
+            type: "tool-result",
+            toolCallId: toolCall.id,
+            toolName: toolCall.name,
+            result: { error: errorStr }
+          }],
           timestamp: Date.now()
         };
         currentMessages.push(errorMessage);
@@ -4442,10 +4528,13 @@ var AgentRuntime = class {
                 name: event.toolCall.name,
                 arguments: ""
               });
+              const startTool = toolRegistry.get(event.toolCall.name);
+              const startIsDynamic = startTool?.type === "dynamic";
               const toolStartEvent = JSON.stringify({
-                type: "tool-call-streaming-start",
+                type: "tool-input-start",
                 toolCallId: event.toolCall.id,
-                toolName: event.toolCall.name
+                toolName: event.toolCall.name,
+                ...startIsDynamic && { dynamic: true }
               });
               controller.enqueue(encoder.encode(`data: ${toolStartEvent}
 
@@ -4457,9 +4546,9 @@ var AgentRuntime = class {
               const tc = streamToolCalls.get(event.id);
               tc.arguments += event.arguments;
               const toolDeltaEvent = JSON.stringify({
-                type: "tool-call-delta",
+                type: "tool-input-delta",
                 toolCallId: event.id,
-                argsTextDelta: event.arguments
+                inputTextDelta: event.arguments
               });
               controller.enqueue(encoder.encode(`data: ${toolDeltaEvent}
 
@@ -4473,12 +4562,15 @@ var AgentRuntime = class {
                 name: event.toolCall.name,
                 arguments: event.toolCall.arguments
               });
+              const completeTool = toolRegistry.get(event.toolCall.name);
+              const completeIsDynamic = completeTool?.type === "dynamic";
               const { args } = parseStreamToolArgs(event.toolCall.arguments);
               const toolCallEvent = JSON.stringify({
-                type: "tool-call",
+                type: "tool-input-available",
                 toolCallId: event.toolCall.id,
                 toolName: event.toolCall.name,
-                args
+                input: args,
+                ...completeIsDynamic && { dynamic: true }
               });
               controller.enqueue(encoder.encode(`data: ${toolCallEvent}
 
@@ -4531,30 +4623,33 @@ var AgentRuntime = class {
         } catch {
         }
       }
+      const streamParts = [];
+      if (accumulatedText) {
+        streamParts.push({ type: "text", text: accumulatedText });
+      }
+      if (streamToolCalls.size > 0) {
+        for (const tc of streamToolCalls.values()) {
+          const { args, error } = parseStreamToolArgs(tc.arguments);
+          if (error) {
+            serverLogger.warn("[AGENT] Failed to parse streamed tool arguments", {
+              toolCallId: tc.id,
+              error
+            });
+          }
+          streamParts.push({
+            type: "tool-call",
+            toolCallId: tc.id,
+            toolName: tc.name,
+            args
+          });
+        }
+      }
       const assistantMessage = {
         id: `msg_${Date.now()}_${step2}`,
         role: "assistant",
-        content: accumulatedText,
+        parts: streamParts,
         timestamp: Date.now()
       };
-      if (streamToolCalls.size > 0) {
-        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) {
@@ -4572,6 +4667,17 @@ var AgentRuntime = class {
               toolCallId: tc.id,
               error: argError
             });
+            const inputErrorTool = toolRegistry.get(tc.name);
+            const inputErrorIsDynamic = inputErrorTool?.type === "dynamic";
+            const inputErrorEvent = JSON.stringify({
+              type: "tool-input-error",
+              toolCallId: tc.id,
+              errorText: `Invalid tool arguments: ${argError}`,
+              ...inputErrorIsDynamic && { dynamic: true }
+            });
+            controller.enqueue(encoder.encode(`data: ${inputErrorEvent}
+
+`));
             await recordToolError(toolCall, `Invalid tool arguments: ${argError}`);
             continue;
           }
@@ -4581,15 +4687,6 @@ var AgentRuntime = class {
             if (callbacks?.onToolCall) {
               callbacks.onToolCall(toolCall);
             }
-            const toolCallEvent = JSON.stringify({
-              type: "tool-call",
-              toolCallId: toolCall.id,
-              toolName: toolCall.name,
-              args: toolCall.args
-            });
-            controller.enqueue(encoder.encode(`data: ${toolCallEvent}
-
-`));
             const result = await executeTool(tc.name, toolCall.args, {
               agentId: this.id,
               ...toolContext
@@ -4598,10 +4695,13 @@ var AgentRuntime = class {
             toolCall.result = result;
             toolCall.executionTime = Date.now() - startTime;
             toolCalls.push(toolCall);
+            const outputTool = toolRegistry.get(tc.name);
+            const outputIsDynamic = outputTool?.type === "dynamic";
             const toolResultEvent = JSON.stringify({
-              type: "tool-result",
+              type: "tool-output-available",
               toolCallId: toolCall.id,
-              result
+              output: result,
+              ...outputIsDynamic && { dynamic: true }
             });
             controller.enqueue(encoder.encode(`data: ${toolResultEvent}
 
@@ -4609,9 +4709,12 @@ var AgentRuntime = class {
             const toolResultMessage = {
               id: `tool_${tc.id}`,
               role: "tool",
-              content: JSON.stringify(result),
-              toolCallId: tc.id,
-              toolCall,
+              parts: [{
+                type: "tool-result",
+                toolCallId: tc.id,
+                toolName: tc.name,
+                result
+              }],
               timestamp: Date.now()
             };
             currentMessages.push(toolResultMessage);
@@ -4621,13 +4724,22 @@ var AgentRuntime = class {
             await recordToolError(toolCall, errorStr);
           }
         }
+        const finishStepToolsEvent = JSON.stringify({ type: "finish-step" });
+        controller.enqueue(encoder.encode(`data: ${finishStepToolsEvent}
+
+`));
         this.status = "thinking";
         continue;
       }
+      const finishStepEvent = JSON.stringify({ type: "finish-step" });
+      controller.enqueue(encoder.encode(`data: ${finishStepEvent}
+
+`));
       break;
     }
+    const lastMessage = currentMessages[currentMessages.length - 1];
     return {
-      text: currentMessages[currentMessages.length - 1]?.content || "",
+      text: lastMessage ? getTextFromParts(lastMessage.parts) : "",
       messages: currentMessages,
       toolCalls,
       status: "completed",
@@ -4703,7 +4815,7 @@ var AgentRuntime = class {
     return "You are a helpful AI assistant.";
   }
   /**
-   * Normalize input to messages array
+   * Normalize input to messages array (v5 format with parts)
    */
   normalizeInput(input) {
     if (typeof input === "string") {
@@ -4711,7 +4823,7 @@ var AgentRuntime = class {
         {
           id: `msg_${Date.now()}`,
           role: "user",
-          content: input,
+          parts: [{ type: "text", text: input }],
           timestamp: Date.now()
         }
       ];
@@ -4812,7 +4924,11 @@ ${compatibility.warnings.join("\n")}`
       return runtime.generate(input.input, input.context);
     },
     async stream(input) {
-      const inputMessages = input.input ? [{ role: "user", content: input.input }] : input.messages || [];
+      const inputMessages = input.input ? [{
+        id: `msg_${Date.now()}`,
+        role: "user",
+        parts: [{ type: "text", text: input.input }]
+      }] : input.messages || [];
       const stream = await runtime.stream(inputMessages, input.context, {
         onToolCall: input.onToolCall,
         onChunk: input.onChunk
@@ -5035,6 +5151,7 @@ async function setupAI(options = {}) {
 
 // src/ai/mcp/server.ts
 var MCPServer = class {
+  config;
   constructor(config) {
     this.config = config;
   }
@@ -5346,8 +5463,9 @@ 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) {
@@ -5388,8 +5506,10 @@ 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;
   }
@@ -5492,9 +5612,7 @@ function rateLimitMiddleware(config) {
 
 // src/ai/production/cache/cache.ts
 var MemoryCache = class {
-  constructor() {
-    this.cache = /* @__PURE__ */ new Map();
-  }
+  cache = /* @__PURE__ */ new Map();
   set(key, response) {
     this.cache.set(key, {
       response,
@@ -5525,8 +5643,9 @@ 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) {
@@ -5570,9 +5689,10 @@ 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();
   }
@@ -5726,13 +5846,14 @@ 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();
   }
@@ -5995,6 +6116,7 @@ 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 || {};
   }
@@ -6054,6 +6176,7 @@ var InputValidator = class {
   }
 };
 var OutputFilter = class {
+  config;
   constructor(config) {
     this.config = config || {};
   }
@@ -6327,12 +6450,13 @@ 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,
@@ -6663,6 +6787,7 @@ var MemoryBackend = class {
 
 // src/ai/workflow/executor/dag-executor.ts
 var DAGExecutor = class {
+  config;
   constructor(config) {
     this.config = {
       maxConcurrency: 10,
@@ -7204,6 +7329,7 @@ var DAGExecutor = class {
 
 // src/ai/workflow/executor/checkpoint-manager.ts
 var CheckpointManager = class {
+  config;
   constructor(config) {
     this.config = {
       debug: false,
@@ -7361,6 +7487,7 @@ var CheckpointManager = class {
 // src/ai/workflow/executor/step-executor.ts
 var DEFAULT_STEP_TIMEOUT_MS = 5 * 60 * 1e3;
 var StepExecutor = class {
+  config;
   constructor(config = {}) {
     this.config = {
       defaultTimeout: DEFAULT_STEP_TIMEOUT_MS,
@@ -7582,8 +7709,15 @@ 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,
@@ -7619,10 +7753,6 @@ var WorkflowExecutor = class _WorkflowExecutor {
       };
     }
   }
-  static {
-    /** Default lock duration: 30 seconds */
-    this.DEFAULT_LOCK_DURATION = 3e4;
-  }
   /**
    * Register a workflow definition
    */
@@ -7977,8 +8107,10 @@ 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
@@ -8205,6 +8337,10 @@ 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 });
@@ -8413,6 +8549,7 @@ export {
   createWorkflowClient,
   detectPlatform,
   discoverAll,
+  dynamicTool,
   embed,
   embedMany,
   experimental_createMCPClient,