@artinet/fleet 0.1.1 → 0.1.7

package/dist/routes/request/types/definitions.d.ts

@@ -2,12 +2,12 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import * as armada from "@artinet/armada";
-import { AgentConfiguration } from "agent-def";
-import * as sdk from "@artinet/sdk";
-import { API } from "@artinet/types";
-import { z } from "zod/v4";
-import { ResultOrError } from "../../../types.js";
+import * as armada from '@artinet/armada';
+import { AgentConfiguration } from 'agent-def';
+import * as sdk from '@artinet/sdk';
+import { API } from '@artinet/types';
+import { z } from 'zod/v4';
+import { ResultOrError } from '../../../types.js';
 export type AgentRequest = API.APIRequest & {
     method: string;
     params: sdk.A2A.RequestParam;
@@ -23,7 +23,7 @@ export type loadFunction = (config: AgentConfiguration, context?: RequestContext
 export type invokeFunction = <Req extends AgentRequest = AgentRequest>(request: Req, agent: Agent, context?: RequestContext) => Promise<AgentResponse | null>;
 export interface RequestContext extends armada.StorageContext<typeof armada.StoredAgentSchema>, armada.FindContext<typeof armada.StoredAgentSchema>, 
 /**If passing `contexts` to the `orc8` loader, be aware that it requires a Monitored Context Manager */
-Pick<sdk.CreateAgentParams, "contexts" | "tasks"> {
+Pick<sdk.CreateAgentParams, 'contexts' | 'tasks'> {
     agentId: string;
     headers?: Record<string, string>;
     agents?: Record<string, Agent>;
@@ -48,6 +48,7 @@ Pick<sdk.CreateAgentParams, "contexts" | "tasks"> {
 }
 export interface RequestAgentRoute<Req extends AgentRequest = AgentRequest> extends armada.Storable<typeof armada.StoredAgentSchema, Req, AgentResponse, RequestContext> {
 }
+export type RequestAgentMount<Session extends object> = armada.Mount<Session, RequestAgentRoute['request'], RequestAgentRoute['response'], RequestAgentRoute['context']>;
 export declare const TestRequestSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodOptional<z.ZodString>>;
     requestId: z.ZodOptional<z.ZodString>;
@@ -58,27 +59,27 @@ export declare const TestRequestSchema: z.ZodObject<{
         protocolVersion: z.ZodOptional<z.ZodDefault<z.ZodString>>;
         name: z.ZodString;
         description: z.ZodString;
-        url: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodURL>;
         preferredTransport: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
             JSONRPC: "JSONRPC";
             GRPC: "GRPC";
             "HTTP+JSON": "HTTP+JSON";
         }>, z.ZodString]>>;
         additionalInterfaces: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            url: z.ZodString;
+            url: z.ZodURL;
             transport: z.ZodUnion<readonly [z.ZodEnum<{
                 JSONRPC: "JSONRPC";
                 GRPC: "GRPC";
                 "HTTP+JSON": "HTTP+JSON";
             }>, z.ZodString]>;
         }, z.core.$strip>>>;
-        iconUrl: z.ZodOptional<z.ZodString>;
+        iconUrl: z.ZodOptional<z.ZodURL>;
         provider: z.ZodOptional<z.ZodObject<{
             organization: z.ZodString;
-            url: z.ZodString;
+            url: z.ZodURL;
         }, z.core.$strip>>;
         version: z.ZodString;
-        documentationUrl: z.ZodOptional<z.ZodString>;
+        documentationUrl: z.ZodOptional<z.ZodURL>;
         capabilities: z.ZodOptional<z.ZodObject<{
             streaming: z.ZodOptional<z.ZodBoolean>;
             pushNotifications: z.ZodOptional<z.ZodBoolean>;
@@ -110,31 +111,31 @@ export declare const TestRequestSchema: z.ZodObject<{
             flows: z.ZodObject<{
                 authorizationCode: z.ZodOptional<z.ZodObject<{
                     authorizationUrl: z.ZodString;
-                    tokenUrl: z.ZodString;
-                    refreshUrl: z.ZodOptional<z.ZodString>;
+                    tokenUrl: z.ZodURL;
+                    refreshUrl: z.ZodOptional<z.ZodURL>;
                     scopes: z.ZodRecord<z.ZodString, z.ZodString>;
                 }, z.core.$strip>>;
                 clientCredentials: z.ZodOptional<z.ZodObject<{
-                    tokenUrl: z.ZodString;
-                    refreshUrl: z.ZodOptional<z.ZodString>;
+                    tokenUrl: z.ZodURL;
+                    refreshUrl: z.ZodOptional<z.ZodURL>;
                     scopes: z.ZodRecord<z.ZodString, z.ZodString>;
                 }, z.core.$strip>>;
                 implicit: z.ZodOptional<z.ZodObject<{
-                    authorizationUrl: z.ZodString;
-                    refreshUrl: z.ZodOptional<z.ZodString>;
+                    authorizationUrl: z.ZodURL;
+                    refreshUrl: z.ZodOptional<z.ZodURL>;
                     scopes: z.ZodRecord<z.ZodString, z.ZodString>;
                 }, z.core.$strip>>;
                 password: z.ZodOptional<z.ZodObject<{
-                    tokenUrl: z.ZodString;
-                    refreshUrl: z.ZodOptional<z.ZodString>;
+                    tokenUrl: z.ZodURL;
+                    refreshUrl: z.ZodOptional<z.ZodURL>;
                     scopes: z.ZodRecord<z.ZodString, z.ZodString>;
                 }, z.core.$strip>>;
             }, z.core.$strip>;
-            oauth2MetadataUrl: z.ZodOptional<z.ZodString>;
+            oauth2MetadataUrl: z.ZodOptional<z.ZodURL>;
         }, z.core.$strip>, z.ZodObject<{
             description: z.ZodOptional<z.ZodString>;
             type: z.ZodLiteral<"openIdConnect">;
-            openIdConnectUrl: z.ZodString;
+            openIdConnectUrl: z.ZodURL;
         }, z.core.$strip>, z.ZodObject<{
             description: z.ZodOptional<z.ZodString>;
             type: z.ZodLiteral<"mutualTLS">;
@@ -170,7 +171,7 @@ export declare const TestRequestSchema: z.ZodObject<{
         instructions: z.ZodString;
         services: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
             id: z.ZodOptional<z.ZodString>;
-            url: z.ZodString;
+            url: z.ZodURL;
             headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
             authToken: z.ZodOptional<z.ZodString>;
             parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -182,27 +183,27 @@ export declare const TestRequestSchema: z.ZodObject<{
                 protocolVersion: z.ZodDefault<z.ZodString>;
                 name: z.ZodString;
                 description: z.ZodString;
-                url: z.ZodString;
+                url: z.ZodURL;
                 preferredTransport: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
                     JSONRPC: "JSONRPC";
                     GRPC: "GRPC";
                     "HTTP+JSON": "HTTP+JSON";
                 }>, z.ZodString]>>;
                 additionalInterfaces: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    url: z.ZodString;
+                    url: z.ZodURL;
                     transport: z.ZodUnion<readonly [z.ZodEnum<{
                         JSONRPC: "JSONRPC";
                         GRPC: "GRPC";
                         "HTTP+JSON": "HTTP+JSON";
                     }>, z.ZodString]>;
                 }, z.core.$strip>>>;
-                iconUrl: z.ZodOptional<z.ZodString>;
+                iconUrl: z.ZodOptional<z.ZodURL>;
                 provider: z.ZodOptional<z.ZodObject<{
                     organization: z.ZodString;
-                    url: z.ZodString;
+                    url: z.ZodURL;
                 }, z.core.$strip>>;
                 version: z.ZodString;
-                documentationUrl: z.ZodOptional<z.ZodString>;
+                documentationUrl: z.ZodOptional<z.ZodURL>;
                 capabilities: z.ZodObject<{
                     streaming: z.ZodOptional<z.ZodBoolean>;
                     pushNotifications: z.ZodOptional<z.ZodBoolean>;
@@ -234,31 +235,31 @@ export declare const TestRequestSchema: z.ZodObject<{
                     flows: z.ZodObject<{
                         authorizationCode: z.ZodOptional<z.ZodObject<{
                             authorizationUrl: z.ZodString;
-                            tokenUrl: z.ZodString;
-                            refreshUrl: z.ZodOptional<z.ZodString>;
+                            tokenUrl: z.ZodURL;
+                            refreshUrl: z.ZodOptional<z.ZodURL>;
                             scopes: z.ZodRecord<z.ZodString, z.ZodString>;
                         }, z.core.$strip>>;
                         clientCredentials: z.ZodOptional<z.ZodObject<{
-                            tokenUrl: z.ZodString;
-                            refreshUrl: z.ZodOptional<z.ZodString>;
+                            tokenUrl: z.ZodURL;
+                            refreshUrl: z.ZodOptional<z.ZodURL>;
                             scopes: z.ZodRecord<z.ZodString, z.ZodString>;
                         }, z.core.$strip>>;
                         implicit: z.ZodOptional<z.ZodObject<{
-                            authorizationUrl: z.ZodString;
-                            refreshUrl: z.ZodOptional<z.ZodString>;
+                            authorizationUrl: z.ZodURL;
+                            refreshUrl: z.ZodOptional<z.ZodURL>;
                             scopes: z.ZodRecord<z.ZodString, z.ZodString>;
                         }, z.core.$strip>>;
                         password: z.ZodOptional<z.ZodObject<{
-                            tokenUrl: z.ZodString;
-                            refreshUrl: z.ZodOptional<z.ZodString>;
+                            tokenUrl: z.ZodURL;
+                            refreshUrl: z.ZodOptional<z.ZodURL>;
                             scopes: z.ZodRecord<z.ZodString, z.ZodString>;
                         }, z.core.$strip>>;
                     }, z.core.$strip>;
-                    oauth2MetadataUrl: z.ZodOptional<z.ZodString>;
+                    oauth2MetadataUrl: z.ZodOptional<z.ZodURL>;
                 }, z.core.$strip>, z.ZodObject<{
                     description: z.ZodOptional<z.ZodString>;
                     type: z.ZodLiteral<"openIdConnect">;
-                    openIdConnectUrl: z.ZodString;
+                    openIdConnectUrl: z.ZodURL;
                 }, z.core.$strip>, z.ZodObject<{
                     description: z.ZodOptional<z.ZodString>;
                     type: z.ZodLiteral<"mutualTLS">;
@@ -285,7 +286,7 @@ export declare const TestRequestSchema: z.ZodObject<{
             }, z.core.$strip>;
         }, z.core.$strip>, z.ZodObject<{
             id: z.ZodOptional<z.ZodString>;
-            url: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodURL>;
             headers: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
             authToken: z.ZodOptional<z.ZodString>;
             parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -297,27 +298,27 @@ export declare const TestRequestSchema: z.ZodObject<{
                 protocolVersion: z.ZodDefault<z.ZodString>;
                 name: z.ZodString;
                 description: z.ZodString;
-                url: z.ZodString;
+                url: z.ZodURL;
                 preferredTransport: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
                     JSONRPC: "JSONRPC";
                     GRPC: "GRPC";
                     "HTTP+JSON": "HTTP+JSON";
                 }>, z.ZodString]>>;
                 additionalInterfaces: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    url: z.ZodString;
+                    url: z.ZodURL;
                     transport: z.ZodUnion<readonly [z.ZodEnum<{
                         JSONRPC: "JSONRPC";
                         GRPC: "GRPC";
                         "HTTP+JSON": "HTTP+JSON";
                     }>, z.ZodString]>;
                 }, z.core.$strip>>>;
-                iconUrl: z.ZodOptional<z.ZodString>;
+                iconUrl: z.ZodOptional<z.ZodURL>;
                 provider: z.ZodOptional<z.ZodObject<{
                     organization: z.ZodString;
-                    url: z.ZodString;
+                    url: z.ZodURL;
                 }, z.core.$strip>>;
                 version: z.ZodString;
-                documentationUrl: z.ZodOptional<z.ZodString>;
+                documentationUrl: z.ZodOptional<z.ZodURL>;
                 capabilities: z.ZodObject<{
                     streaming: z.ZodOptional<z.ZodBoolean>;
                     pushNotifications: z.ZodOptional<z.ZodBoolean>;
@@ -349,31 +350,31 @@ export declare const TestRequestSchema: z.ZodObject<{
                     flows: z.ZodObject<{
                         authorizationCode: z.ZodOptional<z.ZodObject<{
                             authorizationUrl: z.ZodString;
-                            tokenUrl: z.ZodString;
-                            refreshUrl: z.ZodOptional<z.ZodString>;
+                            tokenUrl: z.ZodURL;
+                            refreshUrl: z.ZodOptional<z.ZodURL>;
                             scopes: z.ZodRecord<z.ZodString, z.ZodString>;
                         }, z.core.$strip>>;
                         clientCredentials: z.ZodOptional<z.ZodObject<{
-                            tokenUrl: z.ZodString;
-                            refreshUrl: z.ZodOptional<z.ZodString>;
+                            tokenUrl: z.ZodURL;
+                            refreshUrl: z.ZodOptional<z.ZodURL>;
                             scopes: z.ZodRecord<z.ZodString, z.ZodString>;
                         }, z.core.$strip>>;
                         implicit: z.ZodOptional<z.ZodObject<{
-                            authorizationUrl: z.ZodString;
-                            refreshUrl: z.ZodOptional<z.ZodString>;
+                            authorizationUrl: z.ZodURL;
+                            refreshUrl: z.ZodOptional<z.ZodURL>;
                             scopes: z.ZodRecord<z.ZodString, z.ZodString>;
                         }, z.core.$strip>>;
                         password: z.ZodOptional<z.ZodObject<{
-                            tokenUrl: z.ZodString;
-                            refreshUrl: z.ZodOptional<z.ZodString>;
+                            tokenUrl: z.ZodURL;
+                            refreshUrl: z.ZodOptional<z.ZodURL>;
                             scopes: z.ZodRecord<z.ZodString, z.ZodString>;
                         }, z.core.$strip>>;
                     }, z.core.$strip>;
-                    oauth2MetadataUrl: z.ZodOptional<z.ZodString>;
+                    oauth2MetadataUrl: z.ZodOptional<z.ZodURL>;
                 }, z.core.$strip>, z.ZodObject<{
                     description: z.ZodOptional<z.ZodString>;
                     type: z.ZodLiteral<"openIdConnect">;
-                    openIdConnectUrl: z.ZodString;
+                    openIdConnectUrl: z.ZodURL;
                 }, z.core.$strip>, z.ZodObject<{
                     description: z.ZodOptional<z.ZodString>;
                     type: z.ZodLiteral<"mutualTLS">;
@@ -400,7 +401,7 @@ export declare const TestRequestSchema: z.ZodObject<{
             }, z.core.$strip>;
         }, z.core.$strip>]>, z.ZodUnion<readonly [z.ZodObject<{
             id: z.ZodOptional<z.ZodString>;
-            url: z.ZodString;
+            url: z.ZodURL;
             headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
             authToken: z.ZodOptional<z.ZodString>;
             parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -537,7 +538,7 @@ export declare const TestRequestSchema: z.ZodObject<{
             }, z.core.$strip>;
         }, z.core.$strip>, z.ZodObject<{
             id: z.ZodOptional<z.ZodString>;
-            url: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodURL>;
             headers: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
             authToken: z.ZodOptional<z.ZodString>;
             parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -721,7 +722,7 @@ export declare const TestRequestSchema: z.ZodObject<{
             historyLength: z.ZodOptional<z.ZodNumber>;
             pushNotificationConfig: z.ZodOptional<z.ZodObject<{
                 id: z.ZodOptional<z.ZodString>;
-                url: z.ZodString;
+                url: z.ZodURL;
                 token: z.ZodOptional<z.ZodString>;
                 authentication: z.ZodOptional<z.ZodObject<{
                     schemes: z.ZodArray<z.ZodString>;
@@ -736,3 +737,4 @@ export declare const TestRequestSchema: z.ZodObject<{
 export type TestRequest = z.output<typeof TestRequestSchema> & AgentRequest;
 export interface TestAgentRoute extends RequestAgentRoute<TestRequest> {
 }
+export type TestAgentMount<Session extends object> = armada.Mount<Session, TestAgentRoute['request'], TestAgentRoute['response'], TestAgentRoute['context']>;

package/dist/routes/request/types/definitions.js

@@ -2,14 +2,12 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import * as armada from "@artinet/armada";
-import * as sdk from "@artinet/sdk";
-import { z } from "zod/v4";
+import * as armada from '@artinet/armada';
+import * as sdk from '@artinet/sdk';
+import { z } from 'zod/v4';
 export const TestRequestSchema = armada.CreateAgentRequestSchema.extend({
     /**
      * All the requested test tasks
      */
-    tests: z
-        .array(sdk.A2A.MessageSendParamsSchema)
-        .describe("All the requested test tasks"),
-}).describe("The test deployment parameters");
+    tests: z.array(sdk.A2A.MessageSendParamsSchema).describe('All the requested test tasks'),
+}).describe('The test deployment parameters');

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,48 +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 = 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,29 +2,89 @@
  * 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.
+ *
+ * Combines base {@link FleetSettings} with Express-specific handlers for
+ * authentication, user resolution, and request processing.
+ *
+ * @see {@link https://expressjs.com/en/guide/using-middleware.html Express Middleware}
+ */
 export type Settings = FleetSettings & {
-    user?: (req: express.Request) => Promise<string>;
-    retrieve?: agent.handler;
-    deploy?: deployment.handler;
-    evaluate?: testing.handler;
+    /** Extracts the user ID from an incoming request. Used for multi-tenant agent isolation. */
+    user?: (session: Session) => Promise<string>;
+    /** Handler for agent retrieval requests. Generated via {@link agent.factory}. */
+    retrieve?: agent.Mount['handler'];
+    /** Handler for agent deployment requests. Generated via {@link deployment.factory}. */
+    deploy?: deployment.Mount['handler'];
+    /** Handler for agent test/evaluation requests. Generated via {@link testing.factory}. */
+    evaluate?: testing.Mount['handler'];
+    /**
+     * Authentication middleware applied to protected routes.
+     * @see {@link https://expressjs.com/en/guide/writing-middleware.html Writing Middleware}
+     */
     auth?: (req: express.Request, res: express.Response, next: express.NextFunction) => Promise<void>;
 };
+/**
+ * Options for configuring the Fleet server instance.
+ *
+ * Allows injection of a pre-configured Express app for integration with
+ * existing servers or custom middleware stacks.
+ */
 export interface Options {
+    /** Pre-configured Express application. Defaults to a new `express()` instance. */
     app?: express.Application;
+    /** Apply auth middleware to agent retrieval routes. Defaults to `false`. */
     authOnRetrieve?: boolean;
+    /** Expose the test endpoint for agent evaluation. Defaults to `true`. */
     enableTesting?: boolean;
 }
-export declare function fleet(settings?: Partial<Settings>, { app, authOnRetrieve, enableTesting, }?: Options): {
+/**
+ * Creates and configures a Fleet server instance using Express.
+ *
+ * This function implements the **Factory Pattern** combined with **Dependency Injection**
+ * to provide a flexible, testable, and configurable server setup. The pattern allows
+ * consumers to override defaults while maintaining sensible out-of-the-box behavior.
+ *
+ * @param settings - Partial configuration merged with defaults. Supports custom
+ *   handlers for `get`, `set`, `test`, and middleware composition.
+ * @param options - Server instantiation options
+ * @param options.app - Pre-configured Express application instance. Useful for
+ *   adding custom middleware or integrating with existing servers.
+ * @param options.authOnRetrieve - When `true`, applies auth middleware to agent
+ *   retrieval routes. Defaults to `false` for development convenience.
+ * @param options.enableTesting - When `true`, exposes the test endpoint for
+ *   agent evaluation. Disable in production if not needed.
+ *
+ * @returns Object containing:
+ *   - `app`: The configured Express application
+ *   - `launch`: Function to start the HTTP server on a specified port
+ *   - `ship`: Async function to deploy agents and return a launchable server
+ *
+ * @example
+ * ```typescript
+ * // Basic usage with defaults
+ * const { app, launch } = fleet();
+ * launch(3000);
+ *
+ * // With custom configuration
+ * const { ship } = fleet({ userId: 'admin' }, { authOnRetrieve: true });
+ * const server = await ship([agentConfig]);
+ * server.launch(8080);
+ * ```
+ */
+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;
     }>;
 };