@voltagent/core 0.1.21 → 0.1.23

package/dist/index.js

@@ -776,77 +776,76 @@ var updateSinglePackage = /* @__PURE__ */ __name((packageName, packagePath) => _
 }), "updateSinglePackage");
 
 // src/server/api.routes.ts
-var import_zod = require("zod");
 var import_zod_openapi = require("@hono/zod-openapi");
-var ParamsSchema = import_zod.z.object({
-  id: import_zod.z.string().openapi({
+var ParamsSchema = import_zod_openapi.z.object({
+  id: import_zod_openapi.z.string().openapi({
     param: { name: "id", in: "path" },
     description: "The ID of the agent",
     example: "my-agent-123"
   })
 });
-var ErrorSchema = import_zod.z.object({
-  success: import_zod.z.literal(false),
-  error: import_zod.z.string().openapi({ description: "Error message" })
+var ErrorSchema = import_zod_openapi.z.object({
+  success: import_zod_openapi.z.literal(false),
+  error: import_zod_openapi.z.string().openapi({ description: "Error message" })
 });
-var SubAgentResponseSchema = import_zod.z.object({
-  id: import_zod.z.string(),
-  name: import_zod.z.string(),
-  description: import_zod.z.string(),
-  status: import_zod.z.string().openapi({ description: "Current status of the sub-agent" }),
+var SubAgentResponseSchema = import_zod_openapi.z.object({
+  id: import_zod_openapi.z.string(),
+  name: import_zod_openapi.z.string(),
+  description: import_zod_openapi.z.string(),
+  status: import_zod_openapi.z.string().openapi({ description: "Current status of the sub-agent" }),
   // Keeping string for now
-  model: import_zod.z.string(),
-  tools: import_zod.z.array(import_zod.z.any()).optional(),
-  memory: import_zod.z.any().optional()
+  model: import_zod_openapi.z.string(),
+  tools: import_zod_openapi.z.array(import_zod_openapi.z.any()).optional(),
+  memory: import_zod_openapi.z.any().optional()
 }).passthrough();
-var AgentResponseSchema = import_zod.z.object({
-  id: import_zod.z.string(),
-  name: import_zod.z.string(),
-  description: import_zod.z.string(),
-  status: import_zod.z.string().openapi({ description: "Current status of the agent" }),
+var AgentResponseSchema = import_zod_openapi.z.object({
+  id: import_zod_openapi.z.string(),
+  name: import_zod_openapi.z.string(),
+  description: import_zod_openapi.z.string(),
+  status: import_zod_openapi.z.string().openapi({ description: "Current status of the agent" }),
   // Reverted to z.string()
-  model: import_zod.z.string(),
-  tools: import_zod.z.array(import_zod.z.any()),
+  model: import_zod_openapi.z.string(),
+  tools: import_zod_openapi.z.array(import_zod_openapi.z.any()),
   // Simplified tool representation
-  subAgents: import_zod.z.array(SubAgentResponseSchema).optional().openapi({ description: "List of sub-agents" }),
+  subAgents: import_zod_openapi.z.array(SubAgentResponseSchema).optional().openapi({ description: "List of sub-agents" }),
   // Use SubAgent schema
-  memory: import_zod.z.any().optional(),
+  memory: import_zod_openapi.z.any().optional(),
   // Simplified memory representation
-  isTelemetryEnabled: import_zod.z.boolean().openapi({ description: "Indicates if telemetry is configured for the agent" })
+  isTelemetryEnabled: import_zod_openapi.z.boolean().openapi({ description: "Indicates if telemetry is configured for the agent" })
   // Add other fields from getFullState if necessary and want them documented
 }).passthrough();
-var GenerateOptionsSchema = import_zod.z.object({
-  userId: import_zod.z.string().optional().openapi({ description: "Optional user ID for context tracking" }),
-  conversationId: import_zod.z.string().optional().openapi({
+var GenerateOptionsSchema = import_zod_openapi.z.object({
+  userId: import_zod_openapi.z.string().optional().openapi({ description: "Optional user ID for context tracking" }),
+  conversationId: import_zod_openapi.z.string().optional().openapi({
     description: "Optional conversation ID for context tracking"
   }),
-  contextLimit: import_zod.z.number().int().positive().optional().default(10).openapi({
+  contextLimit: import_zod_openapi.z.number().int().positive().optional().default(10).openapi({
     description: "Optional limit for conversation history context"
   }),
-  temperature: import_zod.z.number().min(0).max(1).optional().default(0.7).openapi({ description: "Controls randomness (0-1)" }),
-  maxTokens: import_zod.z.number().int().positive().optional().default(4e3).openapi({ description: "Maximum tokens to generate" }),
-  topP: import_zod.z.number().min(0).max(1).optional().default(1).openapi({
+  temperature: import_zod_openapi.z.number().min(0).max(1).optional().default(0.7).openapi({ description: "Controls randomness (0-1)" }),
+  maxTokens: import_zod_openapi.z.number().int().positive().optional().default(4e3).openapi({ description: "Maximum tokens to generate" }),
+  topP: import_zod_openapi.z.number().min(0).max(1).optional().default(1).openapi({
     description: "Controls diversity via nucleus sampling (0-1)"
   }),
-  frequencyPenalty: import_zod.z.number().min(0).max(2).optional().default(0).openapi({ description: "Penalizes repeated tokens (0-2)" }),
-  presencePenalty: import_zod.z.number().min(0).max(2).optional().default(0).openapi({ description: "Penalizes tokens based on presence (0-2)" }),
-  seed: import_zod.z.number().int().optional().openapi({ description: "Optional seed for reproducible results" }),
-  stopSequences: import_zod.z.array(import_zod.z.string()).optional().openapi({ description: "Stop sequences to end generation" }),
-  extraOptions: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional().openapi({ description: "Provider-specific options" })
+  frequencyPenalty: import_zod_openapi.z.number().min(0).max(2).optional().default(0).openapi({ description: "Penalizes repeated tokens (0-2)" }),
+  presencePenalty: import_zod_openapi.z.number().min(0).max(2).optional().default(0).openapi({ description: "Penalizes tokens based on presence (0-2)" }),
+  seed: import_zod_openapi.z.number().int().optional().openapi({ description: "Optional seed for reproducible results" }),
+  stopSequences: import_zod_openapi.z.array(import_zod_openapi.z.string()).optional().openapi({ description: "Stop sequences to end generation" }),
+  extraOptions: import_zod_openapi.z.record(import_zod_openapi.z.string(), import_zod_openapi.z.unknown()).optional().openapi({ description: "Provider-specific options" })
   // Add other relevant options from PublicGenerateOptions if known/needed for API exposure
 }).passthrough();
-var ContentPartSchema = import_zod.z.union([
-  import_zod.z.object({
+var ContentPartSchema = import_zod_openapi.z.union([
+  import_zod_openapi.z.object({
     // Text part
-    type: import_zod.z.literal("text"),
-    text: import_zod.z.string()
+    type: import_zod_openapi.z.literal("text"),
+    text: import_zod_openapi.z.string()
   }).openapi({ example: { type: "text", text: "Hello there!" } }),
-  import_zod.z.object({
+  import_zod_openapi.z.object({
     // Image part
-    type: import_zod.z.literal("image"),
-    image: import_zod.z.string().openapi({ description: "Base64 encoded image data or a URL" }),
-    mimeType: import_zod.z.string().optional().openapi({ example: "image/jpeg" }),
-    alt: import_zod.z.string().optional().openapi({ description: "Alternative text for the image" })
+    type: import_zod_openapi.z.literal("image"),
+    image: import_zod_openapi.z.string().openapi({ description: "Base64 encoded image data or a URL" }),
+    mimeType: import_zod_openapi.z.string().optional().openapi({ example: "image/jpeg" }),
+    alt: import_zod_openapi.z.string().optional().openapi({ description: "Alternative text for the image" })
   }).openapi({
     example: {
       type: "image",
@@ -854,13 +853,13 @@ var ContentPartSchema = import_zod.z.union([
       mimeType: "image/png"
     }
   }),
-  import_zod.z.object({
+  import_zod_openapi.z.object({
     // File part
-    type: import_zod.z.literal("file"),
-    data: import_zod.z.string().openapi({ description: "Base64 encoded file data" }),
-    filename: import_zod.z.string().openapi({ example: "document.pdf" }),
-    mimeType: import_zod.z.string().openapi({ example: "application/pdf" }),
-    size: import_zod.z.number().optional().openapi({ description: "File size in bytes" })
+    type: import_zod_openapi.z.literal("file"),
+    data: import_zod_openapi.z.string().openapi({ description: "Base64 encoded file data" }),
+    filename: import_zod_openapi.z.string().openapi({ example: "document.pdf" }),
+    mimeType: import_zod_openapi.z.string().openapi({ example: "application/pdf" }),
+    size: import_zod_openapi.z.number().optional().openapi({ description: "File size in bytes" })
   }).openapi({
     example: {
       type: "file",
@@ -870,24 +869,24 @@ var ContentPartSchema = import_zod.z.union([
     }
   })
 ]);
-var MessageContentSchema = import_zod.z.union([
-  import_zod.z.string().openapi({ description: "Plain text content" }),
-  import_zod.z.array(ContentPartSchema).openapi({ description: "An array of content parts (text, image, file)." })
+var MessageContentSchema = import_zod_openapi.z.union([
+  import_zod_openapi.z.string().openapi({ description: "Plain text content" }),
+  import_zod_openapi.z.array(ContentPartSchema).openapi({ description: "An array of content parts (text, image, file)." })
 ]);
-var MessageObjectSchema = import_zod.z.object({
-  role: import_zod.z.enum(["system", "user", "assistant", "tool"]).openapi({
+var MessageObjectSchema = import_zod_openapi.z.object({
+  role: import_zod_openapi.z.enum(["system", "user", "assistant", "tool"]).openapi({
     description: "Role of the sender (e.g., 'user', 'assistant')"
   }),
   content: MessageContentSchema
   // Use the reusable content schema
 }).openapi({ description: "A message object with role and content" });
-var TextRequestSchema = import_zod.z.object({
-  input: import_zod.z.union([
-    import_zod.z.string().openapi({
+var TextRequestSchema = import_zod_openapi.z.object({
+  input: import_zod_openapi.z.union([
+    import_zod_openapi.z.string().openapi({
       description: "Input text for the agent",
       example: "Tell me a joke!"
     }),
-    import_zod.z.array(MessageObjectSchema).openapi({
+    import_zod_openapi.z.array(MessageObjectSchema).openapi({
       description: "An array of message objects, representing the conversation history",
       example: [
         { role: "user", content: "What is the weather?" },
@@ -907,37 +906,56 @@ var TextRequestSchema = import_zod.z.object({
     }
   })
 }).openapi("TextGenerationRequest");
-var TextResponseSchema = import_zod.z.object({
-  success: import_zod.z.literal(true),
-  data: import_zod.z.string().openapi({ description: "Generated text response" })
+var TextResponseSchema = import_zod_openapi.z.object({
+  success: import_zod_openapi.z.literal(true),
+  data: import_zod_openapi.z.string().openapi({ description: "Generated text response" })
   // Assuming simple text response for now
 });
-var StreamTextEventSchema = import_zod.z.object({
-  text: import_zod.z.string().optional(),
-  timestamp: import_zod.z.string().datetime().optional(),
-  type: import_zod.z.enum(["text", "completion", "error"]).optional(),
-  done: import_zod.z.boolean().optional(),
-  error: import_zod.z.string().optional()
+var StreamTextEventSchema = import_zod_openapi.z.object({
+  text: import_zod_openapi.z.string().optional(),
+  timestamp: import_zod_openapi.z.string().datetime().optional(),
+  type: import_zod_openapi.z.enum(["text", "completion", "error"]).optional(),
+  done: import_zod_openapi.z.boolean().optional(),
+  error: import_zod_openapi.z.string().optional()
 });
-var ObjectRequestSchema = import_zod.z.object({
-  input: import_zod.z.union([
-    import_zod.z.string().openapi({ description: "Input text prompt" }),
-    import_zod.z.array(MessageObjectSchema).openapi({ description: "Conversation history" })
-  ]),
-  schema: import_zod.z.any().openapi({
-    description: "The Zod schema for the desired object output (passed as JSON)"
+var BasicJsonSchema = import_zod_openapi.z.object({
+  type: import_zod_openapi.z.literal("object"),
+  properties: import_zod_openapi.z.record(
+    import_zod_openapi.z.object({
+      type: import_zod_openapi.z.enum(["string", "number", "boolean", "object", "array", "null", "any"])
+    })
+  ).optional().openapi({
+    description: "A dictionary defining each property of the object and its type",
+    example: {
+      id: { type: "string" },
+      age: { type: "number" },
+      isActive: { type: "boolean" }
+    }
   }),
+  required: import_zod_openapi.z.array(import_zod_openapi.z.string()).optional().openapi({
+    description: "List of required property names in the object",
+    example: ["id", "age"]
+  })
+}).passthrough().openapi({
+  description: "The Zod schema for the desired object output (passed as JSON)"
+});
+var ObjectRequestSchema = import_zod_openapi.z.object({
+  input: import_zod_openapi.z.union([
+    import_zod_openapi.z.string().openapi({ description: "Input text prompt" }),
+    import_zod_openapi.z.array(MessageObjectSchema).openapi({ description: "Conversation history" })
+  ]),
+  schema: BasicJsonSchema,
   options: GenerateOptionsSchema.optional().openapi({
     description: "Optional object generation parameters",
     example: { temperature: 0.2 }
   })
 }).openapi("ObjectGenerationRequest");
-var ObjectResponseSchema = import_zod.z.object({
-  success: import_zod.z.literal(true),
-  data: import_zod.z.object({}).passthrough().openapi({ description: "Generated object response" })
+var ObjectResponseSchema = import_zod_openapi.z.object({
+  success: import_zod_openapi.z.literal(true),
+  data: import_zod_openapi.z.object({}).passthrough().openapi({ description: "Generated object response" })
   // Using passthrough object
 });
-var StreamObjectEventSchema = import_zod.z.any().openapi({
+var StreamObjectEventSchema = import_zod_openapi.z.any().openapi({
   description: "Streamed object parts or the final object, format depends on agent implementation."
 });
 var getAgentsRoute = (0, import_zod_openapi.createRoute)({
@@ -947,9 +965,9 @@ var getAgentsRoute = (0, import_zod_openapi.createRoute)({
     200: {
       content: {
         "application/json": {
-          schema: import_zod.z.object({
-            success: import_zod.z.literal(true),
-            data: import_zod.z.array(AgentResponseSchema).openapi({ description: "List of registered agents" })
+          schema: import_zod_openapi.z.object({
+            success: import_zod_openapi.z.literal(true),
+            data: import_zod_openapi.z.array(AgentResponseSchema).openapi({ description: "List of registered agents" })
           })
         }
       },
@@ -1159,6 +1177,7 @@ Example event: 'data: {"partialUpdate": {...}}
 });
 
 // src/server/api.ts
+var import_json_schema_to_zod = require("@n8n/json-schema-to-zod");
 var app = new import_zod_openapi2.OpenAPIHono();
 app.get("/", (c) => {
   const html = `
@@ -1501,7 +1520,8 @@ app.openapi(objectRoute, (c) => __async(void 0, null, function* () {
       schema,
       options = {}
     } = c.req.valid("json");
-    const response = yield agent.generateObject(input, schema, options);
+    const schemaInZodObject = (0, import_json_schema_to_zod.jsonSchemaToZod)(schema);
+    const response = yield agent.generateObject(input, schemaInZodObject, options);
     return c.json(
       { success: true, data: response },
       200
@@ -1533,12 +1553,12 @@ app.openapi(streamObjectRoute, (c) => __async(void 0, null, function* () {
       schema,
       options = {}
     } = c.req.valid("json");
-    const agentStream = yield agent.streamObject(input, schema, options);
+    const schemaInZodObject = (0, import_json_schema_to_zod.jsonSchemaToZod)(schema);
+    const agentStream = yield agent.streamObject(input, schemaInZodObject, options);
     const sseStream = new ReadableStream({
       start(controller) {
         return __async(this, null, function* () {
-          const reader = agentStream.getReader();
-          const decoder = new TextDecoder();
+          const reader = agentStream.objectStream.getReader();
           try {
             while (true) {
               const { done, value } = yield reader.read();
@@ -1553,8 +1573,7 @@ app.openapi(streamObjectRoute, (c) => __async(void 0, null, function* () {
 `);
                 break;
               }
-              const chunkString = decoder.decode(value, { stream: true });
-              controller.enqueue(`data: ${chunkString}
+              controller.enqueue(`data: ${JSON.stringify(value)}
 
 `);
             }
@@ -4881,7 +4900,7 @@ function createHooks(hooks = {}) {
 __name(createHooks, "createHooks");
 
 // src/agent/subagent/index.ts
-var import_zod2 = require("zod");
+var import_zod = require("zod");
 var SubAgentManager = class {
   /**
    * Creates a new SubAgentManager instance
@@ -5108,10 +5127,10 @@ Context: ${JSON.stringify(context)}`
       id: "delegate_task",
       name: "delegate_task",
       description: "Delegate a task to one or more specialized agents",
-      parameters: import_zod2.z.object({
-        task: import_zod2.z.string().describe("The task to delegate"),
-        targetAgents: import_zod2.z.array(import_zod2.z.string()).describe("List of agent names to delegate the task to"),
-        context: import_zod2.z.record(import_zod2.z.unknown()).optional().describe("Additional context for the task")
+      parameters: import_zod.z.object({
+        task: import_zod.z.string().describe("The task to delegate"),
+        targetAgents: import_zod.z.array(import_zod.z.string()).describe("List of agent names to delegate the task to"),
+        context: import_zod.z.record(import_zod.z.unknown()).optional().describe("Additional context for the task")
       }),
       execute: (_0) => __async(this, [_0], function* ({ task, targetAgents, context = {} }) {
         try {
@@ -7121,48 +7140,48 @@ ${context}`;
 __name(Agent, "Agent");
 
 // src/tool/reasoning/tools.ts
-var import_zod4 = require("zod");
+var import_zod3 = require("zod");
 var import_uuid4 = require("uuid");
 
 // src/tool/reasoning/types.ts
-var import_zod3 = require("zod");
+var import_zod2 = require("zod");
 var NextAction = /* @__PURE__ */ ((NextAction2) => {
   NextAction2["CONTINUE"] = "continue";
   NextAction2["VALIDATE"] = "validate";
   NextAction2["FINAL_ANSWER"] = "final_answer";
   return NextAction2;
 })(NextAction || {});
-var ReasoningStepSchema = import_zod3.z.object({
-  id: import_zod3.z.string().uuid(),
+var ReasoningStepSchema = import_zod2.z.object({
+  id: import_zod2.z.string().uuid(),
   // Unique ID for the step
-  type: import_zod3.z.enum(["thought", "analysis"]),
+  type: import_zod2.z.enum(["thought", "analysis"]),
   // Type of step
-  title: import_zod3.z.string(),
+  title: import_zod2.z.string(),
   // Concise title for the step
-  reasoning: import_zod3.z.string(),
+  reasoning: import_zod2.z.string(),
   // The detailed thought or analysis
-  action: import_zod3.z.string().optional(),
+  action: import_zod2.z.string().optional(),
   // The action planned based on the thought (for 'thought' type)
-  result: import_zod3.z.string().optional(),
+  result: import_zod2.z.string().optional(),
   // The result being analyzed (for 'analysis' type)
-  next_action: import_zod3.z.nativeEnum(NextAction).optional(),
+  next_action: import_zod2.z.nativeEnum(NextAction).optional(),
   // What to do next (for 'analysis' type)
-  confidence: import_zod3.z.number().min(0).max(1).optional().default(0.8),
+  confidence: import_zod2.z.number().min(0).max(1).optional().default(0.8),
   // Confidence level
-  timestamp: import_zod3.z.string().datetime(),
+  timestamp: import_zod2.z.string().datetime(),
   // Timestamp of the step creation
-  historyEntryId: import_zod3.z.string(),
+  historyEntryId: import_zod2.z.string(),
   // Link to the main history entry
-  agentId: import_zod3.z.string()
+  agentId: import_zod2.z.string()
   // ID of the agent performing the step
 });
 
 // src/tool/reasoning/tools.ts
-var thinkParametersSchema = import_zod4.z.object({
-  title: import_zod4.z.string().describe("A concise title for this thinking step"),
-  thought: import_zod4.z.string().describe("Your detailed thought or reasoning for this step"),
-  action: import_zod4.z.string().optional().describe("Optional: What you plan to do next based on this thought"),
-  confidence: import_zod4.z.number().min(0).max(1).optional().default(0.8).describe("Optional: How confident you are about this thought (0.0 to 1.0)")
+var thinkParametersSchema = import_zod3.z.object({
+  title: import_zod3.z.string().describe("A concise title for this thinking step"),
+  thought: import_zod3.z.string().describe("Your detailed thought or reasoning for this step"),
+  action: import_zod3.z.string().optional().describe("Optional: What you plan to do next based on this thought"),
+  confidence: import_zod3.z.number().min(0).max(1).optional().default(0.8).describe("Optional: How confident you are about this thought (0.0 to 1.0)")
 });
 var thinkTool = createTool({
   name: "think",
@@ -7198,14 +7217,14 @@ var thinkTool = createTool({
     }
   })
 });
-var analyzeParametersSchema = import_zod4.z.object({
-  title: import_zod4.z.string().describe("A concise title for this analysis step"),
-  result: import_zod4.z.string().describe("The outcome or result of the previous action/thought being analyzed"),
-  analysis: import_zod4.z.string().describe("Your analysis of the result"),
-  next_action: import_zod4.z.nativeEnum(NextAction).describe(
+var analyzeParametersSchema = import_zod3.z.object({
+  title: import_zod3.z.string().describe("A concise title for this analysis step"),
+  result: import_zod3.z.string().describe("The outcome or result of the previous action/thought being analyzed"),
+  analysis: import_zod3.z.string().describe("Your analysis of the result"),
+  next_action: import_zod3.z.nativeEnum(NextAction).describe(
     `What to do next based on the analysis: "${"continue" /* CONTINUE */}", "${"validate" /* VALIDATE */}", or "${"final_answer" /* FINAL_ANSWER */}"`
   ),
-  confidence: import_zod4.z.number().min(0).max(1).optional().default(0.8).describe("Optional: How confident you are in this analysis (0.0 to 1.0)")
+  confidence: import_zod3.z.number().min(0).max(1).optional().default(0.8).describe("Optional: How confident you are in this analysis (0.0 to 1.0)")
 });
 var analyzeTool = createTool({
   name: "analyze",
@@ -7467,15 +7486,15 @@ function serializeValueForDebug(value) {
 __name(serializeValueForDebug, "serializeValueForDebug");
 
 // src/retriever/tools/index.ts
-var import_zod5 = require("zod");
+var import_zod4 = require("zod");
 var createRetrieverTool = /* @__PURE__ */ __name((retriever, options = {}) => {
   const toolName = options.name || "search_knowledge";
   const toolDescription = options.description || "Searches for relevant information in the knowledge base based on the query.";
   return createTool({
     name: toolName,
     description: toolDescription,
-    parameters: import_zod5.z.object({
-      query: import_zod5.z.string().describe("The search query to find relevant information")
+    parameters: import_zod4.z.object({
+      query: import_zod4.z.string().describe("The search query to find relevant information")
     }),
     execute: (_0) => __async(void 0, [_0], function* ({ query }) {
       const result = yield retriever.retrieve(query);
@@ -7537,7 +7556,7 @@ var import_sse = require("@modelcontextprotocol/sdk/client/sse.js");
 var import_stdio = require("@modelcontextprotocol/sdk/client/stdio.js");
 var import_protocol = require("@modelcontextprotocol/sdk/shared/protocol.js");
 var import_types2 = require("@modelcontextprotocol/sdk/types.js");
-var import_json_schema_to_zod = require("@n8n/json-schema-to-zod");
+var import_json_schema_to_zod2 = require("@n8n/json-schema-to-zod");
 var MCPClient = class extends import_node_events2.EventEmitter {
   // Renamed back from identity
   /**
@@ -7681,7 +7700,7 @@ var MCPClient = class extends import_node_events2.EventEmitter {
         const executableTools = {};
         for (const toolDef of Object.values(definitions)) {
           try {
-            const zodSchema = (0, import_json_schema_to_zod.jsonSchemaToZod)(toolDef.inputSchema);
+            const zodSchema = (0, import_json_schema_to_zod2.jsonSchemaToZod)(toolDef.inputSchema);
             const namespacedToolName = `${this.clientInfo.name}_${toolDef.name}`;
             const agentTool = createTool({
               name: namespacedToolName,