@dexto/server 1.4.0 → 1.5.1

package/dist/hono/routes/memory.js

@@ -127,7 +127,7 @@ function createMemoryRouter(getAgent) {
     if (input.metadata !== void 0) {
       createInput.metadata = input.metadata;
     }
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const memory = await agent.memoryManager.create(createInput);
     return ctx.json({ ok: true, memory }, 201);
   }).openapi(listRoute, async (ctx) => {
@@ -138,12 +138,12 @@ function createMemoryRouter(getAgent) {
     if (query.pinned !== void 0) options.pinned = query.pinned;
     if (query.limit !== void 0) options.limit = query.limit;
     if (query.offset !== void 0) options.offset = query.offset;
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const memories = await agent.memoryManager.list(options);
     return ctx.json({ ok: true, memories });
   }).openapi(getRoute, async (ctx) => {
     const { id } = ctx.req.valid("param");
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const memory = await agent.memoryManager.get(id);
     return ctx.json({ ok: true, memory });
   }).openapi(updateRoute, async (ctx) => {
@@ -153,12 +153,12 @@ function createMemoryRouter(getAgent) {
     if (updatesRaw.content !== void 0) updates.content = updatesRaw.content;
     if (updatesRaw.metadata !== void 0) updates.metadata = updatesRaw.metadata;
     if (updatesRaw.tags !== void 0) updates.tags = updatesRaw.tags;
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const memory = await agent.memoryManager.update(id, updates);
     return ctx.json({ ok: true, memory });
   }).openapi(deleteRoute, async (ctx) => {
     const { id } = ctx.req.valid("param");
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     await agent.memoryManager.delete(id);
     return ctx.json({ ok: true, message: "Memory deleted successfully" });
   });

package/dist/hono/routes/messages.cjs

@@ -184,7 +184,7 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
     }
   });
   return app.openapi(messageRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     agent.logger.info("Received message via POST /api/message");
     const { content, sessionId } = ctx.req.valid("json");
     agent.logger.info(`Message for session: ${sessionId}`);
@@ -195,7 +195,7 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
     });
     return ctx.json({ accepted: true, sessionId }, 202);
   }).openapi(messageSyncRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     agent.logger.info("Received message via POST /api/message-sync");
     const { content, sessionId } = ctx.req.valid("json");
     agent.logger.info(`Message for session: ${sessionId}`);
@@ -210,13 +210,13 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
       provider: llmConfig.provider
     });
   }).openapi(resetRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     agent.logger.info("Received request via POST /api/reset");
     const { sessionId } = ctx.req.valid("json");
     await agent.resetConversation(sessionId);
     return ctx.json({ status: "reset initiated", sessionId });
   }).openapi(messageStreamRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { content, sessionId } = ctx.req.valid("json");
     const isBusy = await agent.isSessionBusy(sessionId);
     if (isBusy) {

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

@@ -1,7 +1,7 @@
 import { OpenAPIHono } from '@hono/zod-openapi';
-import type { DextoAgent } from '@dexto/core';
 import type { ApprovalCoordinator } from '../../approval/approval-coordinator.js';
-export declare function createMessagesRouter(getAgent: () => DextoAgent, approvalCoordinator?: ApprovalCoordinator): OpenAPIHono<import("hono").Env, {
+import type { GetAgentFn } from '../index.js';
+export declare function createMessagesRouter(getAgent: GetAgentFn, approvalCoordinator?: ApprovalCoordinator): OpenAPIHono<import("hono").Env, {
     "/message": {
         $post: {
             input: {
@@ -22,12 +22,9 @@ export declare function createMessagesRouter(getAgent: () => DextoAgent, approva
                     sessionId: string;
                 };
             };
-            output: {
-                sessionId: string;
-                accepted: true;
-            };
-            outputFormat: "json";
-            status: 202;
+            output: {};
+            outputFormat: string;
+            status: 400;
         } | {
             input: {
                 json: {
@@ -47,9 +44,12 @@ export declare function createMessagesRouter(getAgent: () => DextoAgent, approva
                     sessionId: string;
                 };
             };
-            output: {};
-            outputFormat: string;
-            status: 400;
+            output: {
+                sessionId: string;
+                accepted: true;
+            };
+            outputFormat: "json";
+            status: 202;
         };
     };
 } & {
@@ -106,7 +106,7 @@ export declare function createMessagesRouter(getAgent: () => DextoAgent, approva
                     totalTokens?: number | undefined;
                 } | undefined;
                 model?: string | undefined;
-                provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
+                provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | undefined;
             };
             outputFormat: "json";
             status: 200;

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

@@ -1 +1 @@
-{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/messages.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAEhE,OAAO,KAAK,EAAE,UAAU,EAAgB,MAAM,aAAa,CAAC;AAE5D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AA2DlF,wBAAgB,oBAAoB,CAChC,QAAQ,EAAE,MAAM,UAAU,EAC1B,mBAAmB,CAAC,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA0U5C"}
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/messages.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAIhE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAElF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AA0D9C,wBAAgB,oBAAoB,CAChC,QAAQ,EAAE,UAAU,EACpB,mBAAmB,CAAC,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA0U5C"}

package/dist/hono/routes/messages.js

@@ -161,7 +161,7 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
     }
   });
   return app.openapi(messageRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     agent.logger.info("Received message via POST /api/message");
     const { content, sessionId } = ctx.req.valid("json");
     agent.logger.info(`Message for session: ${sessionId}`);
@@ -172,7 +172,7 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
     });
     return ctx.json({ accepted: true, sessionId }, 202);
   }).openapi(messageSyncRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     agent.logger.info("Received message via POST /api/message-sync");
     const { content, sessionId } = ctx.req.valid("json");
     agent.logger.info(`Message for session: ${sessionId}`);
@@ -187,13 +187,13 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
       provider: llmConfig.provider
     });
   }).openapi(resetRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     agent.logger.info("Received request via POST /api/reset");
     const { sessionId } = ctx.req.valid("json");
     await agent.resetConversation(sessionId);
     return ctx.json({ status: "reset initiated", sessionId });
   }).openapi(messageStreamRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { content, sessionId } = ctx.req.valid("json");
     const isBusy = await agent.isSessionBusy(sessionId);
     if (isBusy) {

package/dist/hono/routes/models.cjs

@@ -0,0 +1,319 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var models_exports = {};
+__export(models_exports, {
+  createModelsRouter: () => createModelsRouter
+});
+module.exports = __toCommonJS(models_exports);
+var import_zod_openapi = require("@hono/zod-openapi");
+var import_fs = require("fs");
+var import_core = require("@dexto/core");
+var import_agent_management = require("@dexto/agent-management");
+const LocalModelSchema = import_zod_openapi.z.object({
+  id: import_zod_openapi.z.string().describe("Model identifier"),
+  displayName: import_zod_openapi.z.string().describe("Human-readable model name"),
+  filePath: import_zod_openapi.z.string().describe("Absolute path to the GGUF file"),
+  sizeBytes: import_zod_openapi.z.number().describe("File size in bytes"),
+  contextLength: import_zod_openapi.z.number().optional().describe("Maximum context length in tokens"),
+  source: import_zod_openapi.z.enum(["huggingface", "manual"]).optional().describe("Where the model was downloaded from")
+}).describe("An installed local GGUF model");
+const OllamaModelSchema = import_zod_openapi.z.object({
+  name: import_zod_openapi.z.string().describe("Ollama model name (e.g., llama3.2:latest)"),
+  size: import_zod_openapi.z.number().optional().describe("Model size in bytes"),
+  digest: import_zod_openapi.z.string().optional().describe("Model digest/hash"),
+  modifiedAt: import_zod_openapi.z.string().optional().describe("Last modified timestamp")
+}).describe("An Ollama model");
+const ValidateFileRequestSchema = import_zod_openapi.z.object({
+  filePath: import_zod_openapi.z.string().min(1).describe("Absolute path to the GGUF file to validate")
+}).describe("File validation request");
+const ValidateFileResponseSchema = import_zod_openapi.z.object({
+  valid: import_zod_openapi.z.boolean().describe("Whether the file exists and is readable"),
+  sizeBytes: import_zod_openapi.z.number().optional().describe("File size in bytes if valid"),
+  error: import_zod_openapi.z.string().optional().describe("Error message if invalid")
+}).describe("File validation response");
+const listLocalModelsRoute = (0, import_zod_openapi.createRoute)({
+  method: "get",
+  path: "/models/local",
+  summary: "List Local Models",
+  description: "Returns all installed local GGUF models from ~/.dexto/models/state.json. These are models downloaded from HuggingFace or manually registered.",
+  tags: ["models"],
+  responses: {
+    200: {
+      description: "List of installed local models",
+      content: {
+        "application/json": {
+          schema: import_zod_openapi.z.object({
+            models: import_zod_openapi.z.array(LocalModelSchema).describe("List of installed local models")
+          })
+        }
+      }
+    }
+  }
+});
+const listOllamaModelsRoute = (0, import_zod_openapi.createRoute)({
+  method: "get",
+  path: "/models/ollama",
+  summary: "List Ollama Models",
+  description: "Returns available models from the local Ollama server. Returns empty list with available=false if Ollama is not running.",
+  tags: ["models"],
+  request: {
+    query: import_zod_openapi.z.object({
+      baseURL: import_zod_openapi.z.string().url().optional().describe(`Ollama server URL (default: ${import_core.DEFAULT_OLLAMA_URL})`)
+    })
+  },
+  responses: {
+    200: {
+      description: "List of Ollama models",
+      content: {
+        "application/json": {
+          schema: import_zod_openapi.z.object({
+            available: import_zod_openapi.z.boolean().describe("Whether Ollama server is running"),
+            version: import_zod_openapi.z.string().optional().describe("Ollama server version"),
+            models: import_zod_openapi.z.array(OllamaModelSchema).describe("List of available Ollama models"),
+            error: import_zod_openapi.z.string().optional().describe("Error message if Ollama not available")
+          })
+        }
+      }
+    }
+  }
+});
+const validateLocalFileRoute = (0, import_zod_openapi.createRoute)({
+  method: "post",
+  path: "/models/local/validate",
+  summary: "Validate GGUF File",
+  description: "Validates that a GGUF file exists and is readable. Used by Web UI to validate custom file paths before saving.",
+  tags: ["models"],
+  request: {
+    body: {
+      content: {
+        "application/json": {
+          schema: ValidateFileRequestSchema
+        }
+      }
+    }
+  },
+  responses: {
+    200: {
+      description: "Validation result",
+      content: {
+        "application/json": {
+          schema: ValidateFileResponseSchema
+        }
+      }
+    }
+  }
+});
+const DeleteModelRequestSchema = import_zod_openapi.z.object({
+  deleteFile: import_zod_openapi.z.boolean().default(true).describe("Whether to also delete the GGUF file from disk")
+}).describe("Delete model request options");
+const DeleteModelResponseSchema = import_zod_openapi.z.object({
+  success: import_zod_openapi.z.boolean().describe("Whether the deletion was successful"),
+  modelId: import_zod_openapi.z.string().describe("The deleted model ID"),
+  fileDeleted: import_zod_openapi.z.boolean().describe("Whether the GGUF file was deleted"),
+  error: import_zod_openapi.z.string().optional().describe("Error message if deletion failed")
+}).describe("Delete model response");
+const deleteLocalModelRoute = (0, import_zod_openapi.createRoute)({
+  method: "delete",
+  path: "/models/local/{modelId}",
+  summary: "Delete Installed Model",
+  description: "Removes an installed local model from state.json. Optionally deletes the GGUF file from disk (default: true).",
+  tags: ["models"],
+  request: {
+    params: import_zod_openapi.z.object({
+      modelId: import_zod_openapi.z.string().describe("The model ID to delete")
+    }),
+    body: {
+      content: {
+        "application/json": {
+          schema: DeleteModelRequestSchema
+        }
+      },
+      required: false
+    }
+  },
+  responses: {
+    200: {
+      description: "Model deleted successfully",
+      content: {
+        "application/json": {
+          schema: DeleteModelResponseSchema
+        }
+      }
+    },
+    404: {
+      description: "Model not found",
+      content: {
+        "application/json": {
+          schema: DeleteModelResponseSchema
+        }
+      }
+    }
+  }
+});
+function createModelsRouter() {
+  const app = new import_zod_openapi.OpenAPIHono();
+  return app.openapi(listLocalModelsRoute, async (ctx) => {
+    const installedModels = await (0, import_agent_management.getAllInstalledModels)();
+    const models = installedModels.map((model) => {
+      const registryInfo = (0, import_core.getLocalModelById)(model.id);
+      return {
+        id: model.id,
+        displayName: registryInfo?.name || model.id,
+        filePath: model.filePath,
+        sizeBytes: model.sizeBytes,
+        contextLength: registryInfo?.contextLength,
+        source: model.source
+      };
+    });
+    return ctx.json({ models });
+  }).openapi(listOllamaModelsRoute, async (ctx) => {
+    const { baseURL } = ctx.req.valid("query");
+    const ollamaURL = baseURL || import_core.DEFAULT_OLLAMA_URL;
+    try {
+      const status = await (0, import_core.checkOllamaStatus)(ollamaURL);
+      if (!status.running) {
+        return ctx.json({
+          available: false,
+          models: [],
+          error: "Ollama server is not running"
+        });
+      }
+      const ollamaModels = await (0, import_core.listOllamaModels)(ollamaURL);
+      return ctx.json({
+        available: true,
+        version: status.version,
+        models: ollamaModels.map((m) => ({
+          name: m.name,
+          size: m.size,
+          digest: m.digest,
+          modifiedAt: m.modifiedAt
+        }))
+      });
+    } catch (error) {
+      return ctx.json({
+        available: false,
+        models: [],
+        error: error instanceof Error ? error.message : "Failed to connect to Ollama server"
+      });
+    }
+  }).openapi(validateLocalFileRoute, async (ctx) => {
+    const { filePath } = ctx.req.valid("json");
+    if (!filePath.startsWith("/")) {
+      return ctx.json({
+        valid: false,
+        error: "File path must be absolute (start with /)"
+      });
+    }
+    if (!filePath.endsWith(".gguf")) {
+      return ctx.json({
+        valid: false,
+        error: "File must have .gguf extension"
+      });
+    }
+    try {
+      const stats = await import_fs.promises.stat(filePath);
+      if (!stats.isFile()) {
+        return ctx.json({
+          valid: false,
+          error: "Path is not a file"
+        });
+      }
+      await import_fs.promises.access(filePath, import_fs.promises.constants.R_OK);
+      return ctx.json({
+        valid: true,
+        sizeBytes: stats.size
+      });
+    } catch (error) {
+      const nodeError = error;
+      if (nodeError.code === "ENOENT") {
+        return ctx.json({
+          valid: false,
+          error: "File not found"
+        });
+      }
+      if (nodeError.code === "EACCES") {
+        return ctx.json({
+          valid: false,
+          error: "File is not readable (permission denied)"
+        });
+      }
+      return ctx.json({
+        valid: false,
+        error: error instanceof Error ? error.message : "Failed to access file"
+      });
+    }
+  }).openapi(deleteLocalModelRoute, async (ctx) => {
+    const { modelId } = ctx.req.valid("param");
+    let deleteFile = true;
+    try {
+      const body = await ctx.req.json();
+      if (body && typeof body.deleteFile === "boolean") {
+        deleteFile = body.deleteFile;
+      }
+    } catch {
+    }
+    const model = await (0, import_agent_management.getInstalledModel)(modelId);
+    if (!model) {
+      return ctx.json(
+        {
+          success: false,
+          modelId,
+          fileDeleted: false,
+          error: `Model '${modelId}' not found`
+        },
+        404
+      );
+    }
+    const filePath = model.filePath;
+    let fileDeleted = false;
+    if (deleteFile && filePath) {
+      try {
+        await import_fs.promises.unlink(filePath);
+        fileDeleted = true;
+      } catch (error) {
+        const nodeError = error;
+        if (nodeError.code === "ENOENT") {
+          fileDeleted = true;
+        } else {
+          import_core.logger.warn(
+            `Failed to delete GGUF file ${filePath}: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+    }
+    const removed = await (0, import_agent_management.removeInstalledModel)(modelId);
+    if (!removed) {
+      return ctx.json({
+        success: false,
+        modelId,
+        fileDeleted,
+        error: "Failed to remove model from state"
+      });
+    }
+    return ctx.json({
+      success: true,
+      modelId,
+      fileDeleted
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createModelsRouter
+});

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

@@ -0,0 +1,107 @@
+/**
+ * Models Routes
+ *
+ * API endpoints for listing and managing local/ollama models.
+ * These endpoints expose model discovery that CLI does directly via function calls.
+ */
+import { OpenAPIHono } from '@hono/zod-openapi';
+export declare function createModelsRouter(): OpenAPIHono<import("hono").Env, {
+    "/models/local": {
+        $get: {
+            input: {};
+            output: {
+                models: {
+                    id: string;
+                    displayName: string;
+                    filePath: string;
+                    sizeBytes: number;
+                    source?: "manual" | "huggingface" | undefined;
+                    contextLength?: number | undefined;
+                }[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/models/ollama": {
+        $get: {
+            input: {
+                query: {
+                    baseURL?: string | undefined;
+                };
+            };
+            output: {
+                models: {
+                    name: string;
+                    size?: number | undefined;
+                    digest?: string | undefined;
+                    modifiedAt?: string | undefined;
+                }[];
+                available: boolean;
+                error?: string | undefined;
+                version?: string | undefined;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/models/local/validate": {
+        $post: {
+            input: {
+                json: {
+                    filePath: string;
+                };
+            };
+            output: {
+                valid: boolean;
+                error?: string | undefined;
+                sizeBytes?: number | undefined;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/models/local/:modelId": {
+        $delete: {
+            input: {
+                param: {
+                    modelId: string;
+                };
+            } & {
+                json: {
+                    deleteFile?: boolean | undefined;
+                };
+            };
+            output: {
+                success: boolean;
+                modelId: string;
+                fileDeleted: boolean;
+                error?: string | undefined;
+            };
+            outputFormat: "json";
+            status: 200;
+        } | {
+            input: {
+                param: {
+                    modelId: string;
+                };
+            } & {
+                json: {
+                    deleteFile?: boolean | undefined;
+                };
+            };
+            output: {
+                success: boolean;
+                modelId: string;
+                fileDeleted: boolean;
+                error?: string | undefined;
+            };
+            outputFormat: "json";
+            status: 404;
+        };
+    };
+}, "/">;
+//# sourceMappingURL=models.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/models.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAuNhE,wBAAgB,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA8LjC"}