@artinet/fleet 0.1.5 → 0.1.7

package/dist/server/express/agent-request.d.ts

@@ -2,12 +2,8 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import express from "express";
-import { RequestAgentRoute, RequestContext } from "../../routes/request/index.js";
-export declare const AGENT_FIELD_NAME = "agentId";
-export type handler = (req: express.Request, res: express.Response, next: express.NextFunction, context: RequestContext, request?: RequestAgentRoute["implementation"], intercepts?: RequestAgentRoute["intercept"][]) => Promise<void>;
-export declare function handle(req: express.Request, res: express.Response, _next: express.NextFunction, context: RequestContext, request?: RequestAgentRoute["implementation"], intercepts?: RequestAgentRoute["intercept"][]): Promise<void>;
-export declare const factory: (request?: RequestAgentRoute["implementation"], intercepts?: RequestAgentRoute["intercept"][]) => handler;
+import { RequestAgentMount } from '../../routes/request/index.js';
+import { Session } from './types.js';
 /**
  * Handler utilities for agent HTTP requests.
  *
@@ -19,12 +15,7 @@ export declare const factory: (request?: RequestAgentRoute["implementation"], in
  *
  * @module server/handlers/agent
  */
-export interface Params {
-    request: express.Request;
-    response: express.Response;
-    next: express.NextFunction;
-    context: Omit<RequestContext, "agentId">;
-    handler: handler;
-    user: (request: express.Request) => Promise<string>;
-}
-export declare function request({ request: req, response: res, next, context, handler, user, }: Params): Promise<void>;
+export type Mount = RequestAgentMount<Session>;
+export declare const factory: Mount['factory'];
+export declare const handle: Mount['handler'];
+export declare const request: Mount['request'];

package/dist/server/express/agent-request.js

@@ -2,50 +2,54 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import { INVALID_REQUEST } from "@artinet/sdk";
-import { RequestAgent, } from "../../routes/request/index.js";
-import * as sdk from "@artinet/sdk";
-import { handleJSONRPCResponse } from "./rpc.js";
-import { generateRequestId } from "./utils.js";
-export const AGENT_FIELD_NAME = "agentId";
-export async function handle(req, res, _next, context, request = RequestAgent, intercepts) {
-    const requestId = generateRequestId(context, req);
+import { INVALID_REQUEST } from '@artinet/sdk';
+import { RequestAgent } from '../../routes/request/index.js';
+import * as sdk from '@artinet/sdk';
+import { handleJSONRPCResponse } from './rpc.js';
+import { generateRequestId } from './utils.js';
+import { AGENT_FIELD_NAME } from '../../default.js';
+export const factory = ({ implementation = RequestAgent, }) => {
+    return async (params) => {
+        return await handle(params, implementation);
+    };
+};
+export const handle = async ({ session: { request, response }, context, intercepts }, implementation = RequestAgent) => {
+    const requestId = generateRequestId(context, request);
     let parsed;
-    if (req?.path?.endsWith("agent-card.json") ||
-        req?.path?.endsWith("agent.json")) {
+    if (request?.path?.endsWith('agent-card.json') || request?.path?.endsWith('agent.json')) {
         parsed = {
-            jsonrpc: "2.0",
+            jsonrpc: '2.0',
             id: requestId,
-            method: "agentcard/get",
+            method: 'agentcard/get',
             params: null,
         };
     }
     else {
-        parsed = await sdk.validateSchema(sdk.A2A.A2ARequestSchema, req?.body ?? {});
+        parsed = await sdk.validateSchema(sdk.A2A.A2ARequestSchema, request?.body ?? {});
     }
     const params = await sdk.validateSchema(sdk.A2A.RequestParamSchema, parsed.params);
-    const agentRequest = {
+    const req = {
         method: parsed.method,
         params: params,
     };
-    sdk.logger.info(`handle agent request received:${parsed.method}:params:${sdk.formatJson(agentRequest)}`);
-    const response = await request(agentRequest, context, intercepts);
-    sdk.logger.info(`handle agent request completed:${parsed.method}:response:${sdk.formatJson(response)}`);
-    await handleJSONRPCResponse(res, requestId, parsed.method, response);
-}
-export const factory = (request = RequestAgent, intercepts) => async (req, res, next, context) => await handle(req, res, next, context, request, intercepts);
-export async function request({ request: req, response: res, next, context, handler = handle, user, }) {
-    const agentId = Array.isArray(req?.params?.[AGENT_FIELD_NAME])
-        ? req?.params?.[AGENT_FIELD_NAME][0]
-        : req?.params?.[AGENT_FIELD_NAME];
+    sdk.logger.info(`handle agent request received:${parsed.method}:params:${sdk.formatJson(req)}`);
+    const res = await implementation(req, context, intercepts);
+    sdk.logger.info(`handle agent request completed:${parsed.method}:response:${sdk.formatJson(res)}`);
+    await handleJSONRPCResponse(response, requestId, parsed.method, res);
+};
+export const request = async ({ session, context, handler = handle, user, intercepts }, implementation = RequestAgent) => {
+    const { request, next } = session;
+    const agentId = Array.isArray(request?.params?.[AGENT_FIELD_NAME])
+        ? request?.params?.[AGENT_FIELD_NAME][0]
+        : request?.params?.[AGENT_FIELD_NAME];
     if (!agentId) {
         return next(INVALID_REQUEST({ message: `${AGENT_FIELD_NAME} is required` }));
     }
-    const requestContext = {
+    const _context = {
         ...context,
         agentId,
-        requestId: generateRequestId(context, req),
-        userId: await user?.(req),
+        requestId: generateRequestId(context, request),
+        userId: await user?.(session),
     };
-    await handler(req, res, next, requestContext);
-}
+    return await handler({ session, context: _context, intercepts }, implementation);
+};

package/dist/server/express/deploy-request.d.ts

@@ -2,17 +2,9 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import express from "express";
-import { CreateAgentRoute } from "../../routes/create/index.js";
-export type handler = (req: express.Request, res: express.Response, next: express.NextFunction, context: CreateAgentRoute["context"], deploy?: CreateAgentRoute["implementation"]) => Promise<void>;
-export declare function handle(req: express.Request, res: express.Response, _next: express.NextFunction, context: CreateAgentRoute["context"], deploy?: CreateAgentRoute["implementation"]): Promise<void>;
-export declare const factory: (deploy?: CreateAgentRoute["implementation"]) => handler;
-export interface Params {
-    request: express.Request;
-    response: express.Response;
-    next: express.NextFunction;
-    context: CreateAgentRoute["context"];
-    handler: handler;
-    user: (req: express.Request) => Promise<string>;
-}
-export declare function request({ request: req, response: res, next, context, handler, user, }: Params): Promise<void>;
+import { CreateAgentMount } from '../../routes/create/index.js';
+import { Session } from './types.js';
+export type Mount = CreateAgentMount<Session>;
+export declare const handle: Mount['handler'];
+export declare const factory: Mount['factory'];
+export declare const request: Mount['request'];

package/dist/server/express/deploy-request.js

@@ -2,23 +2,23 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import { CreateAgent, CreateAgentRequestSchema, } from "../../routes/create/index.js";
-import { generateRequestId, generateRegistrationId } from "./utils.js";
-import { logger, validateSchema, formatJson } from "@artinet/sdk";
-export async function handle(req, res, _next, context, deploy = CreateAgent) {
-    const request = await validateSchema(CreateAgentRequestSchema, req?.body ?? {});
-    logger.info(`deploying agent: ${request.config.name}`);
-    logger.debug(`deploying agent: ${formatJson(request)}`);
-    context.registrationId = generateRegistrationId(request.config.uri);
-    const result = await deploy(request, context);
-    res.json(result);
-}
-export const factory = (deploy = CreateAgent) => async (req, res, next, context) => await handle(req, res, next, context, deploy);
-export async function request({ request: req, response: res, next, context, handler = handle, user, }) {
-    const requestContext = {
+import { CreateAgent, CreateAgentRequestSchema, } from '../../routes/create/index.js';
+import { generateRequestId, generateRegistrationId } from './utils.js';
+import { logger, validateSchema, formatJson } from '@artinet/sdk';
+export const handle = async ({ session: { request, response }, context, intercepts }, implementation = CreateAgent) => {
+    const req = await validateSchema(CreateAgentRequestSchema, request?.body ?? {});
+    logger.info(`deploying agent: ${req.config.name}`);
+    logger.debug(`deploying agent: ${formatJson(req)}`);
+    context.registrationId = generateRegistrationId(req.config.uri);
+    const res = await implementation(req, context, intercepts);
+    response.json(res);
+};
+export const factory = ({ implementation = CreateAgent }) => async (params) => await handle(params, implementation);
+export const request = async ({ session, context, handler = handle, user, intercepts }, implementation = CreateAgent) => {
+    const _context = {
         ...context,
-        requestId: generateRequestId(context, req),
-        userId: await user?.(req),
+        requestId: generateRequestId(context, session.request),
+        userId: await user?.(session),
     };
-    return await handler(req, res, next, requestContext);
-}
+    return await handler({ session, context: _context, intercepts }, implementation);
+};

package/dist/server/express/server.d.ts

@@ -2,13 +2,14 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import { Server } from "http";
-import express from "express";
-import { CreateAgentRoute } from "../../routes/create/index.js";
-import { Settings as FleetSettings } from "../../settings.js";
-import * as agent from "./agent-request.js";
-import * as testing from "./test-request.js";
-import * as deployment from "./deploy-request.js";
+import { Server } from 'http';
+import express from 'express';
+import { CreateAgentRoute } from '../../routes/create/index.js';
+import { Settings as FleetSettings } from '../../settings.js';
+import * as agent from './agent-request.js';
+import * as testing from './test-request.js';
+import * as deployment from './deploy-request.js';
+import { Session } from './types.js';
 /**
  * Extended settings for the Express Fleet server.
  *
@@ -19,13 +20,13 @@ import * as deployment from "./deploy-request.js";
  */
 export type Settings = FleetSettings & {
     /** Extracts the user ID from an incoming request. Used for multi-tenant agent isolation. */
-    user?: (req: express.Request) => Promise<string>;
+    user?: (session: Session) => Promise<string>;
     /** Handler for agent retrieval requests. Generated via {@link agent.factory}. */
-    retrieve?: agent.handler;
+    retrieve?: agent.Mount['handler'];
     /** Handler for agent deployment requests. Generated via {@link deployment.factory}. */
-    deploy?: deployment.handler;
+    deploy?: deployment.Mount['handler'];
     /** Handler for agent test/evaluation requests. Generated via {@link testing.factory}. */
-    evaluate?: testing.handler;
+    evaluate?: testing.Mount['handler'];
     /**
      * Authentication middleware applied to protected routes.
      * @see {@link https://expressjs.com/en/guide/writing-middleware.html Writing Middleware}
@@ -80,10 +81,10 @@ export interface Options {
  * server.launch(8080);
  * ```
  */
-export declare function fleet(settings?: Partial<Settings>, { app, authOnRetrieve, enableTesting, }?: Options): {
+export declare function fleet(settings?: Partial<Settings>, { app, authOnRetrieve, enableTesting }?: Options): {
     app: express.Application;
     launch: (port: number) => Server;
-    ship: (agents: CreateAgentRoute["request"][], userId?: string) => Promise<{
+    ship: (agents: CreateAgentRoute['request'][], userId?: string) => Promise<{
         launch: (port?: number) => Server;
     }>;
 };

package/dist/server/express/server.js

@@ -2,25 +2,21 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import * as sdk from "@artinet/sdk";
-import express from "express";
-import { DEFAULTS } from "../../default.js";
-import * as agent from "./agent-request.js";
-import * as testing from "./test-request.js";
-import * as deployment from "./deploy-request.js";
-import { AGENT_FIELD_NAME } from "./agent-request.js";
+import * as sdk from '@artinet/sdk';
+import express from 'express';
+import { DEFAULTS } from '../../default.js';
+import * as agent from './agent-request.js';
+import * as testing from './test-request.js';
+import * as deployment from './deploy-request.js';
+import { AGENT_FIELD_NAME } from '../../default.js';
 const createContext = (settings) => {
     const _settings = {
         ...DEFAULTS,
         ...settings,
-        retrieve: agent.factory(settings.get ?? DEFAULTS.get, 
-        /**Middleware addons are currently only supported on the agent request route */
-        settings.middleware?.build() ?? []),
-        deploy: deployment.factory(settings.set ?? DEFAULTS.set),
-        evaluate: testing.factory(settings.test ?? DEFAULTS.test),
-        user: settings.user
-            ? settings.user
-            : (_req) => Promise.resolve(settings.userId ?? "default"),
+        retrieve: agent.factory({ implementation: settings.get ?? DEFAULTS.get }),
+        deploy: deployment.factory({ implementation: settings.set ?? DEFAULTS.set }),
+        evaluate: testing.factory({ implementation: settings.test ?? DEFAULTS.test }),
+        user: settings.user ? settings.user : (_session) => Promise.resolve(settings.userId ?? 'default'),
     };
     return _settings;
 };
@@ -74,9 +70,9 @@ const createRequestContext = (context) => {
  * server.launch(8080);
  * ```
  */
-export function fleet(settings = DEFAULTS, { app = express(), authOnRetrieve = false, enableTesting = true, } = {}) {
+export function fleet(settings = DEFAULTS, { app = express(), authOnRetrieve = false, enableTesting = true } = {}) {
     const context = createContext(settings);
-    const { basePath, agentPath, fallbackPath, deploymentPath, testPath, auth, user, evaluate, deploy, retrieve, set, } = context;
+    const { basePath, agentPath, fallbackPath, deploymentPath, testPath, auth, user, evaluate, deploy, retrieve, set } = context;
     const router = express.Router();
     router.use(express.json());
     if (auth) {
@@ -88,38 +84,32 @@ export function fleet(settings = DEFAULTS, { app = express(), authOnRetrieve = f
         }
     }
     if (enableTesting === true && evaluate !== undefined) {
-        router.post(testPath, async (req, res, next) => await testing.request({
-            request: req,
-            response: res,
-            next,
+        router.post(testPath, async (request, response, next) => await testing.request({
+            session: { request, response, next },
             context: createRequestContext(context),
             handler: evaluate,
             user,
         }), sdk.errorHandler);
     }
-    router.post(deploymentPath, async (req, res, next) => await deployment.request({
-        request: req,
-        response: res,
-        next,
+    router.post(deploymentPath, async (request, response, next) => await deployment.request({
+        session: { request, response, next },
         context: createRequestContext(context),
         handler: deploy,
         user,
     }));
-    router.use(`${agentPath}/:${AGENT_FIELD_NAME}`, async (req, res, next) => await agent.request({
-        request: req,
-        response: res,
-        next,
+    router.use(`${agentPath}/:${AGENT_FIELD_NAME}`, async (request, response, next) => await agent.request({
+        session: { request, response, next },
         context: createRequestContext(context),
         handler: retrieve,
         user,
+        intercepts: settings.middleware?.build() ?? [],
     }), sdk.errorHandler);
-    router.use(`${fallbackPath}/:${AGENT_FIELD_NAME}`, async (req, res, next) => await agent.request({
-        request: req,
-        response: res,
-        next,
+    router.use(`${fallbackPath}/:${AGENT_FIELD_NAME}`, async (request, response, next) => await agent.request({
+        session: { request, response, next },
         context: createRequestContext(context),
         handler: retrieve,
         user,
+        intercepts: settings.middleware?.build() ?? [],
     }), sdk.errorHandler);
     app.use(basePath, router);
     const launch = (port = 3000) => {
@@ -141,19 +131,3 @@ export function fleet(settings = DEFAULTS, { app = express(), authOnRetrieve = f
     };
     return { app, launch, ship };
 }
-// const swarm = await fleet().ship([
-//   {
-//     config: {
-//       uri: "my-agent",
-//       name: "my-agent",
-//       description: "A helpful assistant",
-//       modelId: "gpt-4",
-//       instructions: "You are a helpful assistant.",
-//       version: "1.0.0",
-//       skills: [],
-//       capabilities: {},
-//       services: [],
-//     },
-//   },
-// ]);
-// swarm.launch(3000);

package/dist/server/express/test-request.d.ts

@@ -2,17 +2,19 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import express from "express";
-import { TestAgentRoute } from "../../routes/request/index.js";
-export type handler = (req: express.Request, res: express.Response, next: express.NextFunction, context: TestAgentRoute["context"], test?: TestAgentRoute["implementation"]) => Promise<void>;
-export declare function handle(req: express.Request, res: express.Response, _next: express.NextFunction, context: TestAgentRoute["context"], test?: TestAgentRoute["implementation"]): Promise<void>;
-export declare const factory: (test?: TestAgentRoute["implementation"]) => handler;
-export interface Params {
-    request: express.Request;
-    response: express.Response;
-    next: express.NextFunction;
-    context: Omit<TestAgentRoute["context"], "agentId">;
-    handler: handler;
-    user: (request: express.Request) => Promise<string>;
-}
-export declare function request({ request: req, response: res, next, context, handler, user, }: Params): Promise<void>;
+import { TestAgentMount } from '../../routes/request/index.js';
+import { Session } from './types.js';
+/**
+ * Handler utilities for agent test/evaluation requests.
+ *
+ * Exports a reusable handler function for routing test/evaluation requests to agent instances,
+ * validating the request body, and returning the result as a JSON-RPC response.
+ *
+ * Used by the deployment server to provide a standard agent test/evaluation endpoint interface.
+ *
+ * @module server/handlers/test
+ */
+export type Mount = TestAgentMount<Session>;
+export declare const factory: Mount['factory'];
+export declare const handle: Mount['handler'];
+export declare const request: Mount['request'];

package/dist/server/express/test-request.js

@@ -2,25 +2,13 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import * as sdk from "@artinet/sdk";
-import { TestAgent, TestRequestSchema, } from "../../routes/request/index.js";
-import { v4 as uuidv4 } from "uuid";
-import { handleJSONRPCResponse } from "./rpc.js";
-import { generateRequestId } from "./utils.js";
-export async function handle(req, res, _next, context, test = TestAgent) {
-    let parsed = await sdk.validateSchema(TestRequestSchema, req?.body ?? {});
-    let id = parsed.id ?? uuidv4();
-    parsed.id = id;
-    let request = parsed;
-    context.target = parsed.config;
-    request.method = "test/invoke";
-    request.params = null;
-    const response = await test(request, context);
-    await handleJSONRPCResponse(res, String(id), request.method, response);
-}
-export const factory = (test = TestAgent) => async (req, res, next, context) => await handle(req, res, next, context, test);
+import * as sdk from '@artinet/sdk';
+import { TestAgent, TestRequestSchema, } from '../../routes/request/index.js';
+import { v4 as uuidv4 } from 'uuid';
+import { handleJSONRPCResponse } from './rpc.js';
+import { generateRequestId } from './utils.js';
 const MAX_TEST_ID_ATTEMPTS = 10;
-const getTestId = async (context) => {
+const generateTestId = async (context) => {
     let testId = uuidv4();
     let free = false;
     for (let i = 0; i < MAX_TEST_ID_ATTEMPTS; i++) {
@@ -40,12 +28,24 @@ const getTestId = async (context) => {
     }
     return testId;
 };
-export async function request({ request: req, response: res, next, context, handler = handle, user, }) {
-    const requestContext = {
+export const factory = ({ implementation = TestAgent }) => async (params) => await handle(params, implementation);
+export const handle = async ({ session: { request, response }, context }, implementation = TestAgent) => {
+    let parsed = await sdk.validateSchema(TestRequestSchema, request?.body ?? {});
+    let id = parsed.id ?? uuidv4();
+    parsed.id = id;
+    let req = parsed;
+    context.target = parsed.config;
+    req.method = 'test/invoke';
+    req.params = null;
+    const res = await implementation(req, context);
+    return await handleJSONRPCResponse(response, String(id), req.method, res);
+};
+export const request = async ({ session, context, handler = handle, user, intercepts }, implementation = TestAgent) => {
+    const _context = {
         ...context,
-        agentId: await getTestId(context),
-        requestId: generateRequestId(context, req),
-        userId: await user?.(req),
+        agentId: await generateTestId(context),
+        requestId: generateRequestId(context, session.request),
+        userId: await user?.(session),
     };
-    return await handler(req, res, next, requestContext);
-}
+    return await handler({ session, context: _context, intercepts }, implementation);
+};

package/dist/server/express/types.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import express from 'express';
+export type Session = {
+    request: express.Request;
+    response: express.Response;
+    next: express.NextFunction;
+};

package/dist/server/express/types.js

@@ -0,0 +1,5 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};

package/dist/server/hono/agent-request.d.ts

@@ -2,12 +2,8 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import * as hono from "hono";
-import { RequestAgentRoute, RequestContext } from "../../routes/request/index.js";
-export declare const AGENT_FIELD_NAME = "agentId";
-export type handler = (ctx: hono.Context, next: hono.Next, context: RequestContext, request?: RequestAgentRoute["implementation"], intercepts?: RequestAgentRoute["intercept"][]) => Promise<void>;
-export declare function handle(ctx: hono.Context, _next: hono.Next, context: RequestContext, request?: RequestAgentRoute["implementation"], intercepts?: RequestAgentRoute["intercept"][]): Promise<void>;
-export declare const factory: (request?: RequestAgentRoute["implementation"], intercepts?: RequestAgentRoute["intercept"][]) => handler;
+import { RequestAgentMount } from '../../routes/request/index.js';
+import { Session } from './types.js';
 /**
  * Handler utilities for agent HTTP requests.
  *
@@ -19,11 +15,7 @@ export declare const factory: (request?: RequestAgentRoute["implementation"], in
  *
  * @module server/handlers/agent
  */
-export interface Params {
-    ctx: hono.Context;
-    next: hono.Next;
-    context: Omit<RequestContext, "agentId">;
-    handler: handler;
-    user: (ctx: hono.Context) => Promise<string>;
-}
-export declare function request({ ctx, next, context, handler, user, }: Params): Promise<void>;
+export type Mount = RequestAgentMount<Session>;
+export declare const handle: Mount['handler'];
+export declare const factory: Mount['factory'];
+export declare const request: Mount['request'];

package/dist/server/hono/agent-request.js

@@ -2,23 +2,22 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import { INVALID_REQUEST } from "@artinet/sdk";
-import { RequestAgent, } from "../../routes/request/index.js";
-import * as sdk from "@artinet/sdk";
-import { handleJSONRPCResponse } from "./rpc.js";
-import { generateRequestId } from "./utils.js";
-export const AGENT_FIELD_NAME = "agentId";
-export async function handle(ctx, _next, context, request = RequestAgent, intercepts) {
+import { INVALID_REQUEST } from '@artinet/sdk';
+import { RequestAgent } from '../../routes/request/index.js';
+import * as sdk from '@artinet/sdk';
+import { handleJSONRPCResponse } from './rpc.js';
+import { generateRequestId } from './utils.js';
+import { AGENT_FIELD_NAME } from '../../default.js';
+export const handle = async ({ session: { ctx }, context, intercepts }, implementation = RequestAgent) => {
     /* hono.Context.req uses a raw JSON.parse() so we prefer to use the text() and our own safeParse() */
     const body = sdk.safeParse(await ctx.req.text());
-    const requestId = generateRequestId(context, ctx.req.header("x-request-id") ?? body?.id);
+    const requestId = generateRequestId(context, ctx.req.header('x-request-id') ?? body?.id);
     let parsed;
-    if (ctx.req.path.endsWith("agent-card.json") ||
-        ctx.req.path.endsWith("agent.json")) {
+    if (ctx.req.path.endsWith('agent-card.json') || ctx.req.path.endsWith('agent.json')) {
         parsed = {
-            jsonrpc: "2.0",
+            jsonrpc: '2.0',
             id: requestId,
-            method: "agentcard/get",
+            method: 'agentcard/get',
             params: null,
         };
     }
@@ -31,23 +30,28 @@ export async function handle(ctx, _next, context, request = RequestAgent, interc
         params: params,
     };
     sdk.logger.info(`handle agent request received:${parsed.method}:params:${sdk.formatJson(agentRequest)}`);
-    const response = await request(agentRequest, context, intercepts);
+    const response = await implementation(agentRequest, context, intercepts);
     sdk.logger.info(`handle agent request completed:${parsed.method}:response:${sdk.formatJson(response)}`);
     await handleJSONRPCResponse(ctx, requestId, parsed.method, response);
-}
-export const factory = (request = RequestAgent, intercepts) => async (ctx, next, context) => await handle(ctx, next, context, request, intercepts);
-export async function request({ ctx, next, context, handler = handle, user, }) {
+};
+export const factory = ({ implementation = RequestAgent, }) => {
+    return async (params) => {
+        return await handle(params, implementation);
+    };
+};
+export const request = async ({ session, context, handler = handle, user, intercepts }, implementation = RequestAgent) => {
+    const { ctx } = session;
     const agentId = ctx.req.param(AGENT_FIELD_NAME);
     if (!agentId) {
         throw INVALID_REQUEST({ message: `${AGENT_FIELD_NAME} is required` });
     }
-    /* hono.Context.req uses a raw JSON.parse() so we prefer to use the text() and our own safeParse() */
-    const reqId = ctx.req.header("x-request-id") ?? sdk.safeParse(await ctx.req.text())?.id;
+    /* hono.Context.req uses a raw JSON.parse() so we prefer to use text() and our own safeParse() */
+    const reqId = ctx.req.header('x-request-id') ?? sdk.safeParse(await ctx.req.text())?.id;
     const requestContext = {
         ...context,
         agentId,
         requestId: generateRequestId(context, reqId),
-        userId: await user?.(ctx),
+        userId: await user?.(session),
     };
-    await handler(ctx, next, requestContext);
-}
+    return await handler({ session, context: requestContext, intercepts }, implementation);
+};

package/dist/server/hono/deploy-request.d.ts

@@ -2,16 +2,9 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import * as hono from "hono";
-import { CreateAgentRoute } from "../../routes/create/index.js";
-export type handler = (ctx: hono.Context, next: hono.Next, context: CreateAgentRoute["context"], deploy?: CreateAgentRoute["implementation"]) => Promise<void>;
-export declare function handle(ctx: hono.Context, _next: hono.Next, context: CreateAgentRoute["context"], deploy?: CreateAgentRoute["implementation"]): Promise<void>;
-export declare const factory: (deploy?: CreateAgentRoute["implementation"]) => handler;
-export interface Params {
-    ctx: hono.Context;
-    next: hono.Next;
-    context: CreateAgentRoute["context"];
-    handler: handler;
-    user: (ctx: hono.Context) => Promise<string>;
-}
-export declare function request({ ctx, next, context, handler, user, }: Params): Promise<void>;
+import { CreateAgentMount } from '../../routes/create/index.js';
+import { Session } from './types.js';
+export type Mount = CreateAgentMount<Session>;
+export declare const factory: Mount['factory'];
+export declare const handle: Mount['handler'];
+export declare const request: Mount['request'];