@dexto/server 1.2.6 → 1.4.0

package/dist/hono/routes/llm.js

@@ -1,15 +1,20 @@
 import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import { DextoRuntimeError, ErrorScope, ErrorType } from "@dexto/core";
 import {
   LLM_REGISTRY,
   LLM_PROVIDERS,
-  LLM_ROUTERS,
   SUPPORTED_FILE_TYPES,
-  getSupportedRoutersForProvider,
   supportsBaseURL,
-  isRouterSupportedForModel,
   LLMUpdatesSchema
 } from "@dexto/core";
-import { getProviderKeyStatus, saveProviderApiKey } from "@dexto/agent-management";
+import {
+  getProviderKeyStatus,
+  saveProviderApiKey,
+  loadCustomModels,
+  saveCustomModel,
+  deleteCustomModel,
+  CustomModelSchema
+} from "@dexto/agent-management";
 import {
   ProviderCatalogSchema,
   ModelFlatSchema,
@@ -25,7 +30,6 @@ const CatalogQuerySchema = z.object({
   hasKey: z.union([z.literal("true"), z.literal("false"), z.literal("1"), z.literal("0")]).optional().transform(
     (raw) => raw === "true" || raw === "1" ? true : raw === "false" || raw === "0" ? false : void 0
   ).describe("Filter by API key presence (true or false)"),
-  router: z.enum(LLM_ROUTERS).optional().describe("Filter by router type (vercel or in-built)"),
   fileType: z.enum(SUPPORTED_FILE_TYPES).optional().describe("Filter by supported file type (audio, pdf, or image)"),
   defaultOnly: z.union([z.literal("true"), z.literal("false"), z.literal("1"), z.literal("0")]).optional().transform(
     (raw) => raw === "true" || raw === "1" ? true : raw === "false" || raw === "0" ? false : void 0
@@ -57,8 +61,7 @@ function createLlmRouter(getAgent) {
           "application/json": {
             schema: z.object({
               config: LLMConfigResponseSchema.partial({
-                maxIterations: true,
-                router: true
+                maxIterations: true
               }).extend({
                 displayName: z.string().optional().describe("Human-readable model display name")
               })
@@ -152,6 +155,84 @@ function createLlmRouter(getAgent) {
       }
     }
   });
+  const listCustomModelsRoute = createRoute({
+    method: "get",
+    path: "/llm/custom-models",
+    summary: "List Custom Models",
+    description: "Returns all saved custom openai-compatible model configurations",
+    tags: ["llm"],
+    responses: {
+      200: {
+        description: "List of custom models",
+        content: {
+          "application/json": {
+            schema: z.object({
+              models: z.array(CustomModelSchema).describe("List of custom models")
+            })
+          }
+        }
+      }
+    }
+  });
+  const createCustomModelRoute = createRoute({
+    method: "post",
+    path: "/llm/custom-models",
+    summary: "Create Custom Model",
+    description: "Saves a new custom openai-compatible model configuration",
+    tags: ["llm"],
+    request: {
+      body: { content: { "application/json": { schema: CustomModelSchema } } }
+    },
+    responses: {
+      200: {
+        description: "Custom model saved",
+        content: {
+          "application/json": {
+            schema: z.object({
+              ok: z.literal(true).describe("Success indicator"),
+              model: CustomModelSchema
+            })
+          }
+        }
+      }
+    }
+  });
+  const deleteCustomModelRoute = createRoute({
+    method: "delete",
+    path: "/llm/custom-models/{name}",
+    summary: "Delete Custom Model",
+    description: "Deletes a custom model by name",
+    tags: ["llm"],
+    request: {
+      params: z.object({
+        name: z.string().min(1).describe("Model name to delete")
+      })
+    },
+    responses: {
+      200: {
+        description: "Custom model deleted",
+        content: {
+          "application/json": {
+            schema: z.object({
+              ok: z.literal(true).describe("Success indicator"),
+              deleted: z.string().describe("Name of the deleted model")
+            })
+          }
+        }
+      },
+      404: {
+        description: "Custom model not found",
+        content: {
+          "application/json": {
+            schema: z.object({
+              ok: z.literal(false).describe("Failure indicator"),
+              error: z.string().describe("Error message")
+            })
+          }
+        }
+      }
+    }
+  });
   return app.openapi(currentRoute, (ctx) => {
     const agent = getAgent();
     const { sessionId } = ctx.req.valid("query");
@@ -183,7 +264,6 @@ function createLlmRouter(getAgent) {
         name: displayName,
         hasApiKey: keyStatus.hasApiKey,
         primaryEnvVar: keyStatus.envVar,
-        supportedRouters: getSupportedRoutersForProvider(provider),
         supportsBaseURL: supportsBaseURL(provider),
         models: info.models,
         supportedFileTypes: info.supportedFileTypes
@@ -213,23 +293,6 @@ function createLlmRouter(getAgent) {
       }
       filtered = byKey;
     }
-    if (queryParams.router) {
-      const byRouter = {};
-      for (const [id, catalog] of Object.entries(filtered)) {
-        if (!catalog.supportedRouters.includes(queryParams.router)) continue;
-        const models = catalog.models.filter(
-          (model) => isRouterSupportedForModel(
-            id,
-            model.name,
-            queryParams.router
-          )
-        );
-        if (models.length > 0) {
-          byRouter[id] = { ...catalog, models };
-        }
-      }
-      filtered = byRouter;
-    }
     if (queryParams.fileType) {
       const byFileType = {};
       for (const [id, catalog] of Object.entries(filtered)) {
@@ -280,6 +343,26 @@ function createLlmRouter(getAgent) {
       },
       sessionId
     });
+  }).openapi(listCustomModelsRoute, async (ctx) => {
+    const models = await loadCustomModels();
+    return ctx.json({ models });
+  }).openapi(createCustomModelRoute, async (ctx) => {
+    const model = ctx.req.valid("json");
+    await saveCustomModel(model);
+    return ctx.json({ ok: true, model });
+  }).openapi(deleteCustomModelRoute, async (ctx) => {
+    const { name } = ctx.req.valid("param");
+    const deleted = await deleteCustomModel(name);
+    if (!deleted) {
+      throw new DextoRuntimeError(
+        "custom_model_not_found",
+        ErrorScope.LLM,
+        ErrorType.NOT_FOUND,
+        `Custom model '${name}' not found`,
+        { modelName: name }
+      );
+    }
+    return ctx.json({ ok: true, deleted: name }, 200);
   });
 }
 export {

package/dist/hono/routes/mcp.cjs

@@ -40,7 +40,7 @@ const ServerStatusResponseSchema = import_zod_openapi.z.object({
 const ServerInfoSchema = import_zod_openapi.z.object({
   id: import_zod_openapi.z.string().describe("Server identifier"),
   name: import_zod_openapi.z.string().describe("Server name"),
-  status: import_zod_openapi.z.enum(["connected", "error", "disconnected"]).describe("Server status")
+  status: import_zod_openapi.z.enum(import_core.MCP_CONNECTION_STATUSES).describe("Server status")
 }).strict().describe("MCP server information");
 const ServersListResponseSchema = import_zod_openapi.z.object({
   servers: import_zod_openapi.z.array(ServerInfoSchema).describe("Array of server information")
@@ -230,8 +230,11 @@ function createMcpRouter(getAgent) {
   return app.openapi(addServerRoute, async (ctx) => {
     const agent = getAgent();
     const { name, config, persistToAgent } = ctx.req.valid("json");
-    await agent.connectMcpServer(name, config);
-    import_core.logger.info(`Successfully connected to new server '${name}' via API request.`);
+    await agent.addMcpServer(name, config);
+    const isConnected = config.enabled !== false;
+    import_core.logger.info(
+      isConnected ? `Successfully connected to new server '${name}' via API request.` : `Registered server '${name}' (disabled) via API request.`
+    );
     if (persistToAgent === true) {
       try {
         const currentConfig = agent.getEffectiveConfig();
@@ -262,7 +265,8 @@ function createMcpRouter(getAgent) {
         );
       }
     }
-    return ctx.json({ status: "connected", name }, 200);
+    const status = isConnected ? "connected" : "registered";
+    return ctx.json({ status, name }, 200);
   }).openapi(listServersRoute, async (ctx) => {
     const agent = getAgent();
     const clientsMap = agent.getMcpClients();

package/dist/hono/routes/mcp.d.ts

@@ -9,6 +9,7 @@ export declare function createMcpRouter(getAgent: () => DextoAgent): OpenAPIHono
                         type: "stdio";
                         command: string;
                         timeout?: number | undefined;
+                        enabled?: boolean | undefined;
                         args?: string[] | undefined;
                         env?: Record<string, string> | undefined;
                         connectionMode?: "strict" | "lenient" | undefined;
@@ -16,12 +17,14 @@ export declare function createMcpRouter(getAgent: () => DextoAgent): OpenAPIHono
                         type: "sse";
                         url: string;
                         timeout?: number | undefined;
+                        enabled?: boolean | undefined;
                         connectionMode?: "strict" | "lenient" | undefined;
                         headers?: Record<string, string> | undefined;
                     } | {
                         type: "http";
                         url: string;
                         timeout?: number | undefined;
+                        enabled?: boolean | undefined;
                         connectionMode?: "strict" | "lenient" | undefined;
                         headers?: Record<string, string> | undefined;
                     };
@@ -200,10 +203,10 @@ export declare function createMcpRouter(getAgent: () => DextoAgent): OpenAPIHono
                     source: "mcp" | "internal";
                     description?: string | undefined;
                     mimeType?: string | undefined;
-                    name?: string | undefined;
                     metadata?: {
                         [x: string]: import("hono/utils/types").JSONValue;
                     } | undefined;
+                    name?: string | undefined;
                     serverName?: string | undefined;
                     size?: number | undefined;
                     lastModified?: string | undefined;

package/dist/hono/routes/mcp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/mcp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AA0I9C,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA4SzD"}
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/mcp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AA0I9C,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAkTzD"}

package/dist/hono/routes/mcp.js

@@ -1,5 +1,5 @@
 import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
-import { logger, McpServerConfigSchema } from "@dexto/core";
+import { logger, McpServerConfigSchema, MCP_CONNECTION_STATUSES } from "@dexto/core";
 import { updateAgentConfigFile } from "@dexto/agent-management";
 import { ResourceSchema } from "../schemas/responses.js";
 const McpServerRequestSchema = z.object({
@@ -17,7 +17,7 @@ const ServerStatusResponseSchema = z.object({
 const ServerInfoSchema = z.object({
   id: z.string().describe("Server identifier"),
   name: z.string().describe("Server name"),
-  status: z.enum(["connected", "error", "disconnected"]).describe("Server status")
+  status: z.enum(MCP_CONNECTION_STATUSES).describe("Server status")
 }).strict().describe("MCP server information");
 const ServersListResponseSchema = z.object({
   servers: z.array(ServerInfoSchema).describe("Array of server information")
@@ -207,8 +207,11 @@ function createMcpRouter(getAgent) {
   return app.openapi(addServerRoute, async (ctx) => {
     const agent = getAgent();
     const { name, config, persistToAgent } = ctx.req.valid("json");
-    await agent.connectMcpServer(name, config);
-    logger.info(`Successfully connected to new server '${name}' via API request.`);
+    await agent.addMcpServer(name, config);
+    const isConnected = config.enabled !== false;
+    logger.info(
+      isConnected ? `Successfully connected to new server '${name}' via API request.` : `Registered server '${name}' (disabled) via API request.`
+    );
     if (persistToAgent === true) {
       try {
         const currentConfig = agent.getEffectiveConfig();
@@ -239,7 +242,8 @@ function createMcpRouter(getAgent) {
         );
       }
     }
-    return ctx.json({ status: "connected", name }, 200);
+    const status = isConnected ? "connected" : "registered";
+    return ctx.json({ status, name }, 200);
   }).openapi(listServersRoute, async (ctx) => {
     const agent = getAgent();
     const clientsMap = agent.getMcpClients();

package/dist/hono/routes/memory.d.ts

@@ -99,11 +99,11 @@ export declare function createMemoryRouter(getAgent: () => DextoAgent): OpenAPIH
                 };
             } & {
                 json: {
+                    content?: string | undefined;
                     metadata?: z.objectInputType<{
                         source: z.ZodOptional<z.ZodEnum<["user", "system"]>>;
                         pinned: z.ZodOptional<z.ZodBoolean>;
                     }, z.ZodTypeAny, "passthrough"> | undefined;
-                    content?: string | undefined;
                     tags?: string[] | undefined;
                 };
             };

package/dist/hono/routes/messages.cjs

@@ -25,25 +25,26 @@ var import_zod_openapi = require("@hono/zod-openapi");
 var import_streaming = require("hono/streaming");
 var import_core = require("@dexto/core");
 var import_responses = require("../schemas/responses.js");
+const TextPartSchema = import_zod_openapi.z.object({
+  type: import_zod_openapi.z.literal("text").describe("Content type identifier"),
+  text: import_zod_openapi.z.string().describe("Text content")
+}).describe("Text content part");
+const ImagePartSchema = import_zod_openapi.z.object({
+  type: import_zod_openapi.z.literal("image").describe("Content type identifier"),
+  image: import_zod_openapi.z.string().describe("Base64-encoded image data or URL"),
+  mimeType: import_zod_openapi.z.string().optional().describe("MIME type (e.g., image/png)")
+}).describe("Image content part");
+const FilePartSchema = import_zod_openapi.z.object({
+  type: import_zod_openapi.z.literal("file").describe("Content type identifier"),
+  data: import_zod_openapi.z.string().describe("Base64-encoded file data or URL"),
+  mimeType: import_zod_openapi.z.string().describe("MIME type (e.g., application/pdf)"),
+  filename: import_zod_openapi.z.string().optional().describe("Optional filename")
+}).describe("File content part");
+const ContentPartSchema = import_zod_openapi.z.discriminatedUnion("type", [TextPartSchema, ImagePartSchema, FilePartSchema]).describe("Content part - text, image, or file");
 const MessageBodySchema = import_zod_openapi.z.object({
-  message: import_zod_openapi.z.string().optional().describe("The user message text"),
-  sessionId: import_zod_openapi.z.string().min(1, "Session ID is required").describe("The session to use for this message"),
-  imageData: import_zod_openapi.z.object({
-    base64: import_zod_openapi.z.string().describe("Base64-encoded image data"),
-    mimeType: import_zod_openapi.z.string().describe("The MIME type of the image (e.g., image/png)")
-  }).optional().describe("Optional image data to include with the message"),
-  fileData: import_zod_openapi.z.object({
-    base64: import_zod_openapi.z.string().describe("Base64-encoded file data"),
-    mimeType: import_zod_openapi.z.string().describe("The MIME type of the file (e.g., application/pdf)"),
-    filename: import_zod_openapi.z.string().optional().describe("The filename")
-  }).optional().describe("Optional file data to include with the message")
-}).refine(
-  (data) => {
-    const msg = (data.message ?? "").trim();
-    return msg.length > 0 || !!data.imageData || !!data.fileData;
-  },
-  { message: "Must provide either message text, image data, or file data" }
-).describe("Request body for sending a message to the agent");
+  content: import_zod_openapi.z.union([import_zod_openapi.z.string(), import_zod_openapi.z.array(ContentPartSchema)]).describe("Message content - string for text, or ContentPart[] for multimodal"),
+  sessionId: import_zod_openapi.z.string().min(1, "Session ID is required").describe("The session to use for this message")
+}).describe("Request body for sending a message to the agent");
 const ResetBodySchema = import_zod_openapi.z.object({
   sessionId: import_zod_openapi.z.string().min(1, "Session ID is required").describe("The ID of the session to reset")
 }).describe("Request body for resetting a conversation");
@@ -95,8 +96,7 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
               tokenUsage: import_responses.TokenUsageSchema.optional().describe("Token usage statistics"),
               reasoning: import_zod_openapi.z.string().optional().describe("Extended thinking content from reasoning models"),
               model: import_zod_openapi.z.string().optional().describe("Model used for this response"),
-              provider: import_zod_openapi.z.enum(import_core.LLM_PROVIDERS).optional().describe("LLM provider"),
-              router: import_zod_openapi.z.enum(import_core.LLM_ROUTERS).optional().describe("Router used (e.g., vercel)")
+              provider: import_zod_openapi.z.enum(import_core.LLM_PROVIDERS).optional().describe("LLM provider")
             }).strict()
           }
         }
@@ -131,7 +131,7 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
     method: "post",
     path: "/message-stream",
     summary: "Stream message response",
-    description: "Sends a message and streams the response via Server-Sent Events (SSE). Returns SSE stream directly in response. Events include llm:thinking, llm:chunk, llm:tool-call, llm:tool-result, llm:response, and llm:error.",
+    description: "Sends a message and streams the response via Server-Sent Events (SSE). Returns SSE stream directly in response. Events include llm:thinking, llm:chunk, llm:tool-call, llm:tool-result, llm:response, and llm:error. If the session is busy processing another message, returns 202 with queue information.",
     tags: ["messages"],
     request: {
       body: {
@@ -167,23 +167,28 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
           }
         }
       },
+      202: {
+        description: "Session is busy processing another message. Use the queue endpoints to manage pending messages.",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              busy: import_zod_openapi.z.literal(true).describe("Indicates session is busy"),
+              sessionId: import_zod_openapi.z.string().describe("The session ID"),
+              queueLength: import_zod_openapi.z.number().describe("Current number of messages in queue"),
+              hint: import_zod_openapi.z.string().describe("Instructions for the client")
+            }).strict()
+          }
+        }
+      },
       400: { description: "Validation error" }
     }
   });
   return app.openapi(messageRoute, async (ctx) => {
     const agent = getAgent();
     agent.logger.info("Received message via POST /api/message");
-    const { message, sessionId, imageData, fileData } = ctx.req.valid("json");
-    const imageDataInput = imageData ? { image: imageData.base64, mimeType: imageData.mimeType } : void 0;
-    const fileDataInput = fileData ? {
-      data: fileData.base64,
-      mimeType: fileData.mimeType,
-      ...fileData.filename && { filename: fileData.filename }
-    } : void 0;
-    if (imageDataInput) agent.logger.info("Image data included in message.");
-    if (fileDataInput) agent.logger.info("File data included in message.");
+    const { content, sessionId } = ctx.req.valid("json");
     agent.logger.info(`Message for session: ${sessionId}`);
-    agent.run(message || "", imageDataInput, fileDataInput, sessionId, false).catch((error) => {
+    agent.generate(content, sessionId).catch((error) => {
       agent.logger.error(
         `Error in async message processing: ${error instanceof Error ? error.message : String(error)}`
       );
@@ -192,21 +197,9 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
   }).openapi(messageSyncRoute, async (ctx) => {
     const agent = getAgent();
     agent.logger.info("Received message via POST /api/message-sync");
-    const { message, sessionId, imageData, fileData } = ctx.req.valid("json");
-    const imageDataInput = imageData ? { image: imageData.base64, mimeType: imageData.mimeType } : void 0;
-    const fileDataInput = fileData ? {
-      data: fileData.base64,
-      mimeType: fileData.mimeType,
-      ...fileData.filename && { filename: fileData.filename }
-    } : void 0;
-    if (imageDataInput) agent.logger.info("Image data included in message.");
-    if (fileDataInput) agent.logger.info("File data included in message.");
+    const { content, sessionId } = ctx.req.valid("json");
     agent.logger.info(`Message for session: ${sessionId}`);
-    const result = await agent.generate(message || "", {
-      sessionId,
-      imageData: imageDataInput,
-      fileData: fileDataInput
-    });
+    const result = await agent.generate(content, sessionId);
     const llmConfig = agent.stateManager.getLLMConfig(sessionId);
     return ctx.json({
       response: result.content,
@@ -214,9 +207,7 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
       tokenUsage: result.usage,
       reasoning: result.reasoning,
       model: llmConfig.model,
-      provider: llmConfig.provider,
-      router: "vercel"
-      // Hardcoded for now since we only use Vercel AI SDK
+      provider: llmConfig.provider
     });
   }).openapi(resetRoute, async (ctx) => {
     const agent = getAgent();
@@ -226,22 +217,23 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
     return ctx.json({ status: "reset initiated", sessionId });
   }).openapi(messageStreamRoute, async (ctx) => {
     const agent = getAgent();
-    const body = ctx.req.valid("json");
-    const { message = "", sessionId, imageData, fileData } = body;
-    const imageDataInput = imageData ? { image: imageData.base64, mimeType: imageData.mimeType } : void 0;
-    const fileDataInput = fileData ? {
-      data: fileData.base64,
-      mimeType: fileData.mimeType,
-      ...fileData.filename && { filename: fileData.filename }
-    } : void 0;
+    const { content, sessionId } = ctx.req.valid("json");
+    const isBusy = await agent.isSessionBusy(sessionId);
+    if (isBusy) {
+      const queuedMessages = await agent.getQueuedMessages(sessionId);
+      return ctx.json(
+        {
+          busy: true,
+          sessionId,
+          queueLength: queuedMessages.length,
+          hint: "Use POST /api/queue/{sessionId} to queue this message, or wait for the current request to complete."
+        },
+        202
+      );
+    }
     const abortController = new AbortController();
     const { signal } = abortController;
-    const iterator = await agent.stream(message, {
-      sessionId,
-      imageData: imageDataInput,
-      fileData: fileDataInput,
-      signal
-    });
+    const iterator = await agent.stream(content, sessionId, { signal });
     return (0, import_streaming.streamSSE)(ctx, async (stream) => {
       const pendingApprovalEvents = [];
       if (approvalCoordinator) {
@@ -277,7 +269,7 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
               data: JSON.stringify(approvalEvent.data)
             });
           }
-          const eventData = event.type === "llm:error" && event.error instanceof Error ? {
+          const eventData = event.name === "llm:error" && event.error instanceof Error ? {
             ...event,
             error: {
               message: event.error.message,
@@ -286,7 +278,7 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
             }
           } : event;
           await stream.writeSSE({
-            event: event.type,
+            event: event.name,
             data: JSON.stringify(eventData)
           });
         }