@dexto/server 1.2.5

package/dist/hono/routes/messages.js

@@ -0,0 +1,296 @@
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import { streamSSE } from "hono/streaming";
+import { LLM_PROVIDERS, LLM_ROUTERS } from "@dexto/core";
+import { TokenUsageSchema } from "../schemas/responses.js";
+const MessageBodySchema = z.object({
+  message: z.string().optional().describe("The user message text"),
+  sessionId: z.string().min(1, "Session ID is required").describe("The session to use for this message"),
+  imageData: z.object({
+    base64: z.string().describe("Base64-encoded image data"),
+    mimeType: z.string().describe("The MIME type of the image (e.g., image/png)")
+  }).optional().describe("Optional image data to include with the message"),
+  fileData: z.object({
+    base64: z.string().describe("Base64-encoded file data"),
+    mimeType: z.string().describe("The MIME type of the file (e.g., application/pdf)"),
+    filename: 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");
+const ResetBodySchema = z.object({
+  sessionId: z.string().min(1, "Session ID is required").describe("The ID of the session to reset")
+}).describe("Request body for resetting a conversation");
+function createMessagesRouter(getAgent, approvalCoordinator) {
+  const app = new OpenAPIHono();
+  const messageRoute = createRoute({
+    method: "post",
+    path: "/message",
+    summary: "Send Message (async)",
+    description: "Sends a message and returns immediately. The full response will be sent over SSE",
+    tags: ["messages"],
+    request: {
+      body: {
+        content: { "application/json": { schema: MessageBodySchema } }
+      }
+    },
+    responses: {
+      202: {
+        description: "Message accepted for async processing; subscribe to SSE for results",
+        content: {
+          "application/json": {
+            schema: z.object({
+              accepted: z.literal(true).describe("Indicates request was accepted"),
+              sessionId: z.string().describe("Session ID used for this message")
+            }).strict()
+          }
+        }
+      },
+      400: { description: "Validation error" }
+    }
+  });
+  const messageSyncRoute = createRoute({
+    method: "post",
+    path: "/message-sync",
+    summary: "Send Message (sync)",
+    description: "Sends a message and waits for the full response",
+    tags: ["messages"],
+    request: {
+      body: { content: { "application/json": { schema: MessageBodySchema } } }
+    },
+    responses: {
+      200: {
+        description: "Synchronous response",
+        content: {
+          "application/json": {
+            schema: z.object({
+              response: z.string().describe("Agent response text"),
+              sessionId: z.string().describe("Session ID used for this message"),
+              tokenUsage: TokenUsageSchema.optional().describe("Token usage statistics"),
+              reasoning: z.string().optional().describe("Extended thinking content from reasoning models"),
+              model: z.string().optional().describe("Model used for this response"),
+              provider: z.enum(LLM_PROVIDERS).optional().describe("LLM provider"),
+              router: z.enum(LLM_ROUTERS).optional().describe("Router used (e.g., vercel)")
+            }).strict()
+          }
+        }
+      },
+      400: { description: "Validation error" }
+    }
+  });
+  const resetRoute = createRoute({
+    method: "post",
+    path: "/reset",
+    summary: "Reset Conversation",
+    description: "Resets the conversation history for a given session",
+    tags: ["messages"],
+    request: {
+      body: { content: { "application/json": { schema: ResetBodySchema } } }
+    },
+    responses: {
+      200: {
+        description: "Reset initiated",
+        content: {
+          "application/json": {
+            schema: z.object({
+              status: z.string().describe("Status message indicating reset was initiated"),
+              sessionId: z.string().describe("Session ID that was reset")
+            }).strict()
+          }
+        }
+      }
+    }
+  });
+  const messageStreamRoute = createRoute({
+    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.",
+    tags: ["messages"],
+    request: {
+      body: {
+        content: { "application/json": { schema: MessageBodySchema } }
+      }
+    },
+    responses: {
+      200: {
+        description: "SSE stream of agent events. Standard SSE format with event type and JSON data.",
+        headers: {
+          "Content-Type": {
+            description: "SSE content type",
+            schema: { type: "string", example: "text/event-stream" }
+          },
+          "Cache-Control": {
+            description: "Disable caching for stream",
+            schema: { type: "string", example: "no-cache" }
+          },
+          Connection: {
+            description: "Keep connection alive for streaming",
+            schema: { type: "string", example: "keep-alive" }
+          },
+          "X-Accel-Buffering": {
+            description: "Disable nginx buffering",
+            schema: { type: "string", example: "no" }
+          }
+        },
+        content: {
+          "text/event-stream": {
+            schema: z.string().describe(
+              "Server-Sent Events stream. Events: llm:thinking (start), llm:chunk (text fragments), llm:tool-call (tool execution), llm:tool-result (tool output), llm:response (final), llm:error (errors)"
+            )
+          }
+        }
+      },
+      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.");
+    agent.logger.info(`Message for session: ${sessionId}`);
+    agent.run(message || "", imageDataInput, fileDataInput, sessionId, false).catch((error) => {
+      agent.logger.error(
+        `Error in async message processing: ${error instanceof Error ? error.message : String(error)}`
+      );
+    });
+    return ctx.json({ accepted: true, sessionId }, 202);
+  }).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.");
+    agent.logger.info(`Message for session: ${sessionId}`);
+    const result = await agent.generate(message || "", {
+      sessionId,
+      imageData: imageDataInput,
+      fileData: fileDataInput
+    });
+    const llmConfig = agent.stateManager.getLLMConfig(sessionId);
+    return ctx.json({
+      response: result.content,
+      sessionId: result.sessionId,
+      tokenUsage: result.usage,
+      reasoning: result.reasoning,
+      model: llmConfig.model,
+      provider: llmConfig.provider,
+      router: "vercel"
+      // Hardcoded for now since we only use Vercel AI SDK
+    });
+  }).openapi(resetRoute, async (ctx) => {
+    const agent = getAgent();
+    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 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 abortController = new AbortController();
+    const { signal } = abortController;
+    const iterator = await agent.stream(message, {
+      sessionId,
+      imageData: imageDataInput,
+      fileData: fileDataInput,
+      signal
+    });
+    return streamSSE(ctx, async (stream) => {
+      const pendingApprovalEvents = [];
+      if (approvalCoordinator) {
+        approvalCoordinator.onRequest(
+          (request) => {
+            if (request.sessionId === sessionId) {
+              pendingApprovalEvents.push({
+                event: "approval:request",
+                data: request
+              });
+            }
+          },
+          { signal }
+        );
+        approvalCoordinator.onResponse(
+          (response) => {
+            if (response.sessionId === sessionId) {
+              pendingApprovalEvents.push({
+                event: "approval:response",
+                data: response
+              });
+            }
+          },
+          { signal }
+        );
+      }
+      try {
+        for await (const event of iterator) {
+          while (pendingApprovalEvents.length > 0) {
+            const approvalEvent = pendingApprovalEvents.shift();
+            await stream.writeSSE({
+              event: approvalEvent.event,
+              data: JSON.stringify(approvalEvent.data)
+            });
+          }
+          const eventData = event.type === "llm:error" && event.error instanceof Error ? {
+            ...event,
+            error: {
+              message: event.error.message,
+              name: event.error.name,
+              stack: event.error.stack
+            }
+          } : event;
+          await stream.writeSSE({
+            event: event.type,
+            data: JSON.stringify(eventData)
+          });
+        }
+        while (pendingApprovalEvents.length > 0) {
+          const approvalEvent = pendingApprovalEvents.shift();
+          await stream.writeSSE({
+            event: approvalEvent.event,
+            data: JSON.stringify(approvalEvent.data)
+          });
+        }
+      } catch (error) {
+        await stream.writeSSE({
+          event: "llm:error",
+          data: JSON.stringify({
+            error: {
+              message: error instanceof Error ? error.message : String(error)
+            },
+            recoverable: false,
+            sessionId
+          })
+        });
+      } finally {
+        abortController.abort();
+      }
+    });
+  });
+}
+export {
+  createMessagesRouter
+};

package/dist/hono/routes/prompts.cjs

@@ -0,0 +1,228 @@
+"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 prompts_exports = {};
+__export(prompts_exports, {
+  createPromptsRouter: () => createPromptsRouter
+});
+module.exports = __toCommonJS(prompts_exports);
+var import_zod_openapi = require("@hono/zod-openapi");
+var import_core = require("@dexto/core");
+var import_responses = require("../schemas/responses.js");
+const CustomPromptRequestSchema = import_zod_openapi.z.object({
+  name: import_zod_openapi.z.string().min(1, "Prompt name is required").describe("Unique name for the custom prompt"),
+  title: import_zod_openapi.z.string().optional().describe("Display title for the prompt"),
+  description: import_zod_openapi.z.string().optional().describe("Description of what the prompt does"),
+  content: import_zod_openapi.z.string().min(1, "Prompt content is required").describe("The prompt content text (can include {{argumentName}} placeholders)"),
+  arguments: import_zod_openapi.z.array(
+    import_zod_openapi.z.object({
+      name: import_zod_openapi.z.string().min(1, "Argument name is required").describe("Argument name"),
+      description: import_zod_openapi.z.string().optional().describe("Argument description"),
+      required: import_zod_openapi.z.boolean().optional().describe("Whether the argument is required")
+    }).strict()
+  ).optional().describe("Array of argument definitions"),
+  resource: import_zod_openapi.z.object({
+    base64: import_zod_openapi.z.string().min(1, "Resource data is required").describe("Base64-encoded resource data"),
+    mimeType: import_zod_openapi.z.string().min(1, "Resource MIME type is required").describe("MIME type of the resource (e.g., text/plain, application/pdf)"),
+    filename: import_zod_openapi.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 = import_zod_openapi.z.object({
+  name: import_zod_openapi.z.string().min(1, "Prompt name is required").describe("The prompt name")
+}).describe("Path parameters for prompt endpoints");
+const ResolvePromptQuerySchema = import_zod_openapi.z.object({
+  context: import_zod_openapi.z.string().optional().describe("Additional context for prompt resolution"),
+  args: import_zod_openapi.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 import_zod_openapi.OpenAPIHono();
+  const listRoute = (0, import_zod_openapi.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: import_zod_openapi.z.object({
+              prompts: import_zod_openapi.z.array(import_responses.PromptInfoSchema).describe("Array of available prompts")
+            }).strict().describe("Prompts list response")
+          }
+        }
+      }
+    }
+  });
+  const createCustomRoute = (0, import_zod_openapi.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: import_zod_openapi.z.object({
+              prompt: import_responses.PromptInfoSchema.describe("Created prompt information")
+            }).strict().describe("Create prompt response")
+          }
+        }
+      }
+    }
+  });
+  const deleteCustomRoute = (0, import_zod_openapi.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: import_zod_openapi.z.object({
+        name: import_zod_openapi.z.string().min(1, "Prompt name is required").describe("The prompt name")
+      })
+    },
+    responses: {
+      204: { description: "Prompt deleted" }
+    }
+  });
+  const getPromptRoute = (0, import_zod_openapi.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: import_zod_openapi.z.object({
+              definition: import_responses.PromptDefinitionSchema.describe("Prompt definition")
+            }).strict().describe("Get prompt definition response")
+          }
+        }
+      },
+      404: { description: "Prompt not found" }
+    }
+  });
+  const resolvePromptRoute = (0, import_zod_openapi.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: import_zod_openapi.z.object({
+              text: import_zod_openapi.z.string().describe("Resolved prompt text"),
+              resources: import_zod_openapi.z.array(import_zod_openapi.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 import_core.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 });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createPromptsRouter
+});

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

@@ -0,0 +1,150 @@
+import { OpenAPIHono } from '@hono/zod-openapi';
+import type { DextoAgent } from '@dexto/core';
+export declare function createPromptsRouter(getAgent: () => DextoAgent): OpenAPIHono<import("hono").Env, {
+    "/prompts": {
+        $get: {
+            input: {};
+            output: {
+                prompts: {
+                    name: string;
+                    source: "file" | "custom" | "mcp" | "starter";
+                    description?: string | undefined;
+                    title?: string | undefined;
+                    arguments?: {
+                        name: string;
+                        description?: string | undefined;
+                        required?: boolean | undefined;
+                    }[] | undefined;
+                    metadata?: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | undefined;
+                }[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/prompts/custom": {
+        $post: {
+            input: {
+                json: {
+                    content: string;
+                    name: string;
+                    description?: string | undefined;
+                    title?: string | undefined;
+                    arguments?: {
+                        name: string;
+                        description?: string | undefined;
+                        required?: boolean | undefined;
+                    }[] | undefined;
+                    resource?: {
+                        mimeType: string;
+                        base64: string;
+                        filename?: string | undefined;
+                    } | undefined;
+                };
+            };
+            output: {
+                prompt: {
+                    name: string;
+                    source: "file" | "custom" | "mcp" | "starter";
+                    description?: string | undefined;
+                    title?: string | undefined;
+                    arguments?: {
+                        name: string;
+                        description?: string | undefined;
+                        required?: boolean | undefined;
+                    }[] | undefined;
+                    metadata?: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | undefined;
+                };
+            };
+            outputFormat: "json";
+            status: 201;
+        };
+    };
+} & {
+    "/prompts/custom/:name": {
+        $delete: {
+            input: {
+                param: {
+                    name: string;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: 204;
+        };
+    };
+} & {
+    "/prompts/:name": {
+        $get: {
+            input: {
+                param: {
+                    name: string;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    name: string;
+                };
+            };
+            output: {
+                definition: {
+                    name: string;
+                    description?: string | undefined;
+                    title?: string | undefined;
+                    arguments?: {
+                        name: string;
+                        description?: string | undefined;
+                        required?: boolean | undefined;
+                    }[] | undefined;
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/prompts/:name/resolve": {
+        $get: {
+            input: {
+                param: {
+                    name: string;
+                };
+            } & {
+                query: {
+                    context?: string | undefined;
+                    args?: string | undefined;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    name: string;
+                };
+            } & {
+                query: {
+                    context?: string | undefined;
+                    args?: string | undefined;
+                };
+            };
+            output: {
+                text: string;
+                resources: string[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">;
+//# sourceMappingURL=prompts.d.ts.map

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

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