@dexto/server 1.4.0 → 1.5.0

package/dist/hono/routes/models.js

@@ -0,0 +1,305 @@
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import { promises as fs } from "fs";
+import {
+  getLocalModelById,
+  listOllamaModels,
+  DEFAULT_OLLAMA_URL,
+  checkOllamaStatus,
+  logger
+} from "@dexto/core";
+import {
+  getAllInstalledModels,
+  getInstalledModel,
+  removeInstalledModel
+} from "@dexto/agent-management";
+const LocalModelSchema = z.object({
+  id: z.string().describe("Model identifier"),
+  displayName: z.string().describe("Human-readable model name"),
+  filePath: z.string().describe("Absolute path to the GGUF file"),
+  sizeBytes: z.number().describe("File size in bytes"),
+  contextLength: z.number().optional().describe("Maximum context length in tokens"),
+  source: z.enum(["huggingface", "manual"]).optional().describe("Where the model was downloaded from")
+}).describe("An installed local GGUF model");
+const OllamaModelSchema = z.object({
+  name: z.string().describe("Ollama model name (e.g., llama3.2:latest)"),
+  size: z.number().optional().describe("Model size in bytes"),
+  digest: z.string().optional().describe("Model digest/hash"),
+  modifiedAt: z.string().optional().describe("Last modified timestamp")
+}).describe("An Ollama model");
+const ValidateFileRequestSchema = z.object({
+  filePath: z.string().min(1).describe("Absolute path to the GGUF file to validate")
+}).describe("File validation request");
+const ValidateFileResponseSchema = z.object({
+  valid: z.boolean().describe("Whether the file exists and is readable"),
+  sizeBytes: z.number().optional().describe("File size in bytes if valid"),
+  error: z.string().optional().describe("Error message if invalid")
+}).describe("File validation response");
+const listLocalModelsRoute = 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: z.object({
+            models: z.array(LocalModelSchema).describe("List of installed local models")
+          })
+        }
+      }
+    }
+  }
+});
+const listOllamaModelsRoute = 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: z.object({
+      baseURL: z.string().url().optional().describe(`Ollama server URL (default: ${DEFAULT_OLLAMA_URL})`)
+    })
+  },
+  responses: {
+    200: {
+      description: "List of Ollama models",
+      content: {
+        "application/json": {
+          schema: z.object({
+            available: z.boolean().describe("Whether Ollama server is running"),
+            version: z.string().optional().describe("Ollama server version"),
+            models: z.array(OllamaModelSchema).describe("List of available Ollama models"),
+            error: z.string().optional().describe("Error message if Ollama not available")
+          })
+        }
+      }
+    }
+  }
+});
+const validateLocalFileRoute = 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 = z.object({
+  deleteFile: z.boolean().default(true).describe("Whether to also delete the GGUF file from disk")
+}).describe("Delete model request options");
+const DeleteModelResponseSchema = z.object({
+  success: z.boolean().describe("Whether the deletion was successful"),
+  modelId: z.string().describe("The deleted model ID"),
+  fileDeleted: z.boolean().describe("Whether the GGUF file was deleted"),
+  error: z.string().optional().describe("Error message if deletion failed")
+}).describe("Delete model response");
+const deleteLocalModelRoute = 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: z.object({
+      modelId: 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 OpenAPIHono();
+  return app.openapi(listLocalModelsRoute, async (ctx) => {
+    const installedModels = await getAllInstalledModels();
+    const models = installedModels.map((model) => {
+      const registryInfo = 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 || DEFAULT_OLLAMA_URL;
+    try {
+      const status = await checkOllamaStatus(ollamaURL);
+      if (!status.running) {
+        return ctx.json({
+          available: false,
+          models: [],
+          error: "Ollama server is not running"
+        });
+      }
+      const ollamaModels = await 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 fs.stat(filePath);
+      if (!stats.isFile()) {
+        return ctx.json({
+          valid: false,
+          error: "Path is not a file"
+        });
+      }
+      await fs.access(filePath, fs.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 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 fs.unlink(filePath);
+        fileDeleted = true;
+      } catch (error) {
+        const nodeError = error;
+        if (nodeError.code === "ENOENT") {
+          fileDeleted = true;
+        } else {
+          logger.warn(
+            `Failed to delete GGUF file ${filePath}: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+    }
+    const removed = await 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
+    });
+  });
+}
+export {
+  createModelsRouter
+};

package/dist/hono/routes/openrouter.cjs

@@ -0,0 +1,153 @@
+"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 openrouter_exports = {};
+__export(openrouter_exports, {
+  createOpenRouterRouter: () => createOpenRouterRouter
+});
+module.exports = __toCommonJS(openrouter_exports);
+var import_zod_openapi = require("@hono/zod-openapi");
+var import_core = require("@dexto/core");
+const ValidateModelParamsSchema = import_zod_openapi.z.object({
+  modelId: import_zod_openapi.z.string().min(1).describe("OpenRouter model ID to validate (e.g., anthropic/claude-3.5-sonnet)")
+}).describe("Path parameters for model validation");
+const ValidateModelResponseSchema = import_zod_openapi.z.object({
+  valid: import_zod_openapi.z.boolean().describe("Whether the model ID is valid"),
+  modelId: import_zod_openapi.z.string().describe("The model ID that was validated"),
+  status: import_zod_openapi.z.enum(["valid", "invalid", "unknown"]).describe("Validation status: valid, invalid, or unknown (cache empty)"),
+  error: import_zod_openapi.z.string().optional().describe("Error message if invalid"),
+  info: import_zod_openapi.z.object({
+    contextLength: import_zod_openapi.z.number().describe("Model context length in tokens")
+  }).optional().describe("Model information if valid")
+}).describe("Model validation response");
+function createOpenRouterRouter() {
+  const app = new import_zod_openapi.OpenAPIHono();
+  const validateRoute = (0, import_zod_openapi.createRoute)({
+    method: "get",
+    path: "/openrouter/validate/{modelId}",
+    summary: "Validate OpenRouter Model",
+    description: "Validates an OpenRouter model ID against the cached model registry. Refreshes cache if stale.",
+    tags: ["openrouter"],
+    request: {
+      params: ValidateModelParamsSchema
+    },
+    responses: {
+      200: {
+        description: "Validation result",
+        content: {
+          "application/json": {
+            schema: ValidateModelResponseSchema
+          }
+        }
+      }
+    }
+  });
+  const refreshRoute = (0, import_zod_openapi.createRoute)({
+    method: "post",
+    path: "/openrouter/refresh-cache",
+    summary: "Refresh OpenRouter Model Cache",
+    description: "Forces a refresh of the OpenRouter model registry cache from the API.",
+    tags: ["openrouter"],
+    responses: {
+      200: {
+        description: "Cache refreshed successfully",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              ok: import_zod_openapi.z.literal(true).describe("Success indicator"),
+              message: import_zod_openapi.z.string().describe("Status message")
+            })
+          }
+        }
+      },
+      500: {
+        description: "Cache refresh failed",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              ok: import_zod_openapi.z.literal(false).describe("Failure indicator"),
+              message: import_zod_openapi.z.string().describe("Error message")
+            })
+          }
+        }
+      }
+    }
+  });
+  return app.openapi(validateRoute, async (ctx) => {
+    const { modelId: encodedModelId } = ctx.req.valid("param");
+    const modelId = decodeURIComponent(encodedModelId);
+    let status = (0, import_core.lookupOpenRouterModel)(modelId);
+    if (status === "unknown") {
+      try {
+        await (0, import_core.refreshOpenRouterModelCache)();
+        status = (0, import_core.lookupOpenRouterModel)(modelId);
+      } catch (error) {
+        import_core.logger.warn(
+          `OpenRouter cache refresh failed during validation: ${error instanceof Error ? error.message : String(error)}`
+        );
+        return ctx.json({
+          valid: false,
+          modelId,
+          status: "unknown",
+          error: "Could not validate model - cache refresh failed"
+        });
+      }
+    }
+    if (status === "invalid") {
+      return ctx.json({
+        valid: false,
+        modelId,
+        status: "invalid",
+        error: `Model '${modelId}' not found in OpenRouter. Check the model ID at https://openrouter.ai/models`
+      });
+    }
+    const info = (0, import_core.getOpenRouterModelInfo)(modelId);
+    return ctx.json({
+      valid: true,
+      modelId,
+      status: "valid",
+      ...info && { info: { contextLength: info.contextLength } }
+    });
+  }).openapi(refreshRoute, async (ctx) => {
+    try {
+      await (0, import_core.refreshOpenRouterModelCache)();
+      return ctx.json(
+        {
+          ok: true,
+          message: "OpenRouter model cache refreshed successfully"
+        },
+        200
+      );
+    } catch (error) {
+      import_core.logger.error(
+        `Failed to refresh OpenRouter cache: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return ctx.json(
+        {
+          ok: false,
+          message: "Failed to refresh OpenRouter model cache"
+        },
+        500
+      );
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createOpenRouterRouter
+});

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

@@ -0,0 +1,54 @@
+/**
+ * OpenRouter Validation Routes
+ *
+ * Standalone routes for validating OpenRouter model IDs against the registry.
+ * Decoupled from agent runtime - can be used independently.
+ */
+import { OpenAPIHono } from '@hono/zod-openapi';
+/**
+ * Create OpenRouter validation router.
+ * No agent dependency - purely utility routes.
+ */
+export declare function createOpenRouterRouter(): OpenAPIHono<import("hono").Env, {
+    "/openrouter/validate/:modelId": {
+        $get: {
+            input: {
+                param: {
+                    modelId: string;
+                };
+            };
+            output: {
+                valid: boolean;
+                status: "valid" | "unknown" | "invalid";
+                modelId: string;
+                error?: string | undefined;
+                info?: {
+                    contextLength: number;
+                } | undefined;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/openrouter/refresh-cache": {
+        $post: {
+            input: {};
+            output: {
+                message: string;
+                ok: true;
+            };
+            outputFormat: "json";
+            status: 200;
+        } | {
+            input: {};
+            output: {
+                message: string;
+                ok: false;
+            };
+            outputFormat: "json";
+            status: 500;
+        };
+    };
+}, "/">;
+//# sourceMappingURL=openrouter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"openrouter.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/openrouter.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAkChE;;;GAGG;AACH,wBAAgB,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA8HrC"}

package/dist/hono/routes/openrouter.js

@@ -0,0 +1,134 @@
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import {
+  logger,
+  lookupOpenRouterModel,
+  refreshOpenRouterModelCache,
+  getOpenRouterModelInfo
+} from "@dexto/core";
+const ValidateModelParamsSchema = z.object({
+  modelId: z.string().min(1).describe("OpenRouter model ID to validate (e.g., anthropic/claude-3.5-sonnet)")
+}).describe("Path parameters for model validation");
+const ValidateModelResponseSchema = z.object({
+  valid: z.boolean().describe("Whether the model ID is valid"),
+  modelId: z.string().describe("The model ID that was validated"),
+  status: z.enum(["valid", "invalid", "unknown"]).describe("Validation status: valid, invalid, or unknown (cache empty)"),
+  error: z.string().optional().describe("Error message if invalid"),
+  info: z.object({
+    contextLength: z.number().describe("Model context length in tokens")
+  }).optional().describe("Model information if valid")
+}).describe("Model validation response");
+function createOpenRouterRouter() {
+  const app = new OpenAPIHono();
+  const validateRoute = createRoute({
+    method: "get",
+    path: "/openrouter/validate/{modelId}",
+    summary: "Validate OpenRouter Model",
+    description: "Validates an OpenRouter model ID against the cached model registry. Refreshes cache if stale.",
+    tags: ["openrouter"],
+    request: {
+      params: ValidateModelParamsSchema
+    },
+    responses: {
+      200: {
+        description: "Validation result",
+        content: {
+          "application/json": {
+            schema: ValidateModelResponseSchema
+          }
+        }
+      }
+    }
+  });
+  const refreshRoute = createRoute({
+    method: "post",
+    path: "/openrouter/refresh-cache",
+    summary: "Refresh OpenRouter Model Cache",
+    description: "Forces a refresh of the OpenRouter model registry cache from the API.",
+    tags: ["openrouter"],
+    responses: {
+      200: {
+        description: "Cache refreshed successfully",
+        content: {
+          "application/json": {
+            schema: z.object({
+              ok: z.literal(true).describe("Success indicator"),
+              message: z.string().describe("Status message")
+            })
+          }
+        }
+      },
+      500: {
+        description: "Cache refresh failed",
+        content: {
+          "application/json": {
+            schema: z.object({
+              ok: z.literal(false).describe("Failure indicator"),
+              message: z.string().describe("Error message")
+            })
+          }
+        }
+      }
+    }
+  });
+  return app.openapi(validateRoute, async (ctx) => {
+    const { modelId: encodedModelId } = ctx.req.valid("param");
+    const modelId = decodeURIComponent(encodedModelId);
+    let status = lookupOpenRouterModel(modelId);
+    if (status === "unknown") {
+      try {
+        await refreshOpenRouterModelCache();
+        status = lookupOpenRouterModel(modelId);
+      } catch (error) {
+        logger.warn(
+          `OpenRouter cache refresh failed during validation: ${error instanceof Error ? error.message : String(error)}`
+        );
+        return ctx.json({
+          valid: false,
+          modelId,
+          status: "unknown",
+          error: "Could not validate model - cache refresh failed"
+        });
+      }
+    }
+    if (status === "invalid") {
+      return ctx.json({
+        valid: false,
+        modelId,
+        status: "invalid",
+        error: `Model '${modelId}' not found in OpenRouter. Check the model ID at https://openrouter.ai/models`
+      });
+    }
+    const info = getOpenRouterModelInfo(modelId);
+    return ctx.json({
+      valid: true,
+      modelId,
+      status: "valid",
+      ...info && { info: { contextLength: info.contextLength } }
+    });
+  }).openapi(refreshRoute, async (ctx) => {
+    try {
+      await refreshOpenRouterModelCache();
+      return ctx.json(
+        {
+          ok: true,
+          message: "OpenRouter model cache refreshed successfully"
+        },
+        200
+      );
+    } catch (error) {
+      logger.error(
+        `Failed to refresh OpenRouter cache: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return ctx.json(
+        {
+          ok: false,
+          message: "Failed to refresh OpenRouter model cache"
+        },
+        500
+      );
+    }
+  });
+}
+export {
+  createOpenRouterRouter
+};

package/dist/hono/routes/prompts.cjs

@@ -162,12 +162,12 @@ function createPromptsRouter(getAgent) {
     }
   });
   return app.openapi(listRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const prompts = await agent.listPrompts();
     const list = Object.values(prompts);
     return ctx.json({ prompts: list });
   }).openapi(createCustomRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const payload = ctx.req.valid("json");
     const promptArguments = payload.arguments?.map((arg) => ({
       name: arg.name,
@@ -191,18 +191,18 @@ function createPromptsRouter(getAgent) {
     const prompt = await agent.createCustomPrompt(createPayload);
     return ctx.json({ prompt }, 201);
   }).openapi(deleteCustomRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { name } = ctx.req.valid("param");
     await agent.deleteCustomPrompt(name);
     return ctx.body(null, 204);
   }).openapi(getPromptRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { name } = ctx.req.valid("param");
     const definition = await agent.getPromptDefinition(name);
     if (!definition) throw import_core.PromptError.notFound(name);
     return ctx.json({ definition });
   }).openapi(resolvePromptRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { name } = ctx.req.valid("param");
     const { context, args: argsString } = ctx.req.valid("query");
     let parsedArgs;