@dexto/server 1.2.5

package/dist/hono/routes/prompts.js

@@ -0,0 +1,204 @@
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import { PromptError } from "@dexto/core";
+import { PromptInfoSchema, PromptDefinitionSchema } from "../schemas/responses.js";
+const CustomPromptRequestSchema = z.object({
+  name: z.string().min(1, "Prompt name is required").describe("Unique name for the custom prompt"),
+  title: z.string().optional().describe("Display title for the prompt"),
+  description: z.string().optional().describe("Description of what the prompt does"),
+  content: z.string().min(1, "Prompt content is required").describe("The prompt content text (can include {{argumentName}} placeholders)"),
+  arguments: z.array(
+    z.object({
+      name: z.string().min(1, "Argument name is required").describe("Argument name"),
+      description: z.string().optional().describe("Argument description"),
+      required: z.boolean().optional().describe("Whether the argument is required")
+    }).strict()
+  ).optional().describe("Array of argument definitions"),
+  resource: z.object({
+    base64: z.string().min(1, "Resource data is required").describe("Base64-encoded resource data"),
+    mimeType: z.string().min(1, "Resource MIME type is required").describe("MIME type of the resource (e.g., text/plain, application/pdf)"),
+    filename: z.string().optional().describe("Resource filename")
+  }).strict().optional().describe("Attach a resource to this prompt")
+}).strict().describe("Request body for creating a custom prompt with optional resource attachment");
+const PromptNameParamSchema = z.object({
+  name: z.string().min(1, "Prompt name is required").describe("The prompt name")
+}).describe("Path parameters for prompt endpoints");
+const ResolvePromptQuerySchema = z.object({
+  context: z.string().optional().describe("Additional context for prompt resolution"),
+  args: z.string().optional().describe("Arguments to substitute in the prompt template (pass as a JSON string)")
+}).describe("Query parameters for resolving prompt templates");
+function createPromptsRouter(getAgent) {
+  const app = new OpenAPIHono();
+  const listRoute = createRoute({
+    method: "get",
+    path: "/prompts",
+    summary: "List Prompts",
+    description: "Retrieves all available prompts, including both built-in and custom prompts",
+    tags: ["prompts"],
+    responses: {
+      200: {
+        description: "List all prompts",
+        content: {
+          "application/json": {
+            schema: z.object({
+              prompts: z.array(PromptInfoSchema).describe("Array of available prompts")
+            }).strict().describe("Prompts list response")
+          }
+        }
+      }
+    }
+  });
+  const createCustomRoute = createRoute({
+    method: "post",
+    path: "/prompts/custom",
+    summary: "Create Custom Prompt",
+    description: "Creates a new custom prompt with optional resource attachment. Maximum request size: 10MB",
+    tags: ["prompts"],
+    request: {
+      body: {
+        content: {
+          "application/json": {
+            schema: CustomPromptRequestSchema
+          }
+        }
+      }
+    },
+    responses: {
+      201: {
+        description: "Custom prompt created",
+        content: {
+          "application/json": {
+            schema: z.object({
+              prompt: PromptInfoSchema.describe("Created prompt information")
+            }).strict().describe("Create prompt response")
+          }
+        }
+      }
+    }
+  });
+  const deleteCustomRoute = createRoute({
+    method: "delete",
+    path: "/prompts/custom/{name}",
+    summary: "Delete Custom Prompt",
+    description: "Permanently deletes a custom prompt. Built-in prompts cannot be deleted",
+    tags: ["prompts"],
+    request: {
+      params: z.object({
+        name: z.string().min(1, "Prompt name is required").describe("The prompt name")
+      })
+    },
+    responses: {
+      204: { description: "Prompt deleted" }
+    }
+  });
+  const getPromptRoute = createRoute({
+    method: "get",
+    path: "/prompts/{name}",
+    summary: "Get Prompt Definition",
+    description: "Fetches the definition for a specific prompt",
+    tags: ["prompts"],
+    request: {
+      params: PromptNameParamSchema
+    },
+    responses: {
+      200: {
+        description: "Prompt definition",
+        content: {
+          "application/json": {
+            schema: z.object({
+              definition: PromptDefinitionSchema.describe("Prompt definition")
+            }).strict().describe("Get prompt definition response")
+          }
+        }
+      },
+      404: { description: "Prompt not found" }
+    }
+  });
+  const resolvePromptRoute = createRoute({
+    method: "get",
+    path: "/prompts/{name}/resolve",
+    summary: "Resolve Prompt",
+    description: "Resolves a prompt template with provided arguments and returns the final text with resources",
+    tags: ["prompts"],
+    request: {
+      params: PromptNameParamSchema,
+      query: ResolvePromptQuerySchema
+    },
+    responses: {
+      200: {
+        description: "Resolved prompt content",
+        content: {
+          "application/json": {
+            schema: z.object({
+              text: z.string().describe("Resolved prompt text"),
+              resources: z.array(z.string()).describe("Array of resource identifiers")
+            }).strict().describe("Resolve prompt response")
+          }
+        }
+      },
+      404: { description: "Prompt not found" }
+    }
+  });
+  return app.openapi(listRoute, async (ctx) => {
+    const agent = getAgent();
+    const prompts = await agent.listPrompts();
+    const list = Object.values(prompts);
+    return ctx.json({ prompts: list });
+  }).openapi(createCustomRoute, async (ctx) => {
+    const agent = getAgent();
+    const payload = ctx.req.valid("json");
+    const promptArguments = payload.arguments?.map((arg) => ({
+      name: arg.name,
+      ...arg.description ? { description: arg.description } : {},
+      ...typeof arg.required === "boolean" ? { required: arg.required } : {}
+    })).filter(Boolean);
+    const createPayload = {
+      name: payload.name,
+      content: payload.content,
+      ...payload.title ? { title: payload.title } : {},
+      ...payload.description ? { description: payload.description } : {},
+      ...promptArguments && promptArguments.length > 0 ? { arguments: promptArguments } : {},
+      ...payload.resource ? {
+        resource: {
+          base64: payload.resource.base64,
+          mimeType: payload.resource.mimeType,
+          ...payload.resource.filename ? { filename: payload.resource.filename } : {}
+        }
+      } : {}
+    };
+    const prompt = await agent.createCustomPrompt(createPayload);
+    return ctx.json({ prompt }, 201);
+  }).openapi(deleteCustomRoute, async (ctx) => {
+    const agent = getAgent();
+    const { name } = ctx.req.valid("param");
+    await agent.deleteCustomPrompt(name);
+    return ctx.body(null, 204);
+  }).openapi(getPromptRoute, async (ctx) => {
+    const agent = getAgent();
+    const { name } = ctx.req.valid("param");
+    const definition = await agent.getPromptDefinition(name);
+    if (!definition) throw PromptError.notFound(name);
+    return ctx.json({ definition });
+  }).openapi(resolvePromptRoute, async (ctx) => {
+    const agent = getAgent();
+    const { name } = ctx.req.valid("param");
+    const { context, args: argsString } = ctx.req.valid("query");
+    let parsedArgs;
+    if (argsString) {
+      try {
+        const parsed = JSON.parse(argsString);
+        if (parsed && typeof parsed === "object") {
+          parsedArgs = parsed;
+        }
+      } catch {
+      }
+    }
+    const options = {};
+    if (context !== void 0) options.context = context;
+    if (parsedArgs !== void 0) options.args = parsedArgs;
+    const result = await agent.resolvePrompt(name, options);
+    return ctx.json({ text: result.text, resources: result.resources });
+  });
+}
+export {
+  createPromptsRouter
+};

package/dist/hono/routes/resources.cjs

@@ -0,0 +1,110 @@
+"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 resources_exports = {};
+__export(resources_exports, {
+  createResourcesRouter: () => createResourcesRouter
+});
+module.exports = __toCommonJS(resources_exports);
+var import_zod_openapi = require("@hono/zod-openapi");
+var import_responses = require("../schemas/responses.js");
+const ResourceIdParamSchema = import_zod_openapi.z.object({
+  resourceId: import_zod_openapi.z.string().min(1, "Resource ID is required").transform((encoded) => decodeURIComponent(encoded)).describe("The URI-encoded resource identifier")
+}).describe("Path parameters for resource endpoints");
+const ListResourcesResponseSchema = import_zod_openapi.z.object({
+  ok: import_zod_openapi.z.literal(true).describe("Indicates successful response"),
+  resources: import_zod_openapi.z.array(import_responses.ResourceSchema).describe("Array of all available resources from all sources")
+}).strict().describe("List of all resources");
+const ResourceContentItemSchema = import_zod_openapi.z.object({
+  uri: import_zod_openapi.z.string().describe("Resource URI"),
+  mimeType: import_zod_openapi.z.string().optional().describe("MIME type of the content"),
+  text: import_zod_openapi.z.string().optional().describe("Text content (for text resources)"),
+  blob: import_zod_openapi.z.string().optional().describe("Base64-encoded binary content (for binary resources)")
+}).strict().describe("Resource content item");
+const ReadResourceResponseSchema = import_zod_openapi.z.object({
+  ok: import_zod_openapi.z.literal(true).describe("Indicates successful response"),
+  content: import_zod_openapi.z.object({
+    contents: import_zod_openapi.z.array(ResourceContentItemSchema).describe("Array of content items (typically one item)"),
+    _meta: import_zod_openapi.z.record(import_zod_openapi.z.any()).optional().describe("Optional metadata about the resource")
+  }).strict().describe("Resource content from MCP ReadResourceResult")
+}).strict().describe("Resource content response");
+function createResourcesRouter(getAgent) {
+  const app = new import_zod_openapi.OpenAPIHono();
+  const listRoute = (0, import_zod_openapi.createRoute)({
+    method: "get",
+    path: "/resources",
+    summary: "List All Resources",
+    description: "Retrieves a list of all available resources from all sources (MCP servers and internal providers)",
+    tags: ["resources"],
+    responses: {
+      200: {
+        description: "List all resources",
+        content: { "application/json": { schema: ListResourcesResponseSchema } }
+      }
+    }
+  });
+  const getContentRoute = (0, import_zod_openapi.createRoute)({
+    method: "get",
+    path: "/resources/{resourceId}/content",
+    summary: "Read Resource Content",
+    description: "Reads the content of a specific resource by its URI. The resource ID in the URL must be URI-encoded",
+    tags: ["resources"],
+    request: {
+      params: ResourceIdParamSchema
+    },
+    responses: {
+      200: {
+        description: "Resource content",
+        content: { "application/json": { schema: ReadResourceResponseSchema } }
+      }
+    }
+  });
+  const headRoute = (0, import_zod_openapi.createRoute)({
+    method: "head",
+    path: "/resources/{resourceId}",
+    summary: "Check Resource Exists",
+    description: "Checks if a resource exists by its URI without retrieving its content",
+    tags: ["resources"],
+    request: {
+      params: ResourceIdParamSchema
+    },
+    responses: {
+      200: { description: "Resource exists" },
+      404: { description: "Resource not found" }
+    }
+  });
+  return app.openapi(listRoute, async (ctx) => {
+    const agent = getAgent();
+    const resources = await agent.listResources();
+    return ctx.json({ ok: true, resources: Object.values(resources) });
+  }).openapi(getContentRoute, async (ctx) => {
+    const agent = getAgent();
+    const { resourceId } = ctx.req.valid("param");
+    const content = await agent.readResource(resourceId);
+    return ctx.json({ ok: true, content });
+  }).openapi(headRoute, async (ctx) => {
+    const agent = getAgent();
+    const { resourceId } = ctx.req.valid("param");
+    const exists = await agent.hasResource(resourceId);
+    return ctx.body(null, exists ? 200 : 404);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createResourcesRouter
+});

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

@@ -0,0 +1,76 @@
+import { OpenAPIHono } from '@hono/zod-openapi';
+import type { DextoAgent } from '@dexto/core';
+export declare function createResourcesRouter(getAgent: () => DextoAgent): OpenAPIHono<import("hono").Env, {
+    "/resources": {
+        $get: {
+            input: {};
+            output: {
+                ok: true;
+                resources: {
+                    uri: string;
+                    source: "mcp" | "internal";
+                    description?: string | undefined;
+                    mimeType?: string | undefined;
+                    name?: string | undefined;
+                    metadata?: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | undefined;
+                    serverName?: string | undefined;
+                    size?: number | undefined;
+                    lastModified?: string | undefined;
+                }[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/resources/:resourceId/content": {
+        $get: {
+            input: {
+                param: {
+                    resourceId: string;
+                };
+            };
+            output: {
+                content: {
+                    contents: {
+                        uri: string;
+                        text?: string | undefined;
+                        mimeType?: string | undefined;
+                        blob?: string | undefined;
+                    }[];
+                    _meta?: {
+                        [x: string]: any;
+                    } | undefined;
+                };
+                ok: true;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/resources/:resourceId": {
+        $head: {
+            input: {
+                param: {
+                    resourceId: string;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: 200;
+        } | {
+            input: {
+                param: {
+                    resourceId: string;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: 404;
+        };
+    };
+}, "/">;
+//# sourceMappingURL=resources.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/resources.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAyD9C,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAqE/D"}

package/dist/hono/routes/resources.js

@@ -0,0 +1,86 @@
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import { ResourceSchema } from "../schemas/responses.js";
+const ResourceIdParamSchema = z.object({
+  resourceId: z.string().min(1, "Resource ID is required").transform((encoded) => decodeURIComponent(encoded)).describe("The URI-encoded resource identifier")
+}).describe("Path parameters for resource endpoints");
+const ListResourcesResponseSchema = z.object({
+  ok: z.literal(true).describe("Indicates successful response"),
+  resources: z.array(ResourceSchema).describe("Array of all available resources from all sources")
+}).strict().describe("List of all resources");
+const ResourceContentItemSchema = z.object({
+  uri: z.string().describe("Resource URI"),
+  mimeType: z.string().optional().describe("MIME type of the content"),
+  text: z.string().optional().describe("Text content (for text resources)"),
+  blob: z.string().optional().describe("Base64-encoded binary content (for binary resources)")
+}).strict().describe("Resource content item");
+const ReadResourceResponseSchema = z.object({
+  ok: z.literal(true).describe("Indicates successful response"),
+  content: z.object({
+    contents: z.array(ResourceContentItemSchema).describe("Array of content items (typically one item)"),
+    _meta: z.record(z.any()).optional().describe("Optional metadata about the resource")
+  }).strict().describe("Resource content from MCP ReadResourceResult")
+}).strict().describe("Resource content response");
+function createResourcesRouter(getAgent) {
+  const app = new OpenAPIHono();
+  const listRoute = createRoute({
+    method: "get",
+    path: "/resources",
+    summary: "List All Resources",
+    description: "Retrieves a list of all available resources from all sources (MCP servers and internal providers)",
+    tags: ["resources"],
+    responses: {
+      200: {
+        description: "List all resources",
+        content: { "application/json": { schema: ListResourcesResponseSchema } }
+      }
+    }
+  });
+  const getContentRoute = createRoute({
+    method: "get",
+    path: "/resources/{resourceId}/content",
+    summary: "Read Resource Content",
+    description: "Reads the content of a specific resource by its URI. The resource ID in the URL must be URI-encoded",
+    tags: ["resources"],
+    request: {
+      params: ResourceIdParamSchema
+    },
+    responses: {
+      200: {
+        description: "Resource content",
+        content: { "application/json": { schema: ReadResourceResponseSchema } }
+      }
+    }
+  });
+  const headRoute = createRoute({
+    method: "head",
+    path: "/resources/{resourceId}",
+    summary: "Check Resource Exists",
+    description: "Checks if a resource exists by its URI without retrieving its content",
+    tags: ["resources"],
+    request: {
+      params: ResourceIdParamSchema
+    },
+    responses: {
+      200: { description: "Resource exists" },
+      404: { description: "Resource not found" }
+    }
+  });
+  return app.openapi(listRoute, async (ctx) => {
+    const agent = getAgent();
+    const resources = await agent.listResources();
+    return ctx.json({ ok: true, resources: Object.values(resources) });
+  }).openapi(getContentRoute, async (ctx) => {
+    const agent = getAgent();
+    const { resourceId } = ctx.req.valid("param");
+    const content = await agent.readResource(resourceId);
+    return ctx.json({ ok: true, content });
+  }).openapi(headRoute, async (ctx) => {
+    const agent = getAgent();
+    const { resourceId } = ctx.req.valid("param");
+    const exists = await agent.hasResource(resourceId);
+    return ctx.body(null, exists ? 200 : 404);
+  });
+}
+export {
+  createResourcesRouter
+};

package/dist/hono/routes/search.cjs

@@ -0,0 +1,109 @@
+"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 search_exports = {};
+__export(search_exports, {
+  createSearchRouter: () => createSearchRouter
+});
+module.exports = __toCommonJS(search_exports);
+var import_zod_openapi = require("@hono/zod-openapi");
+var import_responses = require("../schemas/responses.js");
+const MessageSearchQuery = import_zod_openapi.z.object({
+  q: import_zod_openapi.z.string().min(1, "Search query is required").describe("Search query string"),
+  limit: import_zod_openapi.z.coerce.number().min(1).max(100).optional().describe("Maximum number of results to return (default: 20)"),
+  offset: import_zod_openapi.z.coerce.number().min(0).optional().describe("Number of results to skip for pagination (default: 0)"),
+  sessionId: import_zod_openapi.z.string().optional().describe("Limit search to a specific session"),
+  role: import_zod_openapi.z.enum(["user", "assistant", "system", "tool"]).optional().describe("Filter by message role")
+});
+const SessionSearchQuery = import_zod_openapi.z.object({
+  q: import_zod_openapi.z.string().min(1, "Search query is required").describe("Search query string")
+});
+function createSearchRouter(getAgent) {
+  const app = new import_zod_openapi.OpenAPIHono();
+  const messagesRoute = (0, import_zod_openapi.createRoute)({
+    method: "get",
+    path: "/search/messages",
+    summary: "Search Messages",
+    description: "Searches for messages across all sessions or within a specific session",
+    tags: ["search"],
+    request: { query: MessageSearchQuery },
+    responses: {
+      200: {
+        description: "Message search results",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              results: import_zod_openapi.z.array(import_responses.SearchResultSchema).describe("Array of search results"),
+              total: import_zod_openapi.z.number().int().nonnegative().describe("Total number of results available"),
+              hasMore: import_zod_openapi.z.boolean().describe(
+                "Whether there are more results beyond the current page"
+              ),
+              query: import_zod_openapi.z.string().describe("Query that was searched")
+            }).strict().describe("Message search response")
+          }
+        }
+      }
+    }
+  });
+  const sessionsRoute = (0, import_zod_openapi.createRoute)({
+    method: "get",
+    path: "/search/sessions",
+    summary: "Search Sessions",
+    description: "Searches for sessions that contain the specified query",
+    tags: ["search"],
+    request: { query: SessionSearchQuery },
+    responses: {
+      200: {
+        description: "Session search results",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              results: import_zod_openapi.z.array(import_responses.SessionSearchResultSchema).describe("Array of session search results"),
+              total: import_zod_openapi.z.number().int().nonnegative().describe("Total number of sessions with matches"),
+              hasMore: import_zod_openapi.z.boolean().describe(
+                "Always false - session search returns all matching sessions without pagination"
+              ),
+              query: import_zod_openapi.z.string().describe("Query that was searched")
+            }).strict().describe("Session search response")
+          }
+        }
+      }
+    }
+  });
+  return app.openapi(messagesRoute, async (ctx) => {
+    const agent = getAgent();
+    const { q, limit, offset, sessionId, role } = ctx.req.valid("query");
+    const options = {
+      limit: limit || 20,
+      offset: offset || 0,
+      ...sessionId && { sessionId },
+      ...role && { role }
+    };
+    const searchResults = await agent.searchMessages(q, options);
+    return ctx.json(searchResults);
+  }).openapi(sessionsRoute, async (ctx) => {
+    const agent = getAgent();
+    const { q } = ctx.req.valid("query");
+    const searchResults = await agent.searchSessions(q);
+    return ctx.json(searchResults);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createSearchRouter
+});