@voltagent/core 0.1.26 → 0.1.27

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { Span } from '@opentelemetry/api';
+import { Context } from 'hono';
 import { SpanExporter } from '@opentelemetry/sdk-trace-base';
 import { ClientCapabilities } from '@modelcontextprotocol/sdk/types.js';
 import { EventEmitter } from 'node:events';
@@ -2522,6 +2523,43 @@ declare class Agent<TProvider extends {
     _INTERNAL_setVoltAgentExporter(exporter: VoltAgentExporter): void;
 }
 
+/**
+ * HTTP methods supported by custom endpoints
+ */
+type HttpMethod = "get" | "post" | "put" | "patch" | "delete" | "options" | "head";
+/**
+ * Handler function for custom endpoints
+ */
+type CustomEndpointHandler = (c: Context) => Promise<Response> | Response;
+/**
+ * Definition for a custom endpoint
+ */
+interface CustomEndpointDefinition {
+    /**
+     * The path for the endpoint, relative to the API root
+     * Example: "/custom-endpoint" or "/custom/:param"
+     */
+    path: string;
+    /**
+     * The HTTP method for the endpoint
+     */
+    method: HttpMethod;
+    /**
+     * The handler function for the endpoint
+     */
+    handler: CustomEndpointHandler;
+    /**
+     * Optional description for the endpoint
+     */
+    description?: string;
+}
+/**
+ * Error thrown when a custom endpoint definition is invalid
+ */
+declare class CustomEndpointError extends Error {
+    constructor(message: string);
+}
+
 /**
  * Enum defining the next action to take after a reasoning step.
  */
@@ -3220,13 +3258,30 @@ declare class AgentRegistry {
     getGlobalVoltAgentExporter(): VoltAgentExporter | undefined;
 }
 
+/**
+ * Register a single custom endpoint with the API server
+ * @param endpoint The custom endpoint definition
+ * @throws CustomEndpointError if the endpoint definition is invalid or registration fails
+ */
+declare function registerCustomEndpoint(endpoint: CustomEndpointDefinition): void;
+/**
+ * Register multiple custom endpoints with the API server
+ * @param endpoints Array of custom endpoint definitions
+ * @throws CustomEndpointError if any endpoint definition is invalid or registration fails
+ */
+declare function registerCustomEndpoints(endpoints: CustomEndpointDefinition[]): void;
+
 type VoltAgentOptions = {
     agents: Record<string, Agent<any>>;
     port?: number;
     autoStart?: boolean;
     checkDependencies?: boolean;
     /**
-     * Optional OpenTelemetry SpanExporter instance or array of instances,
+     * Optional array of custom endpoint definitions to register with the API server
+     */
+    customEndpoints?: CustomEndpointDefinition[];
+    /**
+     * Optional OpenTelemetry SpanExporter instance or array of instances.
      * or a VoltAgentExporter instance or array of instances.
      * If provided, VoltAgent will attempt to initialize and register
      * a NodeTracerProvider with a BatchSpanProcessor for the given exporter(s).
@@ -3240,6 +3295,7 @@ type VoltAgentOptions = {
 declare class VoltAgent {
     private registry;
     private serverStarted;
+    private customEndpoints;
     constructor(options: VoltAgentOptions);
     /**
      * Check for dependency updates
@@ -3257,6 +3313,18 @@ declare class VoltAgent {
      * Start the server
      */
     startServer(): Promise<void>;
+    /**
+     * Register a custom endpoint with the API server
+     * @param endpoint The custom endpoint definition
+     * @throws Error if the endpoint definition is invalid or registration fails
+     */
+    registerCustomEndpoint(endpoint: CustomEndpointDefinition): void;
+    /**
+     * Register multiple custom endpoints with the API server
+     * @param endpoints Array of custom endpoint definitions
+     * @throws Error if any endpoint definition is invalid or registration fails
+     */
+    registerCustomEndpoints(endpoints: CustomEndpointDefinition[]): void;
     /**
      * Get all registered agents
      */
@@ -3273,4 +3341,4 @@ declare class VoltAgent {
     shutdownTelemetry(): Promise<void>;
 }
 
-export { Agent, AgentErrorEvent, AgentHistoryEntry, AgentHookOnEnd, AgentHookOnHandoff, AgentHookOnStart, AgentHookOnToolEnd, AgentHookOnToolStart, AgentHooks, AgentOptions, AgentRegistry, AgentResponse, AgentStartEvent, AgentStartEventMetadata, AgentSuccessEvent, AgentSuccessEventMetadata, AgentTool, AllowedVariableValue, AnyToolConfig, BaseEventMetadata, BaseLLMOptions, BaseMessage, BaseRetriever, BaseTimelineEvent, BaseTool, BaseToolCall, ClientInfo, Conversation, CreateConversationInput, CreateReasoningToolsOptions, DEFAULT_INSTRUCTIONS, DataContent, EventStatus, ExtractVariableNames, FEW_SHOT_EXAMPLES, FilePart, GenerateObjectOptions, GenerateTextOptions, HTTPServerConfig, HistoryStatus, ImagePart, InMemoryStorage, InferGenerateObjectResponse, InferGenerateTextResponse, InferMessage, InferModel, InferProviderParams, InferStreamResponse, InferTool, LLMProvider, LibSQLStorage, MCPClient, MCPClientConfig, MCPClientEvents, MCPConfiguration, MCPOptions, MCPServerConfig, MCPToolCall, MCPToolResult, Memory, MemoryEventMetadata, MemoryManager, MemoryMessage, MemoryOptions, MemoryReadErrorEvent, MemoryReadStartEvent, MemoryReadSuccessEvent, MemoryWriteErrorEvent, MemoryWriteStartEvent, MemoryWriteSuccessEvent, MessageContent, MessageFilterOptions, MessageRole, ModelToolCall, NewTimelineEvent, NextAction, NodeType, OnEndHookArgs, OnHandoffHookArgs, OnStartHookArgs, OnToolEndHookArgs, OnToolStartHookArgs, OperationContext, PackageUpdateInfo, PromptCreator, PromptTemplate, ProviderObjectResponse, ProviderObjectStreamResponse, ProviderParams, ProviderResponse, ProviderTextResponse, ProviderTextStreamResponse, ReadableStreamType, ReasoningStep, ReasoningStepSchema, ReasoningToolExecuteOptions, Retriever, RetrieverErrorEvent, RetrieverOptions, RetrieverStartEvent, RetrieverSuccessEvent, RetryConfig, StandardEventData, StandardTimelineEvent, StdioServerConfig, StepChunkCallback, StepFinishCallback, StepWithContent, StreamObjectFinishResult, StreamObjectOnFinishCallback, StreamObjectOptions, StreamTextFinishResult, StreamTextOnFinishCallback, StreamTextOptions, TemplateVariables, TextPart, TimelineEventCoreLevel, TimelineEventCoreStatus, TimelineEventCoreType, Tool, ToolCall, ToolErrorEvent, ToolErrorInfo, ToolExecuteOptions, ToolExecutionContext, ToolManager, ToolOptions, ToolSchema, ToolStartEvent, ToolStatus, ToolStatusInfo, ToolSuccessEvent, Toolkit, ToolsetMap, ToolsetWithTools, TransportError, Usage, UsageInfo, Voice, VoiceEventData, VoiceEventType, VoiceMetadata, VoiceOptions, VoltAgent, VoltAgentError, VoltAgentExporter, VoltAgentExporterOptions, checkForUpdates, createHooks, createNodeId, createPrompt, createReasoningTools, createRetrieverTool, createTool, createToolkit, VoltAgent as default, getNodeTypeFromNodeId, safeJsonParse, serializeValueForDebug, tool, updateAllPackages, updateSinglePackage, zodSchemaToJsonUI };
+export { Agent, AgentErrorEvent, AgentHistoryEntry, AgentHookOnEnd, AgentHookOnHandoff, AgentHookOnStart, AgentHookOnToolEnd, AgentHookOnToolStart, AgentHooks, AgentOptions, AgentRegistry, AgentResponse, AgentStartEvent, AgentStartEventMetadata, AgentSuccessEvent, AgentSuccessEventMetadata, AgentTool, AllowedVariableValue, AnyToolConfig, BaseEventMetadata, BaseLLMOptions, BaseMessage, BaseRetriever, BaseTimelineEvent, BaseTool, BaseToolCall, ClientInfo, Conversation, CreateConversationInput, CreateReasoningToolsOptions, CustomEndpointDefinition, CustomEndpointError, CustomEndpointHandler, DEFAULT_INSTRUCTIONS, DataContent, EventStatus, ExtractVariableNames, FEW_SHOT_EXAMPLES, FilePart, GenerateObjectOptions, GenerateTextOptions, HTTPServerConfig, HistoryStatus, HttpMethod, ImagePart, InMemoryStorage, InferGenerateObjectResponse, InferGenerateTextResponse, InferMessage, InferModel, InferProviderParams, InferStreamResponse, InferTool, LLMProvider, LibSQLStorage, MCPClient, MCPClientConfig, MCPClientEvents, MCPConfiguration, MCPOptions, MCPServerConfig, MCPToolCall, MCPToolResult, Memory, MemoryEventMetadata, MemoryManager, MemoryMessage, MemoryOptions, MemoryReadErrorEvent, MemoryReadStartEvent, MemoryReadSuccessEvent, MemoryWriteErrorEvent, MemoryWriteStartEvent, MemoryWriteSuccessEvent, MessageContent, MessageFilterOptions, MessageRole, ModelToolCall, NewTimelineEvent, NextAction, NodeType, OnEndHookArgs, OnHandoffHookArgs, OnStartHookArgs, OnToolEndHookArgs, OnToolStartHookArgs, OperationContext, PackageUpdateInfo, PromptCreator, PromptTemplate, ProviderObjectResponse, ProviderObjectStreamResponse, ProviderParams, ProviderResponse, ProviderTextResponse, ProviderTextStreamResponse, ReadableStreamType, ReasoningStep, ReasoningStepSchema, ReasoningToolExecuteOptions, Retriever, RetrieverErrorEvent, RetrieverOptions, RetrieverStartEvent, RetrieverSuccessEvent, RetryConfig, StandardEventData, StandardTimelineEvent, StdioServerConfig, StepChunkCallback, StepFinishCallback, StepWithContent, StreamObjectFinishResult, StreamObjectOnFinishCallback, StreamObjectOptions, StreamTextFinishResult, StreamTextOnFinishCallback, StreamTextOptions, TemplateVariables, TextPart, TimelineEventCoreLevel, TimelineEventCoreStatus, TimelineEventCoreType, Tool, ToolCall, ToolErrorEvent, ToolErrorInfo, ToolExecuteOptions, ToolExecutionContext, ToolManager, ToolOptions, ToolSchema, ToolStartEvent, ToolStatus, ToolStatusInfo, ToolSuccessEvent, Toolkit, ToolsetMap, ToolsetWithTools, TransportError, Usage, UsageInfo, Voice, VoiceEventData, VoiceEventType, VoiceMetadata, VoiceOptions, VoltAgent, VoltAgentError, VoltAgentExporter, VoltAgentExporterOptions, checkForUpdates, createHooks, createNodeId, createPrompt, createReasoningTools, createRetrieverTool, createTool, createToolkit, VoltAgent as default, getNodeTypeFromNodeId, registerCustomEndpoint, registerCustomEndpoints, safeJsonParse, serializeValueForDebug, tool, updateAllPackages, updateSinglePackage, zodSchemaToJsonUI };

package/dist/index.js

@@ -96,6 +96,7 @@ __export(src_exports, {
   Agent: () => Agent,
   AgentRegistry: () => AgentRegistry,
   BaseRetriever: () => BaseRetriever,
+  CustomEndpointError: () => CustomEndpointError,
   DEFAULT_INSTRUCTIONS: () => DEFAULT_INSTRUCTIONS,
   FEW_SHOT_EXAMPLES: () => FEW_SHOT_EXAMPLES,
   InMemoryStorage: () => InMemoryStorage,
@@ -120,6 +121,8 @@ __export(src_exports, {
   createToolkit: () => createToolkit,
   default: () => src_default,
   getNodeTypeFromNodeId: () => getNodeTypeFromNodeId,
+  registerCustomEndpoint: () => registerCustomEndpoint,
+  registerCustomEndpoints: () => registerCustomEndpoints,
   safeJsonParse: () => safeJsonParse,
   serializeValueForDebug: () => serializeValueForDebug,
   tool: () => tool,
@@ -1175,6 +1178,43 @@ Example event: 'data: {"partialUpdate": {...}}
   tags: ["Agent Generation"]
 });
 
+// src/server/custom-endpoints/index.ts
+var import_zod = require("zod");
+var CustomEndpointSchema = import_zod.z.object({
+  path: import_zod.z.string().startsWith("/"),
+  method: import_zod.z.enum(["get", "post", "put", "patch", "delete", "options", "head"]),
+  handler: import_zod.z.function().args(import_zod.z.any()).returns(import_zod.z.any()),
+  description: import_zod.z.string().optional()
+});
+var CustomEndpointError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CustomEndpointError";
+  }
+};
+__name(CustomEndpointError, "CustomEndpointError");
+function validateCustomEndpoint(endpoint) {
+  try {
+    return CustomEndpointSchema.parse(endpoint);
+  } catch (error) {
+    if (error instanceof import_zod.z.ZodError) {
+      throw new CustomEndpointError(`Invalid custom endpoint definition: ${error.message}`);
+    }
+    throw error;
+  }
+}
+__name(validateCustomEndpoint, "validateCustomEndpoint");
+function validateCustomEndpoints(endpoints) {
+  if (!endpoints || !Array.isArray(endpoints)) {
+    throw new CustomEndpointError("Custom endpoints must be an array");
+  }
+  if (endpoints.length === 0) {
+    return [];
+  }
+  return endpoints.map(validateCustomEndpoint);
+}
+__name(validateCustomEndpoints, "validateCustomEndpoints");
+
 // src/server/api.ts
 var import_zod_from_json_schema = require("zod-from-json-schema");
 var app = new import_zod_openapi2.OpenAPIHono();
@@ -1826,6 +1866,91 @@ app.doc("/doc", {
   servers: [{ url: "http://localhost:3141", description: "Local development server" }]
 });
 app.get("/ui", (0, import_swagger_ui.swaggerUI)({ url: "/doc" }));
+function registerCustomEndpoint(endpoint) {
+  try {
+    const validatedEndpoint = validateCustomEndpoint(endpoint);
+    const { path: path2, method, handler } = validatedEndpoint;
+    switch (method) {
+      case "get":
+        app.get(path2, handler);
+        break;
+      case "post":
+        app.post(path2, handler);
+        break;
+      case "put":
+        app.put(path2, handler);
+        break;
+      case "patch":
+        app.patch(path2, handler);
+        break;
+      case "delete":
+        app.delete(path2, handler);
+        break;
+      case "options":
+        app.options(path2, handler);
+        break;
+      default:
+        throw new CustomEndpointError(`Unsupported HTTP method: ${method}`);
+    }
+    if (!global.__voltAgentCustomEndpoints) {
+      global.__voltAgentCustomEndpoints = [];
+    }
+    global.__voltAgentCustomEndpoints.push(validatedEndpoint);
+  } catch (error) {
+    if (error instanceof CustomEndpointError) {
+      throw error;
+    }
+    throw new CustomEndpointError(
+      `Failed to register custom endpoint: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+__name(registerCustomEndpoint, "registerCustomEndpoint");
+function registerCustomEndpoints(endpoints) {
+  try {
+    const validatedEndpoints = validateCustomEndpoints(endpoints);
+    if (validatedEndpoints.length === 0) {
+      return;
+    }
+    for (const endpoint of validatedEndpoints) {
+      const { path: path2, method, handler } = endpoint;
+      switch (method) {
+        case "get":
+          app.get(path2, handler);
+          break;
+        case "post":
+          app.post(path2, handler);
+          break;
+        case "put":
+          app.put(path2, handler);
+          break;
+        case "patch":
+          app.patch(path2, handler);
+          break;
+        case "delete":
+          app.delete(path2, handler);
+          break;
+        case "options":
+          app.options(path2, handler);
+          break;
+        default:
+          throw new CustomEndpointError(`Unsupported HTTP method: ${method}`);
+      }
+    }
+    if (!global.__voltAgentCustomEndpoints) {
+      global.__voltAgentCustomEndpoints = [];
+    }
+    global.__voltAgentCustomEndpoints.push(...validatedEndpoints);
+  } catch (error) {
+    if (error instanceof CustomEndpointError) {
+      throw error;
+    }
+    throw new CustomEndpointError(
+      `Failed to register custom endpoints: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+__name(registerCustomEndpoints, "registerCustomEndpoints");
 var createWebSocketServer = /* @__PURE__ */ __name(() => {
   const wss = new import_ws.WebSocketServer({ noServer: true });
   AgentEventEmitter.getInstance().onHistoryUpdate((agentId, historyEntry) => {
@@ -1999,6 +2124,31 @@ var printServerStartup = /* @__PURE__ */ __name((port) => {
   console.log(
     `${colors.green}  \u2713 ${colors.bright}Swagger UI:   ${colors.reset}${colors.white}http://localhost:${port}/ui${colors.reset}`
   );
+  const customEndpoints = global.__voltAgentCustomEndpoints;
+  if (customEndpoints && customEndpoints.length > 0) {
+    console.log();
+    console.log(
+      `${colors.green}  \u2713 ${colors.bright}Custom Endpoints: ${colors.reset}${colors.dim}${customEndpoints.length} registered${colors.reset}`
+    );
+    const methodGroups = {};
+    customEndpoints.forEach((endpoint) => {
+      const method = endpoint.method.toUpperCase();
+      if (!methodGroups[method]) {
+        methodGroups[method] = [];
+      }
+      methodGroups[method].push(endpoint.path);
+    });
+    const methodOrder = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"];
+    methodOrder.forEach((method) => {
+      if (methodGroups[method]) {
+        methodGroups[method].forEach((path2) => {
+          console.log(
+            `${colors.dim}    ${method.padEnd(6)} ${colors.reset}${colors.white}${path2}${colors.reset}`
+          );
+        });
+      }
+    });
+  }
   console.log();
   console.log(
     `${colors.bright}${colors.yellow}  ${colors.bright}Developer Console:    ${colors.reset}${colors.white}https://console.voltagent.dev${colors.reset}`
@@ -5097,7 +5247,7 @@ function createHooks(hooks = {}) {
 __name(createHooks, "createHooks");
 
 // src/agent/subagent/index.ts
-var import_zod = require("zod");
+var import_zod2 = require("zod");
 var SubAgentManager = class {
   /**
    * Creates a new SubAgentManager instance
@@ -5324,10 +5474,10 @@ Context: ${JSON.stringify(context)}`
       id: "delegate_task",
       name: "delegate_task",
       description: "Delegate a task to one or more specialized agents",
-      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")
+      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")
       }),
       execute: (_0) => __async(this, [_0], function* ({ task, targetAgents, context = {} }) {
         try {
@@ -7362,48 +7512,48 @@ ${context}`;
 __name(Agent, "Agent");
 
 // src/tool/reasoning/tools.ts
-var import_zod3 = require("zod");
+var import_zod4 = require("zod");
 var import_uuid4 = require("uuid");
 
 // src/tool/reasoning/types.ts
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 var NextAction = /* @__PURE__ */ ((NextAction2) => {
   NextAction2["CONTINUE"] = "continue";
   NextAction2["VALIDATE"] = "validate";
   NextAction2["FINAL_ANSWER"] = "final_answer";
   return NextAction2;
 })(NextAction || {});
-var ReasoningStepSchema = import_zod2.z.object({
-  id: import_zod2.z.string().uuid(),
+var ReasoningStepSchema = import_zod3.z.object({
+  id: import_zod3.z.string().uuid(),
   // Unique ID for the step
-  type: import_zod2.z.enum(["thought", "analysis"]),
+  type: import_zod3.z.enum(["thought", "analysis"]),
   // Type of step
-  title: import_zod2.z.string(),
+  title: import_zod3.z.string(),
   // Concise title for the step
-  reasoning: import_zod2.z.string(),
+  reasoning: import_zod3.z.string(),
   // The detailed thought or analysis
-  action: import_zod2.z.string().optional(),
+  action: import_zod3.z.string().optional(),
   // The action planned based on the thought (for 'thought' type)
-  result: import_zod2.z.string().optional(),
+  result: import_zod3.z.string().optional(),
   // The result being analyzed (for 'analysis' type)
-  next_action: import_zod2.z.nativeEnum(NextAction).optional(),
+  next_action: import_zod3.z.nativeEnum(NextAction).optional(),
   // What to do next (for 'analysis' type)
-  confidence: import_zod2.z.number().min(0).max(1).optional().default(0.8),
+  confidence: import_zod3.z.number().min(0).max(1).optional().default(0.8),
   // Confidence level
-  timestamp: import_zod2.z.string().datetime(),
+  timestamp: import_zod3.z.string().datetime(),
   // Timestamp of the step creation
-  historyEntryId: import_zod2.z.string(),
+  historyEntryId: import_zod3.z.string(),
   // Link to the main history entry
-  agentId: import_zod2.z.string()
+  agentId: import_zod3.z.string()
   // ID of the agent performing the step
 });
 
 // src/tool/reasoning/tools.ts
-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 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 thinkTool = createTool({
   name: "think",
@@ -7439,14 +7589,14 @@ var thinkTool = createTool({
     }
   })
 });
-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(
+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(
     `What to do next based on the analysis: "${"continue" /* CONTINUE */}", "${"validate" /* VALIDATE */}", or "${"final_answer" /* FINAL_ANSWER */}"`
   ),
-  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)")
+  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)")
 });
 var analyzeTool = createTool({
   name: "analyze",
@@ -7647,15 +7797,15 @@ ${fewShotExamples != null ? fewShotExamples : FEW_SHOT_EXAMPLES}`;
 }, "createReasoningTools");
 
 // src/retriever/tools/index.ts
-var import_zod4 = require("zod");
+var import_zod5 = 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_zod4.z.object({
-      query: import_zod4.z.string().describe("The search query to find relevant information")
+    parameters: import_zod5.z.object({
+      query: import_zod5.z.string().describe("The search query to find relevant information")
     }),
     execute: (_0) => __async(void 0, [_0], function* ({ query }) {
       const result = yield retriever.retrieve(query);
@@ -8474,8 +8624,12 @@ var VoltAgent = class {
   constructor(options) {
     __publicField(this, "registry");
     __publicField(this, "serverStarted", false);
+    __publicField(this, "customEndpoints", []);
     this.registry = AgentRegistry.getInstance();
     this.registerAgents(options.agents);
+    if (options.customEndpoints && Array.isArray(options.customEndpoints)) {
+      this.customEndpoints = [...options.customEndpoints];
+    }
     if (options.telemetryExporter) {
       const exporters = Array.isArray(options.telemetryExporter) ? options.telemetryExporter : [options.telemetryExporter];
       const voltExporter = exporters.find(
@@ -8548,10 +8702,59 @@ var VoltAgent = class {
         console.log("[VoltAgent] Server is already running");
         return;
       }
-      yield startServer();
-      this.serverStarted = true;
+      try {
+        if (this.customEndpoints.length > 0) {
+          registerCustomEndpoints(this.customEndpoints);
+        }
+        yield startServer();
+        this.serverStarted = true;
+      } catch (error) {
+        console.error(
+          `[VoltAgent] Failed to start server: ${error instanceof Error ? error.message : String(error)}`
+        );
+        throw error;
+      }
     });
   }
+  /**
+   * Register a custom endpoint with the API server
+   * @param endpoint The custom endpoint definition
+   * @throws Error if the endpoint definition is invalid or registration fails
+   */
+  registerCustomEndpoint(endpoint) {
+    try {
+      this.customEndpoints.push(endpoint);
+      if (this.serverStarted) {
+        registerCustomEndpoint(endpoint);
+      }
+    } catch (error) {
+      console.error(
+        `Failed to register custom endpoint: ${error instanceof Error ? error.message : String(error)}`
+      );
+      throw error;
+    }
+  }
+  /**
+   * Register multiple custom endpoints with the API server
+   * @param endpoints Array of custom endpoint definitions
+   * @throws Error if any endpoint definition is invalid or registration fails
+   */
+  registerCustomEndpoints(endpoints) {
+    try {
+      if (!endpoints || !Array.isArray(endpoints) || endpoints.length === 0) {
+        return;
+      }
+      this.customEndpoints.push(...endpoints);
+      if (this.serverStarted) {
+        registerCustomEndpoints(endpoints);
+      }
+    } catch (error) {
+      console.error(
+        `Failed to register custom endpoints: ${error instanceof Error ? error.message : String(error)}`
+      );
+      throw error;
+    }
+  }
   /**
    * Get all registered agents
    */
@@ -8635,6 +8838,7 @@ if (typeof require !== "undefined" && typeof module !== "undefined" && require.m
   Agent,
   AgentRegistry,
   BaseRetriever,
+  CustomEndpointError,
   DEFAULT_INSTRUCTIONS,
   FEW_SHOT_EXAMPLES,
   InMemoryStorage,
@@ -8658,6 +8862,8 @@ if (typeof require !== "undefined" && typeof module !== "undefined" && require.m
   createTool,
   createToolkit,
   getNodeTypeFromNodeId,
+  registerCustomEndpoint,
+  registerCustomEndpoints,
   safeJsonParse,
   serializeValueForDebug,
   tool,