@dexto/server 1.4.0 → 1.5.0

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

@@ -1,6 +1,8 @@
 import { OpenAPIHono } from '@hono/zod-openapi';
 import type { DextoAgent } from '@dexto/core';
-export declare function createPromptsRouter(getAgent: () => DextoAgent): OpenAPIHono<import("hono").Env, {
+import type { Context } from 'hono';
+type GetAgentFn = (ctx: Context) => DextoAgent | Promise<DextoAgent>;
+export declare function createPromptsRouter(getAgent: GetAgentFn): OpenAPIHono<import("hono").Env, {
     "/prompts": {
         $get: {
             input: {};
@@ -147,4 +149,5 @@ export declare function createPromptsRouter(getAgent: () => DextoAgent): OpenAPI
         };
     };
 }, "/">;
+export {};
 //# sourceMappingURL=prompts.d.ts.map

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

@@ -1 +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"}
+{"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;AAG9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,KAAK,UAAU,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AAmErE,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA6NvD"}

package/dist/hono/routes/prompts.js

@@ -139,12 +139,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,
@@ -168,18 +168,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 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;

package/dist/hono/routes/queue.cjs

@@ -160,7 +160,7 @@ function createQueueRouter(getAgent) {
     }
   });
   return app.openapi(getQueueRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("param");
     const messages = await agent.getQueuedMessages(sessionId);
     return ctx.json({
@@ -168,7 +168,7 @@ function createQueueRouter(getAgent) {
       count: messages.length
     });
   }).openapi(queueMessageRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("param");
     const { content: rawContent } = ctx.req.valid("json");
     const content = typeof rawContent === "string" ? [{ type: "text", text: rawContent }] : rawContent;
@@ -182,7 +182,7 @@ function createQueueRouter(getAgent) {
       201
     );
   }).openapi(removeQueuedMessageRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId, messageId } = ctx.req.valid("param");
     const removed = await agent.removeQueuedMessage(sessionId, messageId);
     if (!removed) {
@@ -190,7 +190,7 @@ function createQueueRouter(getAgent) {
     }
     return ctx.json({ removed: true, id: messageId });
   }).openapi(clearQueueRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("param");
     const count = await agent.clearMessageQueue(sessionId);
     return ctx.json({ cleared: true, count });

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

@@ -1,6 +1,8 @@
 import { OpenAPIHono } from '@hono/zod-openapi';
 import type { DextoAgent } from '@dexto/core';
-export declare function createQueueRouter(getAgent: () => DextoAgent): OpenAPIHono<import("hono").Env, {
+import type { Context } from 'hono';
+type GetAgentFn = (ctx: Context) => DextoAgent | Promise<DextoAgent>;
+export declare function createQueueRouter(getAgent: GetAgentFn): OpenAPIHono<import("hono").Env, {
     "/queue/:sessionId": {
         $get: {
             input: {
@@ -168,4 +170,5 @@ export declare function createQueueRouter(getAgent: () => DextoAgent): OpenAPIHo
         };
     };
 }, "/">;
+export {};
 //# sourceMappingURL=queue.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/queue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAe,MAAM,aAAa,CAAC;AAsD3D,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAoL3D"}
+{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/queue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAe,MAAM,aAAa,CAAC;AAE3D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,KAAK,UAAU,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AAqDrE,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAoLrD"}

package/dist/hono/routes/queue.js

@@ -137,7 +137,7 @@ function createQueueRouter(getAgent) {
     }
   });
   return app.openapi(getQueueRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("param");
     const messages = await agent.getQueuedMessages(sessionId);
     return ctx.json({
@@ -145,7 +145,7 @@ function createQueueRouter(getAgent) {
       count: messages.length
     });
   }).openapi(queueMessageRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("param");
     const { content: rawContent } = ctx.req.valid("json");
     const content = typeof rawContent === "string" ? [{ type: "text", text: rawContent }] : rawContent;
@@ -159,7 +159,7 @@ function createQueueRouter(getAgent) {
       201
     );
   }).openapi(removeQueuedMessageRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId, messageId } = ctx.req.valid("param");
     const removed = await agent.removeQueuedMessage(sessionId, messageId);
     if (!removed) {
@@ -167,7 +167,7 @@ function createQueueRouter(getAgent) {
     }
     return ctx.json({ removed: true, id: messageId });
   }).openapi(clearQueueRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("param");
     const count = await agent.clearMessageQueue(sessionId);
     return ctx.json({ cleared: true, count });

package/dist/hono/routes/resources.cjs

@@ -89,16 +89,16 @@ function createResourcesRouter(getAgent) {
     }
   });
   return app.openapi(listRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const resources = await agent.listResources();
     return ctx.json({ ok: true, resources: Object.values(resources) });
   }).openapi(getContentRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     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 agent = await getAgent(ctx);
     const { resourceId } = ctx.req.valid("param");
     const exists = await agent.hasResource(resourceId);
     return ctx.body(null, exists ? 200 : 404);

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

@@ -1,6 +1,6 @@
 import { OpenAPIHono } from '@hono/zod-openapi';
-import type { DextoAgent } from '@dexto/core';
-export declare function createResourcesRouter(getAgent: () => DextoAgent): OpenAPIHono<import("hono").Env, {
+import type { GetAgentFn } from '../index.js';
+export declare function createResourcesRouter(getAgent: GetAgentFn): OpenAPIHono<import("hono").Env, {
     "/resources": {
         $get: {
             input: {};

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

@@ -1 +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"}
+{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/resources.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAEhE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAwD9C,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAqEzD"}

package/dist/hono/routes/resources.js

@@ -66,16 +66,16 @@ function createResourcesRouter(getAgent) {
     }
   });
   return app.openapi(listRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const resources = await agent.listResources();
     return ctx.json({ ok: true, resources: Object.values(resources) });
   }).openapi(getContentRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     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 agent = await getAgent(ctx);
     const { resourceId } = ctx.req.valid("param");
     const exists = await agent.hasResource(resourceId);
     return ctx.body(null, exists ? 200 : 404);

package/dist/hono/routes/search.cjs

@@ -64,7 +64,7 @@ function createSearchRouter(getAgent) {
     }
   });
   return app.openapi(messagesRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { q, limit, offset, sessionId, role } = ctx.req.valid("query");
     const options = {
       limit: limit || 20,
@@ -75,7 +75,7 @@ function createSearchRouter(getAgent) {
     const searchResults = await agent.searchMessages(q, options);
     return ctx.json(searchResults);
   }).openapi(sessionsRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { q } = ctx.req.valid("query");
     const searchResults = await agent.searchSessions(q);
     return ctx.json(searchResults);

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

@@ -1,6 +1,8 @@
 import { OpenAPIHono } from '@hono/zod-openapi';
 import type { DextoAgent } from '@dexto/core';
-export declare function createSearchRouter(getAgent: () => DextoAgent): OpenAPIHono<import("hono").Env, {
+import type { Context } from 'hono';
+type GetAgentFn = (ctx: Context) => DextoAgent | Promise<DextoAgent>;
+export declare function createSearchRouter(getAgent: GetAgentFn): OpenAPIHono<import("hono").Env, {
     "/search/messages": {
         $get: {
             input: {
@@ -54,7 +56,7 @@ export declare function createSearchRouter(getAgent: () => DextoAgent): OpenAPIH
                             totalTokens?: number | undefined;
                         } | undefined;
                         model?: string | undefined;
-                        provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
+                        provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | undefined;
                         toolCalls?: {
                             function: {
                                 name: string;
@@ -136,7 +138,7 @@ export declare function createSearchRouter(getAgent: () => DextoAgent): OpenAPIH
                                 totalTokens?: number | undefined;
                             } | undefined;
                             model?: string | undefined;
-                            provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
+                            provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | undefined;
                             toolCalls?: {
                                 function: {
                                     name: string;
@@ -162,4 +164,5 @@ export declare function createSearchRouter(getAgent: () => DextoAgent): OpenAPIH
         };
     };
 }, "/">;
+export {};
 //# sourceMappingURL=search.d.ts.map

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

@@ -1 +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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAwD5D"}
+{"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;AAE9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,KAAK,UAAU,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AA0BrE,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAwDtD"}

package/dist/hono/routes/search.js

@@ -41,7 +41,7 @@ function createSearchRouter(getAgent) {
     }
   });
   return app.openapi(messagesRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { q, limit, offset, sessionId, role } = ctx.req.valid("query");
     const options = {
       limit: limit || 20,
@@ -52,7 +52,7 @@ function createSearchRouter(getAgent) {
     const searchResults = await agent.searchMessages(q, options);
     return ctx.json(searchResults);
   }).openapi(sessionsRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { q } = ctx.req.valid("query");
     const searchResults = await agent.searchSessions(q);
     return ctx.json(searchResults);

package/dist/hono/routes/sessions.cjs

@@ -268,7 +268,7 @@ function createSessionsRouter(getAgent) {
     }
   });
   return app.openapi(listRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const sessionIds = await agent.listSessions();
     const sessions = await Promise.all(
       sessionIds.map(async (id) => {
@@ -294,7 +294,7 @@ function createSessionsRouter(getAgent) {
     );
     return ctx.json({ sessions });
   }).openapi(createRouteDef, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("json");
     const session = await agent.createSession(sessionId);
     const metadata = await agent.getSessionMetadata(session.id);
@@ -311,7 +311,7 @@ function createSessionsRouter(getAgent) {
       201
     );
   }).openapi(getRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.param();
     const metadata = await agent.getSessionMetadata(sessionId);
     const history = await agent.getSessionHistory(sessionId);
@@ -326,7 +326,7 @@ function createSessionsRouter(getAgent) {
       }
     });
   }).openapi(historyRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.param();
     const [history, isBusy] = await Promise.all([
       agent.getSessionHistory(sessionId),
@@ -337,12 +337,12 @@ function createSessionsRouter(getAgent) {
       isBusy
     });
   }).openapi(deleteRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.param();
     await agent.deleteSession(sessionId);
     return ctx.json({ status: "deleted", sessionId });
   }).openapi(cancelRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("param");
     let clearQueue = false;
     try {
@@ -371,7 +371,7 @@ function createSessionsRouter(getAgent) {
       clearedCount
     });
   }).openapi(loadRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("param");
     const sessionIds = await agent.listSessions();
     if (!sessionIds.includes(sessionId)) {
@@ -393,7 +393,7 @@ function createSessionsRouter(getAgent) {
       200
     );
   }).openapi(patchRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("param");
     const { title } = ctx.req.valid("json");
     await agent.setSessionTitle(sessionId, title);
@@ -408,7 +408,7 @@ function createSessionsRouter(getAgent) {
       }
     });
   }).openapi(generateTitleRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("param");
     const title = await agent.generateSessionTitle(sessionId);
     return ctx.json({ title, sessionId });

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

@@ -1,6 +1,6 @@
 import { OpenAPIHono } from '@hono/zod-openapi';
-import type { DextoAgent } from '@dexto/core';
-export declare function createSessionsRouter(getAgent: () => DextoAgent): OpenAPIHono<import("hono").Env, {
+import type { GetAgentFn } from '../index.js';
+export declare function createSessionsRouter(getAgent: GetAgentFn): OpenAPIHono<import("hono").Env, {
     "/sessions": {
         $get: {
             input: {};
@@ -108,7 +108,7 @@ export declare function createSessionsRouter(getAgent: () => DextoAgent): OpenAP
                         totalTokens?: number | undefined;
                     } | undefined;
                     model?: string | undefined;
-                    provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
+                    provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | undefined;
                     toolCalls?: {
                         function: {
                             name: string;

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

@@ -1 +1 @@
-{"version":3,"file":"sessions.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/sessions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAS9C,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAie9D"}
+{"version":3,"file":"sessions.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/sessions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAEhE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAQ9C,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAiexD"}

package/dist/hono/routes/sessions.js

@@ -245,7 +245,7 @@ function createSessionsRouter(getAgent) {
     }
   });
   return app.openapi(listRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const sessionIds = await agent.listSessions();
     const sessions = await Promise.all(
       sessionIds.map(async (id) => {
@@ -271,7 +271,7 @@ function createSessionsRouter(getAgent) {
     );
     return ctx.json({ sessions });
   }).openapi(createRouteDef, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("json");
     const session = await agent.createSession(sessionId);
     const metadata = await agent.getSessionMetadata(session.id);
@@ -288,7 +288,7 @@ function createSessionsRouter(getAgent) {
       201
     );
   }).openapi(getRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.param();
     const metadata = await agent.getSessionMetadata(sessionId);
     const history = await agent.getSessionHistory(sessionId);
@@ -303,7 +303,7 @@ function createSessionsRouter(getAgent) {
       }
     });
   }).openapi(historyRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.param();
     const [history, isBusy] = await Promise.all([
       agent.getSessionHistory(sessionId),
@@ -314,12 +314,12 @@ function createSessionsRouter(getAgent) {
       isBusy
     });
   }).openapi(deleteRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.param();
     await agent.deleteSession(sessionId);
     return ctx.json({ status: "deleted", sessionId });
   }).openapi(cancelRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("param");
     let clearQueue = false;
     try {
@@ -348,7 +348,7 @@ function createSessionsRouter(getAgent) {
       clearedCount
     });
   }).openapi(loadRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("param");
     const sessionIds = await agent.listSessions();
     if (!sessionIds.includes(sessionId)) {
@@ -370,7 +370,7 @@ function createSessionsRouter(getAgent) {
       200
     );
   }).openapi(patchRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("param");
     const { title } = ctx.req.valid("json");
     await agent.setSessionTitle(sessionId, title);
@@ -385,7 +385,7 @@ function createSessionsRouter(getAgent) {
       }
     });
   }).openapi(generateTitleRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("param");
     const title = await agent.generateSessionTitle(sessionId);
     return ctx.json({ title, sessionId });

package/dist/hono/routes/tools.cjs

@@ -0,0 +1,126 @@
+"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 tools_exports = {};
+__export(tools_exports, {
+  createToolsRouter: () => createToolsRouter
+});
+module.exports = __toCommonJS(tools_exports);
+var import_zod_openapi = require("@hono/zod-openapi");
+const JsonSchemaProperty = import_zod_openapi.z.object({
+  type: import_zod_openapi.z.enum(["string", "number", "integer", "boolean", "object", "array"]).optional().describe("Property type"),
+  description: import_zod_openapi.z.string().optional().describe("Property description"),
+  enum: import_zod_openapi.z.array(import_zod_openapi.z.union([import_zod_openapi.z.string(), import_zod_openapi.z.number(), import_zod_openapi.z.boolean()])).optional().describe("Enum values"),
+  default: import_zod_openapi.z.any().optional().describe("Default value")
+}).passthrough().describe("JSON Schema property definition");
+const ToolInputSchema = import_zod_openapi.z.object({
+  type: import_zod_openapi.z.literal("object").optional().describe('Schema type, always "object" when present'),
+  properties: import_zod_openapi.z.record(JsonSchemaProperty).optional().describe("Property definitions"),
+  required: import_zod_openapi.z.array(import_zod_openapi.z.string()).optional().describe("Required property names")
+}).passthrough().describe("JSON Schema for tool input parameters");
+const ToolInfoSchema = import_zod_openapi.z.object({
+  id: import_zod_openapi.z.string().describe("Tool identifier"),
+  name: import_zod_openapi.z.string().describe("Tool name"),
+  description: import_zod_openapi.z.string().describe("Tool description"),
+  source: import_zod_openapi.z.enum(["internal", "custom", "mcp"]).describe("Source of the tool (internal, custom, or mcp)"),
+  serverName: import_zod_openapi.z.string().optional().describe("MCP server name (if source is mcp)"),
+  inputSchema: ToolInputSchema.optional().describe("JSON Schema for tool input parameters")
+}).strict().describe("Tool information");
+const AllToolsResponseSchema = import_zod_openapi.z.object({
+  tools: import_zod_openapi.z.array(ToolInfoSchema).describe("Array of all available tools"),
+  totalCount: import_zod_openapi.z.number().describe("Total number of tools"),
+  internalCount: import_zod_openapi.z.number().describe("Number of internal tools"),
+  customCount: import_zod_openapi.z.number().describe("Number of custom tools"),
+  mcpCount: import_zod_openapi.z.number().describe("Number of MCP tools")
+}).strict().describe("All available tools from all sources");
+function createToolsRouter(getAgent) {
+  const app = new import_zod_openapi.OpenAPIHono();
+  const allToolsRoute = (0, import_zod_openapi.createRoute)({
+    method: "get",
+    path: "/tools",
+    summary: "List All Tools",
+    description: "Retrieves all available tools from all sources (internal, custom, and MCP servers)",
+    tags: ["tools"],
+    responses: {
+      200: {
+        description: "All tools",
+        content: { "application/json": { schema: AllToolsResponseSchema } }
+      }
+    }
+  });
+  return app.openapi(allToolsRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
+    const allTools = await agent.getAllTools();
+    const mcpToolsWithServerInfo = agent.getAllMcpToolsWithServerInfo();
+    const toolList = [];
+    let internalCount = 0;
+    let customCount = 0;
+    let mcpCount = 0;
+    for (const [toolName, toolInfo] of Object.entries(allTools)) {
+      let source;
+      let serverName;
+      if (toolName.startsWith("mcp--")) {
+        const mcpToolName = toolName.substring(5);
+        const mcpToolInfo = mcpToolsWithServerInfo.get(mcpToolName);
+        if (mcpToolInfo) {
+          source = "mcp";
+          serverName = mcpToolInfo.serverName;
+          mcpCount++;
+        } else {
+          source = "mcp";
+          mcpCount++;
+        }
+      } else if (toolName.startsWith("internal--")) {
+        source = "internal";
+        internalCount++;
+      } else if (toolName.startsWith("custom--")) {
+        source = "custom";
+        customCount++;
+      } else {
+        source = "internal";
+        internalCount++;
+      }
+      toolList.push({
+        id: toolName,
+        name: toolName,
+        description: toolInfo.description || "No description available",
+        source,
+        serverName,
+        inputSchema: toolInfo.parameters
+      });
+    }
+    toolList.sort((a, b) => {
+      const sourceOrder = { internal: 0, custom: 1, mcp: 2 };
+      if (a.source !== b.source) {
+        return sourceOrder[a.source] - sourceOrder[b.source];
+      }
+      return a.name.localeCompare(b.name);
+    });
+    return ctx.json({
+      tools: toolList,
+      totalCount: toolList.length,
+      internalCount,
+      customCount,
+      mcpCount
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createToolsRouter
+});

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

@@ -0,0 +1,42 @@
+import { OpenAPIHono } from '@hono/zod-openapi';
+import type { DextoAgent } from '@dexto/core';
+import type { Context } from 'hono';
+type GetAgentFn = (ctx: Context) => DextoAgent | Promise<DextoAgent>;
+export declare function createToolsRouter(getAgent: GetAgentFn): OpenAPIHono<import("hono").Env, {
+    "/tools": {
+        $get: {
+            input: {};
+            output: {
+                tools: {
+                    description: string;
+                    id: string;
+                    name: string;
+                    source: "custom" | "mcp" | "internal";
+                    serverName?: string | undefined;
+                    inputSchema?: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                        type?: "object" | undefined;
+                        properties?: {
+                            [x: string]: {
+                                [x: string]: import("hono/utils/types").JSONValue;
+                                description?: string | undefined;
+                                default?: any;
+                                type?: "string" | "number" | "boolean" | "object" | "integer" | "array" | undefined;
+                                enum?: (string | number | boolean)[] | undefined;
+                            };
+                        } | undefined;
+                        required?: string[] | undefined;
+                    } | undefined;
+                }[];
+                totalCount: number;
+                internalCount: number;
+                customCount: number;
+                mcpCount: number;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">;
+export {};
+//# sourceMappingURL=tools.d.ts.map

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

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