@dexto/server 1.2.5

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

@@ -0,0 +1,137 @@
+import { OpenAPIHono } from '@hono/zod-openapi';
+import type { DextoAgent } from '@dexto/core';
+export declare function createSearchRouter(getAgent: () => DextoAgent): OpenAPIHono<import("hono").Env, {
+    "/search/messages": {
+        $get: {
+            input: {
+                query: {
+                    q: string;
+                    sessionId?: string | undefined;
+                    role?: "system" | "user" | "assistant" | "tool" | undefined;
+                    limit?: number | undefined;
+                    offset?: number | undefined;
+                };
+            };
+            output: {
+                query: string;
+                results: {
+                    message: {
+                        content: string | ({
+                            type: "text";
+                            text: string;
+                        } | {
+                            type: "image";
+                            image?: import("hono/utils/types").JSONValue;
+                            mimeType?: string | undefined;
+                        } | {
+                            type: "file";
+                            mimeType: string;
+                            data?: import("hono/utils/types").JSONValue;
+                            filename?: string | undefined;
+                        })[] | null;
+                        role: "system" | "user" | "assistant" | "tool";
+                        provider?: string | undefined;
+                        model?: string | undefined;
+                        router?: string | undefined;
+                        name?: string | undefined;
+                        timestamp?: number | undefined;
+                        reasoning?: string | undefined;
+                        tokenUsage?: {
+                            inputTokens?: number | undefined;
+                            outputTokens?: number | undefined;
+                            reasoningTokens?: number | undefined;
+                            totalTokens?: number | undefined;
+                        } | undefined;
+                        toolCalls?: {
+                            function: {
+                                name: string;
+                                arguments: string;
+                            };
+                            type: "function";
+                            id: string;
+                        }[] | undefined;
+                        toolCallId?: string | undefined;
+                    };
+                    sessionId: string;
+                    matchedText: string;
+                    context: string;
+                    messageIndex: number;
+                }[];
+                total: number;
+                hasMore: boolean;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/search/sessions": {
+        $get: {
+            input: {
+                query: {
+                    q: string;
+                };
+            };
+            output: {
+                query: string;
+                results: {
+                    sessionId: string;
+                    matchCount: number;
+                    firstMatch: {
+                        message: {
+                            content: string | ({
+                                type: "text";
+                                text: string;
+                            } | {
+                                type: "image";
+                                image?: import("hono/utils/types").JSONValue;
+                                mimeType?: string | undefined;
+                            } | {
+                                type: "file";
+                                mimeType: string;
+                                data?: import("hono/utils/types").JSONValue;
+                                filename?: string | undefined;
+                            })[] | null;
+                            role: "system" | "user" | "assistant" | "tool";
+                            provider?: string | undefined;
+                            model?: string | undefined;
+                            router?: string | undefined;
+                            name?: string | undefined;
+                            timestamp?: number | undefined;
+                            reasoning?: string | undefined;
+                            tokenUsage?: {
+                                inputTokens?: number | undefined;
+                                outputTokens?: number | undefined;
+                                reasoningTokens?: number | undefined;
+                                totalTokens?: number | undefined;
+                            } | undefined;
+                            toolCalls?: {
+                                function: {
+                                    name: string;
+                                    arguments: string;
+                                };
+                                type: "function";
+                                id: string;
+                            }[] | undefined;
+                            toolCallId?: string | undefined;
+                        };
+                        sessionId: string;
+                        matchedText: string;
+                        context: string;
+                        messageIndex: number;
+                    };
+                    metadata: {
+                        createdAt: number;
+                        lastActivity: number;
+                        messageCount: number;
+                    };
+                }[];
+                total: number;
+                hasMore: boolean;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">;
+//# sourceMappingURL=search.d.ts.map

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

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

package/dist/hono/routes/search.js

@@ -0,0 +1,85 @@
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import { SearchResultSchema, SessionSearchResultSchema } from "../schemas/responses.js";
+const MessageSearchQuery = z.object({
+  q: z.string().min(1, "Search query is required").describe("Search query string"),
+  limit: z.coerce.number().min(1).max(100).optional().describe("Maximum number of results to return (default: 20)"),
+  offset: z.coerce.number().min(0).optional().describe("Number of results to skip for pagination (default: 0)"),
+  sessionId: z.string().optional().describe("Limit search to a specific session"),
+  role: z.enum(["user", "assistant", "system", "tool"]).optional().describe("Filter by message role")
+});
+const SessionSearchQuery = z.object({
+  q: z.string().min(1, "Search query is required").describe("Search query string")
+});
+function createSearchRouter(getAgent) {
+  const app = new OpenAPIHono();
+  const messagesRoute = 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: z.object({
+              results: z.array(SearchResultSchema).describe("Array of search results"),
+              total: z.number().int().nonnegative().describe("Total number of results available"),
+              hasMore: z.boolean().describe(
+                "Whether there are more results beyond the current page"
+              ),
+              query: z.string().describe("Query that was searched")
+            }).strict().describe("Message search response")
+          }
+        }
+      }
+    }
+  });
+  const sessionsRoute = 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: z.object({
+              results: z.array(SessionSearchResultSchema).describe("Array of session search results"),
+              total: z.number().int().nonnegative().describe("Total number of sessions with matches"),
+              hasMore: z.boolean().describe(
+                "Always false - session search returns all matching sessions without pagination"
+              ),
+              query: 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);
+  });
+}
+export {
+  createSearchRouter
+};

package/dist/hono/routes/sessions.cjs

@@ -0,0 +1,366 @@
+"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 sessions_exports = {};
+__export(sessions_exports, {
+  createSessionsRouter: () => createSessionsRouter
+});
+module.exports = __toCommonJS(sessions_exports);
+var import_zod_openapi = require("@hono/zod-openapi");
+var import_responses = require("../schemas/responses.js");
+const CreateSessionSchema = import_zod_openapi.z.object({
+  sessionId: import_zod_openapi.z.string().optional().describe("A custom ID for the new session")
+}).describe("Request body for creating a new session");
+function createSessionsRouter(getAgent) {
+  const app = new import_zod_openapi.OpenAPIHono();
+  const listRoute = (0, import_zod_openapi.createRoute)({
+    method: "get",
+    path: "/sessions",
+    summary: "List Sessions",
+    description: "Retrieves a list of all active sessions",
+    tags: ["sessions"],
+    responses: {
+      200: {
+        description: "List of all active sessions",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              sessions: import_zod_openapi.z.array(import_responses.SessionMetadataSchema).describe("Array of session metadata objects")
+            }).strict()
+          }
+        }
+      }
+    }
+  });
+  const createRouteDef = (0, import_zod_openapi.createRoute)({
+    method: "post",
+    path: "/sessions",
+    summary: "Create Session",
+    description: "Creates a new session",
+    tags: ["sessions"],
+    request: { body: { content: { "application/json": { schema: CreateSessionSchema } } } },
+    responses: {
+      201: {
+        description: "Session created successfully",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              session: import_responses.SessionMetadataSchema.describe(
+                "Newly created session metadata"
+              )
+            }).strict()
+          }
+        }
+      }
+    }
+  });
+  const getRoute = (0, import_zod_openapi.createRoute)({
+    method: "get",
+    path: "/sessions/{sessionId}",
+    summary: "Get Session Details",
+    description: "Fetches details for a specific session",
+    tags: ["sessions"],
+    request: { params: import_zod_openapi.z.object({ sessionId: import_zod_openapi.z.string().describe("Session identifier") }) },
+    responses: {
+      200: {
+        description: "Session details with metadata",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              session: import_responses.SessionMetadataSchema.extend({
+                history: import_zod_openapi.z.number().int().nonnegative().describe("Number of messages in history")
+              }).strict().describe("Session metadata with history count")
+            }).strict()
+          }
+        }
+      }
+    }
+  });
+  const historyRoute = (0, import_zod_openapi.createRoute)({
+    method: "get",
+    path: "/sessions/{sessionId}/history",
+    summary: "Get Session History",
+    description: "Retrieves the conversation history for a session",
+    tags: ["sessions"],
+    request: { params: import_zod_openapi.z.object({ sessionId: import_zod_openapi.z.string().describe("Session identifier") }) },
+    responses: {
+      200: {
+        description: "Session conversation history",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              history: import_zod_openapi.z.array(import_responses.InternalMessageSchema).describe("Array of messages in conversation history")
+            }).strict()
+          }
+        }
+      }
+    }
+  });
+  const deleteRoute = (0, import_zod_openapi.createRoute)({
+    method: "delete",
+    path: "/sessions/{sessionId}",
+    summary: "Delete Session",
+    description: "Permanently deletes a session and all its conversation history. This action cannot be undone",
+    tags: ["sessions"],
+    request: { params: import_zod_openapi.z.object({ sessionId: import_zod_openapi.z.string().describe("Session identifier") }) },
+    responses: {
+      200: {
+        description: "Session deleted successfully",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              status: import_zod_openapi.z.literal("deleted").describe("Deletion status"),
+              sessionId: import_zod_openapi.z.string().describe("ID of the deleted session")
+            }).strict()
+          }
+        }
+      }
+    }
+  });
+  const cancelRoute = (0, import_zod_openapi.createRoute)({
+    method: "post",
+    path: "/sessions/{sessionId}/cancel",
+    summary: "Cancel Session Run",
+    description: "Cancels an in-flight agent run for the specified session",
+    tags: ["sessions"],
+    request: { params: import_zod_openapi.z.object({ sessionId: import_zod_openapi.z.string().describe("Session identifier") }) },
+    responses: {
+      200: {
+        description: "Cancel operation result",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              cancelled: import_zod_openapi.z.boolean().describe("Whether a run was cancelled"),
+              sessionId: import_zod_openapi.z.string().describe("Session ID")
+            }).strict()
+          }
+        }
+      }
+    }
+  });
+  const loadRoute = (0, import_zod_openapi.createRoute)({
+    method: "get",
+    path: "/sessions/{sessionId}/load",
+    summary: "Load Session",
+    description: "Validates and retrieves session information. The client should track the active session.",
+    tags: ["sessions"],
+    request: {
+      params: import_zod_openapi.z.object({ sessionId: import_zod_openapi.z.string().describe("Session identifier") })
+    },
+    responses: {
+      200: {
+        description: "Session information retrieved successfully",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              session: import_responses.SessionMetadataSchema.describe("Session metadata")
+            }).strict()
+          }
+        }
+      },
+      404: {
+        description: "Session not found",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              error: import_zod_openapi.z.string().describe("Error message")
+            }).strict()
+          }
+        }
+      }
+    }
+  });
+  const patchRoute = (0, import_zod_openapi.createRoute)({
+    method: "patch",
+    path: "/sessions/{sessionId}",
+    summary: "Update Session Title",
+    description: "Updates the title of an existing session",
+    tags: ["sessions"],
+    request: {
+      params: import_zod_openapi.z.object({ sessionId: import_zod_openapi.z.string().describe("Session identifier") }),
+      body: {
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              title: import_zod_openapi.z.string().min(1, "Title is required").max(120, "Title too long").describe("New title for the session (maximum 120 characters)")
+            })
+          }
+        }
+      }
+    },
+    responses: {
+      200: {
+        description: "Session updated successfully",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              session: import_responses.SessionMetadataSchema.describe("Updated session metadata")
+            }).strict()
+          }
+        }
+      }
+    }
+  });
+  const generateTitleRoute = (0, import_zod_openapi.createRoute)({
+    method: "post",
+    path: "/sessions/{sessionId}/generate-title",
+    summary: "Generate Session Title",
+    description: "Generates a descriptive title for the session using the first user message. Returns existing title if already set.",
+    tags: ["sessions"],
+    request: {
+      params: import_zod_openapi.z.object({ sessionId: import_zod_openapi.z.string().describe("Session identifier") })
+    },
+    responses: {
+      200: {
+        description: "Title generated successfully",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              title: import_zod_openapi.z.string().nullable().describe("Generated title, or null if generation failed"),
+              sessionId: import_zod_openapi.z.string().describe("Session ID")
+            }).strict()
+          }
+        }
+      },
+      404: {
+        description: "Session not found (error format handled by middleware)"
+      }
+    }
+  });
+  return app.openapi(listRoute, async (ctx) => {
+    const agent = getAgent();
+    const sessionIds = await agent.listSessions();
+    const sessions = await Promise.all(
+      sessionIds.map(async (id) => {
+        try {
+          const metadata = await agent.getSessionMetadata(id);
+          return {
+            id,
+            createdAt: metadata?.createdAt || null,
+            lastActivity: metadata?.lastActivity || null,
+            messageCount: metadata?.messageCount || 0,
+            title: metadata?.title || null
+          };
+        } catch {
+          return {
+            id,
+            createdAt: null,
+            lastActivity: null,
+            messageCount: 0,
+            title: null
+          };
+        }
+      })
+    );
+    return ctx.json({ sessions });
+  }).openapi(createRouteDef, async (ctx) => {
+    const agent = getAgent();
+    const { sessionId } = ctx.req.valid("json");
+    const session = await agent.createSession(sessionId);
+    const metadata = await agent.getSessionMetadata(session.id);
+    return ctx.json(
+      {
+        session: {
+          id: session.id,
+          createdAt: metadata?.createdAt || Date.now(),
+          lastActivity: metadata?.lastActivity || Date.now(),
+          messageCount: metadata?.messageCount || 0,
+          title: metadata?.title || null
+        }
+      },
+      201
+    );
+  }).openapi(getRoute, async (ctx) => {
+    const agent = getAgent();
+    const { sessionId } = ctx.req.param();
+    const metadata = await agent.getSessionMetadata(sessionId);
+    const history = await agent.getSessionHistory(sessionId);
+    return ctx.json({
+      session: {
+        id: sessionId,
+        createdAt: metadata?.createdAt || null,
+        lastActivity: metadata?.lastActivity || null,
+        messageCount: metadata?.messageCount || 0,
+        title: metadata?.title || null,
+        history: history.length
+      }
+    });
+  }).openapi(historyRoute, async (ctx) => {
+    const agent = getAgent();
+    const { sessionId } = ctx.req.param();
+    const history = await agent.getSessionHistory(sessionId);
+    return ctx.json({ history });
+  }).openapi(deleteRoute, async (ctx) => {
+    const agent = getAgent();
+    const { sessionId } = ctx.req.param();
+    await agent.deleteSession(sessionId);
+    return ctx.json({ status: "deleted", sessionId });
+  }).openapi(cancelRoute, async (ctx) => {
+    const agent = getAgent();
+    const { sessionId } = ctx.req.valid("param");
+    const cancelled = await agent.cancel(sessionId);
+    if (!cancelled) {
+      agent.logger.debug(`No in-flight run to cancel for session: ${sessionId}`);
+    }
+    return ctx.json({ cancelled, sessionId });
+  }).openapi(loadRoute, async (ctx) => {
+    const agent = getAgent();
+    const { sessionId } = ctx.req.valid("param");
+    const sessionIds = await agent.listSessions();
+    if (!sessionIds.includes(sessionId)) {
+      return ctx.json({ error: `Session not found: ${sessionId}` }, 404);
+    }
+    const metadata = await agent.getSessionMetadata(sessionId);
+    return ctx.json(
+      {
+        session: {
+          id: sessionId,
+          createdAt: metadata?.createdAt || null,
+          lastActivity: metadata?.lastActivity || null,
+          messageCount: metadata?.messageCount || 0,
+          title: metadata?.title || null
+        }
+      },
+      200
+    );
+  }).openapi(patchRoute, async (ctx) => {
+    const agent = getAgent();
+    const { sessionId } = ctx.req.valid("param");
+    const { title } = ctx.req.valid("json");
+    await agent.setSessionTitle(sessionId, title);
+    const metadata = await agent.getSessionMetadata(sessionId);
+    return ctx.json({
+      session: {
+        id: sessionId,
+        createdAt: metadata?.createdAt || null,
+        lastActivity: metadata?.lastActivity || null,
+        messageCount: metadata?.messageCount || 0,
+        title: metadata?.title || title
+      }
+    });
+  }).openapi(generateTitleRoute, async (ctx) => {
+    const agent = getAgent();
+    const { sessionId } = ctx.req.valid("param");
+    const title = await agent.generateSessionTitle(sessionId);
+    return ctx.json({ title, sessionId });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createSessionsRouter
+});