@dexto/server 1.4.0 → 1.5.0

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

@@ -1,5 +1,7 @@
-import { OpenAPIHono, z } from '@hono/zod-openapi';
+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 type AgentsRouterContext = {
     switchAgentById: (agentId: string) => Promise<{
         id: string;
@@ -16,7 +18,7 @@ export type AgentsRouterContext = {
     ensureAgentAvailable: () => void;
     getActiveAgentId: () => string | undefined;
 };
-export declare function createAgentsRouter(getAgent: () => DextoAgent, context: AgentsRouterContext): OpenAPIHono<import("hono").Env, {
+export declare function createAgentsRouter(getAgent: GetAgentFn, context: AgentsRouterContext): OpenAPIHono<import("hono").Env, {
     "/agents": {
         $get: {
             input: {};
@@ -75,7 +77,6 @@ export declare function createAgentsRouter(getAgent: () => DextoAgent, context:
                     id: string;
                     sourcePath: string;
                     name?: string | undefined;
-                    injectPreferences?: boolean | undefined;
                 };
             };
             output: {
@@ -147,410 +148,7 @@ export declare function createAgentsRouter(getAgent: () => DextoAgent, context:
             input: {
                 json: {
                     description: string;
-                    config: {
-                        llm: {
-                            model: string;
-                            provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
-                            apiKey: string;
-                            maxIterations?: number | undefined;
-                            baseURL?: string | undefined;
-                            maxInputTokens?: number | undefined;
-                            maxOutputTokens?: number | undefined;
-                            temperature?: number | undefined;
-                            allowedMediaTypes?: string[] | undefined;
-                        };
-                        systemPrompt: string | {
-                            contributors?: ({
-                                type: "static";
-                                content: string;
-                                id: string;
-                                priority: number;
-                                enabled?: boolean | undefined;
-                            } | {
-                                type: "dynamic";
-                                id: string;
-                                source: "resources" | "dateTime";
-                                priority: number;
-                                enabled?: boolean | undefined;
-                            } | {
-                                type: "file";
-                                id: string;
-                                priority: number;
-                                files: string[];
-                                options?: {
-                                    includeFilenames?: boolean | undefined;
-                                    separator?: string | undefined;
-                                    errorHandling?: "error" | "skip" | undefined;
-                                    maxFileSize?: number | undefined;
-                                    includeMetadata?: boolean | undefined;
-                                } | undefined;
-                                enabled?: boolean | undefined;
-                            })[] | undefined;
-                        };
-                        tools?: Record<string, {
-                            maxOutputChars?: number | undefined;
-                            maxLines?: number | undefined;
-                            maxLineLength?: number | undefined;
-                        }> | undefined;
-                        storage?: {
-                            database: {
-                                type: "in-memory";
-                                options?: Record<string, any> | undefined;
-                                maxConnections?: number | undefined;
-                                idleTimeoutMillis?: number | undefined;
-                                connectionTimeoutMillis?: number | undefined;
-                            } | {
-                                path: string;
-                                type: "sqlite";
-                                options?: Record<string, any> | undefined;
-                                maxConnections?: number | undefined;
-                                idleTimeoutMillis?: number | undefined;
-                                connectionTimeoutMillis?: number | undefined;
-                            } | {
-                                type: "postgres";
-                                password?: string | undefined;
-                                options?: Record<string, any> | undefined;
-                                url?: string | undefined;
-                                maxConnections?: number | undefined;
-                                idleTimeoutMillis?: number | undefined;
-                                connectionTimeoutMillis?: number | undefined;
-                                host?: string | undefined;
-                                port?: number | undefined;
-                                database?: string | undefined;
-                                connectionString?: string | undefined;
-                            };
-                            cache: {
-                                type: "in-memory";
-                                options?: Record<string, any> | undefined;
-                                maxConnections?: number | undefined;
-                                idleTimeoutMillis?: number | undefined;
-                                connectionTimeoutMillis?: number | undefined;
-                            } | {
-                                type: "redis";
-                                password?: string | undefined;
-                                options?: Record<string, any> | undefined;
-                                url?: string | undefined;
-                                maxConnections?: number | undefined;
-                                idleTimeoutMillis?: number | undefined;
-                                connectionTimeoutMillis?: number | undefined;
-                                host?: string | undefined;
-                                port?: number | undefined;
-                                database?: number | undefined;
-                            };
-                            blob: {
-                                type: "in-memory";
-                                maxBlobSize?: number | undefined;
-                                maxTotalSize?: number | undefined;
-                            } | {
-                                type: "local";
-                                storePath: string;
-                                maxBlobSize?: number | undefined;
-                                maxTotalSize?: number | undefined;
-                                cleanupAfterDays?: number | undefined;
-                            };
-                        } | undefined;
-                        telemetry?: {
-                            enabled?: boolean | undefined;
-                            serviceName?: string | undefined;
-                            tracerName?: string | undefined;
-                            export?: {
-                                type: "otlp";
-                                headers?: Record<string, string> | undefined;
-                                protocol?: "http" | "grpc" | undefined;
-                                endpoint?: string | undefined;
-                            } | {
-                                type: "console";
-                            } | undefined;
-                        } | undefined;
-                        logger?: {
-                            level?: "debug" | "info" | "warn" | "error" | "silly" | undefined;
-                            transports?: ({
-                                type: "console";
-                                colorize?: boolean | undefined;
-                            } | {
-                                path: string;
-                                type: "file";
-                                maxFiles?: number | undefined;
-                                maxSize?: number | undefined;
-                            } | {
-                                token: string;
-                                type: "upstash";
-                                url: string;
-                                listName?: string | undefined;
-                                maxListLength?: number | undefined;
-                                batchSize?: number | undefined;
-                            })[] | undefined;
-                        } | undefined;
-                        elicitation?: {
-                            timeout?: number | undefined;
-                            enabled?: boolean | undefined;
-                        } | undefined;
-                        prompts?: ({
-                            prompt: string;
-                            type: "inline";
-                            id: string;
-                            description?: string | undefined;
-                            title?: string | undefined;
-                            priority?: number | undefined;
-                            category?: string | undefined;
-                            showInStarters?: boolean | undefined;
-                        } | {
-                            file: string;
-                            type: "file";
-                            showInStarters?: boolean | undefined;
-                        })[] | undefined;
-                        agentId?: string | undefined;
-                        agentCard?: {
-                            description: string;
-                            name: string;
-                            url: string;
-                            version: string;
-                            provider?: {
-                                url: string;
-                                organization: string;
-                            } | undefined;
-                            metadata?: z.objectInputType<{
-                                dexto: z.ZodOptional<z.ZodObject<{
-                                    authentication: z.ZodOptional<z.ZodObject<{
-                                        schemes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
-                                        credentials: z.ZodOptional<z.ZodString>;
-                                    }, "strict", z.ZodTypeAny, {
-                                        schemes: string[];
-                                        credentials?: string | undefined;
-                                    }, {
-                                        schemes?: string[] | undefined;
-                                        credentials?: string | undefined;
-                                    }>>;
-                                    delegation: z.ZodOptional<z.ZodObject<{
-                                        protocol: z.ZodEnum<["dexto-v1", "http-simple", "a2a-jsonrpc", "mcp-http"]>;
-                                        endpoint: z.ZodString;
-                                        supportsSession: z.ZodBoolean;
-                                        supportsStreaming: z.ZodOptional<z.ZodBoolean>;
-                                    }, "strict", z.ZodTypeAny, {
-                                        protocol: "dexto-v1" | "http-simple" | "a2a-jsonrpc" | "mcp-http";
-                                        endpoint: string;
-                                        supportsSession: boolean;
-                                        supportsStreaming?: boolean | undefined;
-                                    }, {
-                                        protocol: "dexto-v1" | "http-simple" | "a2a-jsonrpc" | "mcp-http";
-                                        endpoint: string;
-                                        supportsSession: boolean;
-                                        supportsStreaming?: boolean | undefined;
-                                    }>>;
-                                    owner: z.ZodOptional<z.ZodObject<{
-                                        userId: z.ZodString;
-                                        username: z.ZodString;
-                                        email: z.ZodOptional<z.ZodString>;
-                                    }, "strict", z.ZodTypeAny, {
-                                        userId: string;
-                                        username: string;
-                                        email?: string | undefined;
-                                    }, {
-                                        userId: string;
-                                        username: string;
-                                        email?: string | undefined;
-                                    }>>;
-                                }, "strict", z.ZodTypeAny, {
-                                    authentication?: {
-                                        schemes: string[];
-                                        credentials?: string | undefined;
-                                    } | undefined;
-                                    delegation?: {
-                                        protocol: "dexto-v1" | "http-simple" | "a2a-jsonrpc" | "mcp-http";
-                                        endpoint: string;
-                                        supportsSession: boolean;
-                                        supportsStreaming?: boolean | undefined;
-                                    } | undefined;
-                                    owner?: {
-                                        userId: string;
-                                        username: string;
-                                        email?: string | undefined;
-                                    } | undefined;
-                                }, {
-                                    authentication?: {
-                                        schemes?: string[] | undefined;
-                                        credentials?: string | undefined;
-                                    } | undefined;
-                                    delegation?: {
-                                        protocol: "dexto-v1" | "http-simple" | "a2a-jsonrpc" | "mcp-http";
-                                        endpoint: string;
-                                        supportsSession: boolean;
-                                        supportsStreaming?: boolean | undefined;
-                                    } | undefined;
-                                    owner?: {
-                                        userId: string;
-                                        username: string;
-                                        email?: string | undefined;
-                                    } | undefined;
-                                }>>;
-                            }, z.ZodTypeAny, "passthrough"> | undefined;
-                            capabilities?: {
-                                streaming?: boolean | undefined;
-                                pushNotifications?: boolean | undefined;
-                                stateTransitionHistory?: boolean | undefined;
-                            } | undefined;
-                            protocolVersion?: string | undefined;
-                            preferredTransport?: "JSONRPC" | "GRPC" | "HTTP+JSON" | undefined;
-                            defaultInputModes?: string[] | undefined;
-                            defaultOutputModes?: string[] | undefined;
-                            skills?: {
-                                description: string;
-                                name: string;
-                                id: string;
-                                tags: string[];
-                                examples?: string[] | undefined;
-                                inputModes?: string[] | undefined;
-                                outputModes?: string[] | undefined;
-                            }[] | undefined;
-                            iconUrl?: string | undefined;
-                            documentationUrl?: string | undefined;
-                            additionalInterfaces?: {
-                                url: string;
-                                transport: "JSONRPC" | "GRPC" | "HTTP+JSON";
-                            }[] | undefined;
-                            securitySchemes?: Record<string, {
-                                type: "apiKey";
-                                name: string;
-                                in: "query" | "header" | "cookie";
-                                description?: string | undefined;
-                            } | {
-                                type: "http";
-                                scheme: string;
-                                description?: string | undefined;
-                                bearerFormat?: string | undefined;
-                            } | {
-                                type: "oauth2";
-                                flows: {
-                                    password?: {
-                                        scopes: Record<string, string>;
-                                        authorizationUrl?: string | undefined;
-                                        tokenUrl?: string | undefined;
-                                        refreshUrl?: string | undefined;
-                                    } | undefined;
-                                    implicit?: {
-                                        scopes: Record<string, string>;
-                                        authorizationUrl?: string | undefined;
-                                        tokenUrl?: string | undefined;
-                                        refreshUrl?: string | undefined;
-                                    } | undefined;
-                                    clientCredentials?: {
-                                        scopes: Record<string, string>;
-                                        authorizationUrl?: string | undefined;
-                                        tokenUrl?: string | undefined;
-                                        refreshUrl?: string | undefined;
-                                    } | undefined;
-                                    authorizationCode?: {
-                                        scopes: Record<string, string>;
-                                        authorizationUrl?: string | undefined;
-                                        tokenUrl?: string | undefined;
-                                        refreshUrl?: string | undefined;
-                                    } | undefined;
-                                };
-                                description?: string | undefined;
-                            } | {
-                                type: "openIdConnect";
-                                openIdConnectUrl: string;
-                                description?: string | undefined;
-                            } | {
-                                type: "mutualTLS";
-                                description?: string | undefined;
-                            }> | undefined;
-                            security?: Record<string, string[]>[] | undefined;
-                            supportsAuthenticatedExtendedCard?: boolean | undefined;
-                            signatures?: {
-                                protected: string;
-                                signature: string;
-                            }[] | undefined;
-                        } | undefined;
-                        greeting?: string | undefined;
-                        memories?: {
-                            enabled?: boolean | undefined;
-                            limit?: number | undefined;
-                            priority?: number | undefined;
-                            includeTimestamps?: boolean | undefined;
-                            includeTags?: boolean | undefined;
-                            pinnedOnly?: boolean | undefined;
-                        } | undefined;
-                        mcpServers?: Record<string, {
-                            type: "stdio";
-                            command: string;
-                            timeout?: number | undefined;
-                            enabled?: boolean | undefined;
-                            args?: string[] | undefined;
-                            env?: Record<string, string> | undefined;
-                            connectionMode?: "strict" | "lenient" | undefined;
-                        } | {
-                            type: "sse";
-                            url: string;
-                            timeout?: number | undefined;
-                            enabled?: boolean | undefined;
-                            connectionMode?: "strict" | "lenient" | undefined;
-                            headers?: Record<string, string> | undefined;
-                        } | {
-                            type: "http";
-                            url: string;
-                            timeout?: number | undefined;
-                            enabled?: boolean | undefined;
-                            connectionMode?: "strict" | "lenient" | undefined;
-                            headers?: Record<string, string> | undefined;
-                        }> | undefined;
-                        internalTools?: ("search_history" | "ask_user" | "read_file" | "glob_files" | "grep_content" | "write_file" | "edit_file" | "bash_exec" | "bash_output" | "kill_process" | "delegate_to_url")[] | undefined;
-                        sessions?: {
-                            maxSessions?: number | undefined;
-                            sessionTTL?: number | undefined;
-                        } | undefined;
-                        toolConfirmation?: {
-                            timeout?: number | undefined;
-                            mode?: "manual" | "auto-approve" | "auto-deny" | undefined;
-                            allowedToolsStorage?: "storage" | "memory" | undefined;
-                            toolPolicies?: {
-                                alwaysAllow?: string[] | undefined;
-                                alwaysDeny?: string[] | undefined;
-                            } | undefined;
-                        } | undefined;
-                        internalResources?: ({
-                            type: "filesystem";
-                            paths: string[];
-                            maxFiles?: number | undefined;
-                            maxDepth?: number | undefined;
-                            includeHidden?: boolean | undefined;
-                            includeExtensions?: string[] | undefined;
-                        } | {
-                            type: "blob";
-                        })[] | {
-                            enabled?: boolean | undefined;
-                            resources?: ({
-                                type: "filesystem";
-                                paths: string[];
-                                maxFiles?: number | undefined;
-                                maxDepth?: number | undefined;
-                                includeHidden?: boolean | undefined;
-                                includeExtensions?: string[] | undefined;
-                            } | {
-                                type: "blob";
-                            })[] | undefined;
-                        } | undefined;
-                        plugins?: {
-                            custom?: {
-                                name: string;
-                                priority: number;
-                                module: string;
-                                blocking: boolean;
-                                config?: Record<string, any> | undefined;
-                                enabled?: boolean | undefined;
-                            }[] | undefined;
-                            contentPolicy?: z.objectInputType<{
-                                priority: z.ZodNumber;
-                                blocking: z.ZodOptional<z.ZodBoolean>;
-                                enabled: z.ZodDefault<z.ZodBoolean>;
-                            }, z.ZodTypeAny, "passthrough"> | undefined;
-                            responseSanitizer?: z.objectInputType<{
-                                priority: z.ZodNumber;
-                                blocking: z.ZodOptional<z.ZodBoolean>;
-                                enabled: z.ZodDefault<z.ZodBoolean>;
-                            }, z.ZodTypeAny, "passthrough"> | undefined;
-                        } | undefined;
-                    };
+                    config: Record<string, any>;
                     id: string;
                     name: string;
                     tags?: string[] | undefined;
@@ -657,4 +255,5 @@ export declare function createAgentsRouter(getAgent: () => DextoAgent, context:
         };
     };
 }, "/">;
+export {};
 //# sourceMappingURL=agents.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"agents.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/agents.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"agents.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/agents.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAsB9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,KAAK,UAAU,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AA8MrE,MAAM,MAAM,mBAAmB,GAAG;IAC9B,eAAe,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC5E,iBAAiB,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC/E,gBAAgB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC7E,oBAAoB,EAAE,MAAM,IAAI,CAAC;IACjC,gBAAgB,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;CAC9C,CAAC;AAEF,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,UAAU,EAAE,OAAO,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA6sBpF"}

package/dist/hono/routes/agents.js

@@ -19,6 +19,9 @@ import path from "path";
 import { promises as fs } from "fs";
 import { DextoValidationError, AgentErrorCode, ErrorScope, ErrorType } from "@dexto/core";
 import { AgentRegistryEntrySchema } from "../schemas/responses.js";
+const AgentConfigSchemaForOpenAPI = z.record(z.any()).describe(
+  "Complete agent configuration. See AgentConfig type documentation for full schema details."
+);
 const AgentIdentifierSchema = z.object({
   id: z.string().min(1, "Agent id is required").describe('Unique agent identifier (e.g., "database-agent")'),
   path: z.string().optional().describe(
@@ -38,16 +41,14 @@ const CustomAgentInstallSchema = z.object({
     author: z.string().min(1).describe("Agent author or organization name"),
     tags: z.array(z.string()).describe("Tags for categorizing the agent"),
     main: z.string().optional().describe("Main configuration file name within source directory")
-  }).strict().describe("Agent metadata including description, author, and tags"),
-  injectPreferences: z.boolean().default(true).describe("Whether to inject user preferences into agent config")
+  }).strict().describe("Agent metadata including description, author, and tags")
 }).strict().describe("Request body for installing a custom agent from file system").transform((value) => {
   const displayName = value.name?.trim() || deriveDisplayName(value.id);
   return {
     id: value.id,
     displayName,
     sourcePath: value.sourcePath,
-    metadata: value.metadata,
-    injectPreferences: value.injectPreferences
+    metadata: value.metadata
   };
 });
 const CustomAgentCreateSchema = z.object({
@@ -61,7 +62,7 @@ const CustomAgentCreateSchema = z.object({
   author: z.string().optional().describe("Author or organization"),
   tags: z.array(z.string()).default([]).describe("Tags for discovery"),
   // Full agent configuration
-  config: AgentConfigSchema.describe("Complete agent configuration")
+  config: AgentConfigSchemaForOpenAPI.describe("Complete agent configuration")
 }).strict().describe("Request body for creating a new custom agent with full configuration");
 const AgentConfigValidateSchema = z.object({
   yaml: z.string().describe("YAML agent configuration content to validate")
@@ -405,18 +406,13 @@ function createAgentsRouter(getAgent, context) {
   }).openapi(installRoute, async (ctx) => {
     const body = ctx.req.valid("json");
     if ("sourcePath" in body && "metadata" in body) {
-      const { id, displayName, sourcePath, metadata, injectPreferences } = body;
-      await AgentFactory.installCustomAgent(
-        id,
-        sourcePath,
-        {
-          name: displayName,
-          description: metadata.description,
-          author: metadata.author,
-          tags: metadata.tags
-        },
-        injectPreferences
-      );
+      const { id, displayName, sourcePath, metadata } = body;
+      await AgentFactory.installCustomAgent(id, sourcePath, {
+        name: displayName,
+        description: metadata.description,
+        author: metadata.author,
+        tags: metadata.tags
+      });
       return ctx.json(
         { installed: true, id, name: displayName, type: "custom" },
         201
@@ -496,18 +492,12 @@ function createAgentsRouter(getAgent, context) {
     const tmpFile = path.join(tmpDir, `${id}-${Date.now()}.yml`);
     await fs.writeFile(tmpFile, yamlContent, "utf-8");
     try {
-      await AgentFactory.installCustomAgent(
-        id,
-        tmpFile,
-        {
-          name,
-          description,
-          author: author || "Custom",
-          tags: tags || []
-        },
-        false
-        // Don't inject preferences
-      );
+      await AgentFactory.installCustomAgent(id, tmpFile, {
+        name,
+        description,
+        author: author || "Custom",
+        tags: tags || []
+      });
       await fs.unlink(tmpFile).catch(() => {
       });
       return ctx.json({ created: true, id, name }, 201);
@@ -516,8 +506,8 @@ function createAgentsRouter(getAgent, context) {
       });
       throw installError;
     }
-  }).openapi(getPathRoute, (ctx) => {
-    const agent = getAgent();
+  }).openapi(getPathRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
     const agentPath = agent.getAgentFilePath();
     const relativePath = path.basename(agentPath);
     const ext = path.extname(agentPath);
@@ -526,10 +516,10 @@ function createAgentsRouter(getAgent, context) {
       path: agentPath,
       relativePath,
       name,
-      isDefault: name === "default-agent"
+      isDefault: name === "coding-agent"
     });
   }).openapi(getConfigRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const agentPath = agent.getAgentFilePath();
     const yamlContent = await fs.readFile(agentPath, "utf-8");
     const stats = await fs.stat(agentPath);
@@ -605,7 +595,7 @@ function createAgentsRouter(getAgent, context) {
       warnings
     });
   }).openapi(saveConfigRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { yaml } = ctx.req.valid("json");
     let parsed;
     try {
@@ -677,7 +667,7 @@ function createAgentsRouter(getAgent, context) {
       throw error;
     }
   }).openapi(exportConfigRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("query");
     const config = agent.getEffectiveConfig(sessionId);
     const maskedConfig = {

package/dist/hono/routes/approvals.cjs

@@ -107,7 +107,7 @@ function createApprovalsRouter(getAgent, approvalCoordinator) {
     }
   });
   return app.openapi(getPendingApprovalsRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("query");
     agent.logger.debug(`Fetching pending approvals for session ${sessionId}`);
     const pendingIds = agent.services.approvalManager.getPendingApprovals();
@@ -124,7 +124,7 @@ function createApprovalsRouter(getAgent, approvalCoordinator) {
       approvals
     });
   }).openapi(submitApprovalRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { approvalId } = ctx.req.valid("param");
     const { status, formData, rememberChoice } = ctx.req.valid("json");
     agent.logger.info(`Received approval decision for ${approvalId}: ${status}`);

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

@@ -1,7 +1,9 @@
 import { OpenAPIHono } from '@hono/zod-openapi';
 import { type DextoAgent, ApprovalStatus } from '@dexto/core';
 import type { ApprovalCoordinator } from '../../approval/approval-coordinator.js';
-export declare function createApprovalsRouter(getAgent: () => DextoAgent, approvalCoordinator?: ApprovalCoordinator): OpenAPIHono<import("hono").Env, {
+import type { Context } from 'hono';
+type GetAgentFn = (ctx: Context) => DextoAgent | Promise<DextoAgent>;
+export declare function createApprovalsRouter(getAgent: GetAgentFn, approvalCoordinator?: ApprovalCoordinator): OpenAPIHono<import("hono").Env, {
     "/approvals": {
         $get: {
             input: {
@@ -111,4 +113,5 @@ export declare function createApprovalsRouter(getAgent: () => DextoAgent, approv
         };
     };
 }, "/">;
+export {};
 //# sourceMappingURL=approvals.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"approvals.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/approvals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,EAAE,KAAK,UAAU,EAAgB,cAAc,EAAiB,MAAM,aAAa,CAAC;AAC3F,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AA8ClF,wBAAgB,qBAAqB,CACjC,QAAQ,EAAE,MAAM,UAAU,EAC1B,mBAAmB,CAAC,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAgK5C"}
+{"version":3,"file":"approvals.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/approvals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,EAAE,KAAK,UAAU,EAAgB,cAAc,EAAiB,MAAM,aAAa,CAAC;AAC3F,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAClF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,KAAK,UAAU,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AA8CrE,wBAAgB,qBAAqB,CACjC,QAAQ,EAAE,UAAU,EACpB,mBAAmB,CAAC,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAgK5C"}

package/dist/hono/routes/approvals.js

@@ -84,7 +84,7 @@ function createApprovalsRouter(getAgent, approvalCoordinator) {
     }
   });
   return app.openapi(getPendingApprovalsRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("query");
     agent.logger.debug(`Fetching pending approvals for session ${sessionId}`);
     const pendingIds = agent.services.approvalManager.getPendingApprovals();
@@ -101,7 +101,7 @@ function createApprovalsRouter(getAgent, approvalCoordinator) {
       approvals
     });
   }).openapi(submitApprovalRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { approvalId } = ctx.req.valid("param");
     const { status, formData, rememberChoice } = ctx.req.valid("json");
     agent.logger.info(`Received approval decision for ${approvalId}: ${status}`);