@artinet/fleet 0.1.0 → 0.1.5

package/README.md

@@ -1,6 +1,7 @@
 <p align="center">
 <a href="https://artinet.io"><img src="https://img.shields.io/badge/website-artinet.io-black" alt="Website"></a>
-<a href="https://www.npmjs.com/package/@artinet/fleet"><img src="https://img.shields.io/npm/v/@artinet/fleet?color=black" alt="Downloads"></a>
+<a href="https://www.npmjs.com/package/@artinet/fleet"><img src="https://img.shields.io/npm/v/@artinet/fleet?color=black" alt="Version"></a>
+<a href="https://www.npmjs.com/package/@artinet/fleet"><img src="https://img.shields.io/npm/dt/@artinet/fleet?color=black" alt="Downloads"></a>
 <a><img src="https://img.shields.io/badge/License-Apache_2.0-black.svg" alt="License"></a>
 <a href="https://snyk.io/test/npm/@artinet/fleet"><img src="https://snyk.io/test/npm/@artinet/fleet/badge.svg" alt="Known Vulnerabilities"></a>
 </p>
@@ -8,7 +9,7 @@
 
 Deploy AI agents on any infrastructure.
 
-Fleet is a lightweight server framework for hosting [A2A Protocol](https://github.com/google-a2a/A2A) agents with built-in orchestration, tool integration (MCP), and Agent2Agent communication.
+Fleet is a lightweight server framework for hosting agents with built-in orchestration, tool integration (MCP), and Agent2Agent communication.
 
 ## Installation
 
@@ -220,6 +221,37 @@ configure({
 });
 ```
 
+### Middleware
+
+Intercept and transform agent requests and responses by adding `Middleware`:
+
+```typescript
+import { fleet } from "@artinet/fleet/express";
+import { Middleware } from "@artinet/fleet";
+
+fleet({
+  middleware: new Middleware()
+    .request(async ({ request, context }) => {
+      // Inspect or transform incoming requests
+      console.log("Incoming request:", request);
+      return request;
+    })
+    .response(
+      async ({ response, context }) => {
+        // Inspect or transform outgoing responses
+        console.log("Outgoing response:", response);
+        return response;
+      },
+      // Use a trigger function to determine if the middleware should fire (defaults to `true` for every request/response)
+      ({ response, context }) => {
+        return true;
+      }
+    ),
+}).launch(3000);
+```
+
+The middleware chain is composable & sequential; add multiple `request` or `response` handlers as needed. Each handler receives the current request/response and context, and must return the (optionally modified) value.
+
 ## [Docker Configuration](https://github.com/the-artinet-project/artinet/blob/main/fleet/dockerfile)
 
 Build the docker image:
@@ -290,6 +322,7 @@ app.listen(3000);
 | `testPath`             | `string`     | `"/test"`                      | Test endpoint                                                                                                                   |
 | `inferenceProviderUrl` | `string`     | `undefined`                    | An OpenAI API compatible endpoint                                                                                               |
 | `load`                 | `function`   | `loadAgent`                    | Returns an A2A Protocol compliant agent wrapped in the [`@artinet/sdk`](<(https://github.com/the-artinet-project/artinet-sdk)>) |
+| `middleware`           | `Middleware` | `undefined`                    | Request/response interceptors for the agent route                                                                               |
 
 ## API Reference
 

package/dist/default.js

@@ -13,5 +13,5 @@ export const DEFAULTS = {
     load: loadAgent,
     invoke: invokeAgent,
     storage: new InMemoryStore(),
-    baseUrl: "https://localhost:3000",
+    baseUrl: "http://localhost:3000",
 };

package/dist/routes/create/index.d.ts

@@ -801,7 +801,7 @@ export declare const CreateAgentRequestSchema: import("zod/v4").ZodObject<{
         instructions: import("zod/v4").ZodString;
         services: import("zod/v4").ZodDefault<import("zod/v4").ZodArray<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodObject<{
             id: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-            url: import("zod/v4").ZodString;
+            url: import("zod/v4").ZodURL;
             headers: import("zod/v4").ZodOptional<import("zod/v4").ZodRecord<import("zod/v4").ZodString, import("zod/v4").ZodString>>;
             authToken: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
             parameters: import("zod/v4").ZodOptional<import("zod/v4").ZodRecord<import("zod/v4").ZodString, import("zod/v4").ZodUnknown>>;
@@ -916,7 +916,7 @@ export declare const CreateAgentRequestSchema: import("zod/v4").ZodObject<{
             }, import("zod/v4/core").$strip>;
         }, import("zod/v4/core").$strip>, import("zod/v4").ZodObject<{
             id: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-            url: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            url: import("zod/v4").ZodOptional<import("zod/v4").ZodURL>;
             headers: import("zod/v4").ZodOptional<import("zod/v4").ZodOptional<import("zod/v4").ZodRecord<import("zod/v4").ZodString, import("zod/v4").ZodString>>>;
             authToken: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
             parameters: import("zod/v4").ZodOptional<import("zod/v4").ZodRecord<import("zod/v4").ZodString, import("zod/v4").ZodUnknown>>;
@@ -1031,7 +1031,7 @@ export declare const CreateAgentRequestSchema: import("zod/v4").ZodObject<{
             }, import("zod/v4/core").$strip>;
         }, import("zod/v4/core").$strip>]>, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodObject<{
             id: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-            url: import("zod/v4").ZodString;
+            url: import("zod/v4").ZodURL;
             headers: import("zod/v4").ZodOptional<import("zod/v4").ZodRecord<import("zod/v4").ZodString, import("zod/v4").ZodString>>;
             authToken: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
             parameters: import("zod/v4").ZodOptional<import("zod/v4").ZodRecord<import("zod/v4").ZodString, import("zod/v4").ZodUnknown>>;
@@ -1168,7 +1168,7 @@ export declare const CreateAgentRequestSchema: import("zod/v4").ZodObject<{
             }, import("zod/v4/core").$strip>;
         }, import("zod/v4/core").$strip>, import("zod/v4").ZodObject<{
             id: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-            url: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            url: import("zod/v4").ZodOptional<import("zod/v4").ZodURL>;
             headers: import("zod/v4").ZodOptional<import("zod/v4").ZodOptional<import("zod/v4").ZodRecord<import("zod/v4").ZodString, import("zod/v4").ZodString>>>;
             authToken: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
             parameters: import("zod/v4").ZodOptional<import("zod/v4").ZodRecord<import("zod/v4").ZodString, import("zod/v4").ZodUnknown>>;

package/dist/routes/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./create/index.js";
 export * from "./request/index.js";
+export { Middleware } from "./intercept.js";

package/dist/routes/index.js

@@ -1,2 +1,3 @@
 export * from "./create/index.js";
 export * from "./request/index.js";
+export { Middleware } from "./intercept.js";

package/dist/routes/intercept.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as armada from "@artinet/armada";
+import { RequestAgentRoute } from "./request/types/definitions.js";
+import { API } from "@artinet/types";
+export declare class InterceptBuilder<Req extends API.APIRequest = RequestAgentRoute["request"], Res extends API.APIResponse = RequestAgentRoute["response"], Context extends armada.BaseContext = RequestAgentRoute["context"]> {
+    private readonly intercepts;
+    constructor(intercepts?: armada.Intercept<Req, Res, Req | Res, Context>[]);
+    build(): armada.Intercept<Req, Res, Req | Res, Context>[];
+    request(action: armada.Intercept<Req, Res, Req, Context>["action"], trigger?: armada.Intercept<Req, Res, Req, Context>["trigger"]): InterceptBuilder<Req, Res, Context>;
+    response(action: armada.Intercept<Req, Res, Res, Context>["action"], trigger?: armada.Intercept<Req, Res, Res, Context>["trigger"]): InterceptBuilder<Req, Res, Context>;
+}
+export type Middleware = InterceptBuilder;
+export declare const Middleware: typeof InterceptBuilder;

package/dist/routes/intercept.js

@@ -0,0 +1,31 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as armada from "@artinet/armada";
+export class InterceptBuilder {
+    intercepts;
+    constructor(intercepts = []) {
+        this.intercepts = intercepts;
+    }
+    build() {
+        return this.intercepts;
+    }
+    request(action, trigger) {
+        this.intercepts.push({
+            action,
+            trigger: trigger ?? true,
+            phase: armada.Phase.REQUEST,
+        });
+        return new InterceptBuilder(this.intercepts);
+    }
+    response(action, trigger) {
+        this.intercepts.push({
+            action,
+            trigger: trigger ?? true,
+            phase: armada.Phase.RESPONSE,
+        });
+        return new InterceptBuilder(this.intercepts);
+    }
+}
+export const Middleware = InterceptBuilder;

package/dist/routes/request/implementation/invoke.js

@@ -4,6 +4,7 @@
  */
 import * as sdk from "@artinet/sdk";
 import { assert } from "console";
+import { A2AError } from "@a2a-js/sdk/server";
 function isAgentMessenger(agent) {
     return agent instanceof sdk.AgentMessenger;
 }
@@ -17,9 +18,20 @@ export const invoke = async (type, request, invocable) => {
     }
     catch (error) {
         sdk.logger.error(`invocation error:${request.method}:error:${JSON.stringify(error, null, 2)}`, { error });
+        let jsonRPCError;
+        if (error instanceof A2AError || error instanceof sdk.SystemError) {
+            jsonRPCError = {
+                code: error.code,
+                message: error.message,
+                data: error.data,
+            };
+        }
+        else {
+            jsonRPCError = A2AError.internalError(error?.message ?? "Internal error", { cause: error?.stack }).toJSONRPCError();
+        }
         return {
             type: "error",
-            error: error,
+            error: jsonRPCError,
         };
     }
     if (!result) {

package/dist/routes/request/implementation/load.js

@@ -33,6 +33,7 @@ export const loadAgent = async (config, context, provider = process.env.OPENAI_A
             context.defaultInstructions ??
             DEFAULT_INSTRUCTIONS,
         provider,
+        tasks: context.tasks,
     });
     if (requiredAgentsNotLoaded(config, context)) {
         throw sdk.INTERNAL_ERROR({

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

@@ -3,7 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { RequestAgentRoute, TestAgentRoute } from "./types/definitions.js";
-export declare const requestAgent: (request: RequestAgentRoute["request"], context: RequestAgentRoute["context"], requestFn?: RequestAgentRoute["implementation"]) => Promise<RequestAgentRoute["response"]>;
+export declare const requestAgent: (request: RequestAgentRoute["request"], context: RequestAgentRoute["context"], requestFn?: RequestAgentRoute["implementation"], intercepts?: RequestAgentRoute["intercept"][]) => Promise<RequestAgentRoute["response"]>;
 export declare const RequestAgent: RequestAgentRoute["implementation"];
 /**
  * Test agent implementation.

package/dist/routes/request/request.js

@@ -6,13 +6,14 @@ import * as armada from "@artinet/armada";
 import { FetchAgent } from "./interceptors/fetch-agent.js";
 import { GetAgents } from "./interceptors/get-agents.js";
 import { requestImplementation } from "./implementation/request.js";
-export const requestAgent = (request, context, requestFn = requestImplementation) => armada.entry({
+const DEFAULT_INTERCEPTS = [FetchAgent, GetAgents];
+export const requestAgent = (request, context, requestFn = requestImplementation, intercepts = []) => armada.entry({
     request,
     implementation: requestFn,
-    intercepts: [FetchAgent, GetAgents],
+    intercepts: [...DEFAULT_INTERCEPTS, ...intercepts],
     context,
 });
-export const RequestAgent = (request, context) => requestAgent(request, context, requestImplementation);
+export const RequestAgent = (request, context, intercepts = []) => requestAgent(request, context, requestImplementation, intercepts);
 /**
  * Test agent implementation.
  * @note Similar to RequestAgent, but skips the FetchAgent intercept and uses the testInvoke function that returns a stream of updates.

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

@@ -5,9 +5,10 @@
 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 = {
+export type AgentRequest = API.APIRequest & {
     method: string;
     params: sdk.A2A.RequestParam;
 };
@@ -16,11 +17,13 @@ export type AgentError = {
     message: string;
     data?: unknown;
 };
-export type AgentResponse = ResultOrError<sdk.A2A.ResponseResult | sdk.A2A.AgentCard, AgentError, sdk.A2A.Update>;
+export type AgentResponse = API.APIResponse & ResultOrError<sdk.A2A.ResponseResult | sdk.A2A.AgentCard, AgentError, sdk.A2A.Update>;
 export type Agent = sdk.Agent | sdk.AgentMessenger;
 export type loadFunction = (config: AgentConfiguration, context?: RequestContext) => Promise<Agent | undefined>;
 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> {
+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"> {
     agentId: string;
     headers?: Record<string, string>;
     agents?: Record<string, Agent>;
@@ -167,7 +170,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>>;
@@ -282,7 +285,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>>;
@@ -397,7 +400,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>>;
@@ -534,7 +537,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>>;

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

@@ -5,9 +5,9 @@
 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"]) => Promise<void>;
-export declare function handle(req: express.Request, res: express.Response, _next: express.NextFunction, context: RequestContext, request?: RequestAgentRoute["implementation"]): Promise<void>;
-export declare const factory: (request?: RequestAgentRoute["implementation"]) => handler;
+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;
 /**
  * Handler utilities for agent HTTP requests.
  *

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

@@ -8,7 +8,7 @@ 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) {
+export async function handle(req, res, _next, context, request = RequestAgent, intercepts) {
     const requestId = generateRequestId(context, req);
     let parsed;
     if (req?.path?.endsWith("agent-card.json") ||
@@ -28,13 +28,16 @@ export async function handle(req, res, _next, context, request = RequestAgent) {
         method: parsed.method,
         params: params,
     };
-    const response = await request(agentRequest, context);
-    sdk.logger.info(`handle agent request completed:${parsed.method}:response:${JSON.stringify(response, null, 2)}`);
+    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) => async (req, res, next, context) => await handle(req, res, next, context, request);
+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];
+    const agentId = Array.isArray(req?.params?.[AGENT_FIELD_NAME])
+        ? req?.params?.[AGENT_FIELD_NAME][0]
+        : req?.params?.[AGENT_FIELD_NAME];
     if (!agentId) {
         return next(INVALID_REQUEST({ message: `${AGENT_FIELD_NAME} is required` }));
     }

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

@@ -4,10 +4,11 @@
  */
 import { CreateAgent, CreateAgentRequestSchema, } from "../../routes/create/index.js";
 import { generateRequestId, generateRegistrationId } from "./utils.js";
-import { logger, validateSchema } from "@artinet/sdk";
+import { logger, validateSchema, formatJson } from "@artinet/sdk";
 export async function handle(req, res, _next, context, deploy = CreateAgent) {
-    logger.warn(`handle deploy request with body: ${JSON.stringify(req.body)}`);
     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);

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

@@ -9,18 +9,77 @@ 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";
+/**
+ * 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 & {
+    /** Extracts the user ID from an incoming request. Used for multi-tenant agent isolation. */
     user?: (req: express.Request) => Promise<string>;
+    /** Handler for agent retrieval requests. Generated via {@link agent.factory}. */
     retrieve?: agent.handler;
+    /** Handler for agent deployment requests. Generated via {@link deployment.factory}. */
     deploy?: deployment.handler;
+    /** Handler for agent test/evaluation requests. Generated via {@link testing.factory}. */
     evaluate?: testing.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;
 }
+/**
+ * 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;

package/dist/server/express/server.js

@@ -13,7 +13,9 @@ const createContext = (settings) => {
     const _settings = {
         ...DEFAULTS,
         ...settings,
-        retrieve: agent.factory(settings.get ?? DEFAULTS.get),
+        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
@@ -38,6 +40,40 @@ const createRequestContext = (context) => {
         timestamp: undefined,
     };
 };
+/**
+ * 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 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;

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

@@ -5,9 +5,9 @@
 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"]) => Promise<void>;
-export declare function handle(ctx: hono.Context, _next: hono.Next, context: RequestContext, request?: RequestAgentRoute["implementation"]): Promise<void>;
-export declare const factory: (request?: RequestAgentRoute["implementation"]) => handler;
+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;
 /**
  * Handler utilities for agent HTTP requests.
  *

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

@@ -8,7 +8,7 @@ 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) {
+export async function handle(ctx, _next, context, request = RequestAgent, intercepts) {
     /* 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);
@@ -30,11 +30,12 @@ export async function handle(ctx, _next, context, request = RequestAgent) {
         method: parsed.method,
         params: params,
     };
-    const response = await request(agentRequest, context);
-    sdk.logger.info(`handle agent request completed:${parsed.method}:response:${JSON.stringify(response, null, 2)}`);
+    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(ctx, requestId, parsed.method, response);
 }
-export const factory = (request = RequestAgent) => async (ctx, next, context) => await handle(ctx, next, context, request);
+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, }) {
     const agentId = ctx.req.param(AGENT_FIELD_NAME);
     if (!agentId) {

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

@@ -8,8 +8,9 @@ import { generateRequestId, generateRegistrationId } from "./utils.js";
 export async function handle(ctx, _next, context, deploy = CreateAgent) {
     /* hono.Context.req uses a raw JSON.parse() so we prefer to use the text() and our own safeParse() */
     const req = sdk.safeParse(await ctx.req.text());
-    sdk.logger.warn(`handle deploy request with body: ${JSON.stringify(req)}`);
     const request = await sdk.validateSchema(CreateAgentRequestSchema, req);
+    sdk.logger.info(`deploying agent: ${request.config.name}`);
+    sdk.logger.debug(`deploying agent: ${sdk.formatJson(request)}`);
     context.registrationId = generateRegistrationId(request.config.uri);
     const result = await deploy(request, context);
     ctx.res = ctx.json(result);

package/dist/server/hono/server.d.ts

@@ -9,18 +9,86 @@ 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";
+/**
+ * Extended settings for the Hono Fleet server.
+ *
+ * Combines base {@link FleetSettings} with Hono-specific handlers for
+ * authentication, user resolution, and request processing.
+ *
+ * @see {@link https://hono.dev/docs/guides/middleware Hono Middleware Guide}
+ */
 export type Settings = FleetSettings & {
+    /** Extracts the user ID from the Hono context. Used for multi-tenant agent isolation. */
     user?: (ctx: hono.Context) => Promise<string>;
+    /** Handler for agent retrieval requests. Generated via {@link agent.factory}. */
     retrieve?: agent.handler;
+    /** Handler for agent deployment requests. Generated via {@link deployment.factory}. */
     deploy?: deployment.handler;
+    /** Handler for agent test/evaluation requests. Generated via {@link testing.factory}. */
     evaluate?: testing.handler;
+    /**
+     * Authentication middleware applied to protected routes.
+     * @see {@link https://hono.dev/docs/guides/middleware#middleware-argument Middleware Guide}
+     */
     auth?: (ctx: hono.Context, next: hono.Next) => Promise<void>;
 };
+/**
+ * Options for configuring the Fleet server instance.
+ *
+ * Allows injection of a pre-configured Hono app for integration with
+ * existing servers or edge runtime deployments.
+ */
 export interface Options {
+    /** Pre-configured Hono application. Defaults to a new `Hono()` instance. */
     app?: hono.Hono;
+    /** Apply auth middleware to agent retrieval routes. Defaults to `false`. */
     authOnRetrieve?: boolean;
+    /** Expose the test endpoint for agent evaluation. Defaults to `true`. */
     enableTesting?: boolean;
 }
+/**
+ * Creates and configures a Fleet server instance using Hono.
+ *
+ * This function implements the **Factory Pattern** combined with **Dependency Injection**
+ * to provide a flexible, testable, and configurable server setup. Hono is chosen for its
+ * ultrafast performance, edge-runtime compatibility, and minimal footprint.
+ *
+ * @see {@link https://hono.dev/docs/ Hono Documentation}
+ * @see {@link https://hono.dev/docs/concepts/routers Hono Routers}
+ * @see {@link https://hono.dev/docs/guides/middleware Hono Middleware Guide}
+ *
+ * ## Security Considerations
+ *
+ * - Authentication middleware is applied conditionally via `auth` setting
+ * - `authOnRetrieve` flag controls whether agent retrieval requires authentication
+ * - Consider enabling `authOnRetrieve` in production environments
+ *
+ * @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 Hono 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 Hono 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 and edge deployment
+ * const { app } = fleet({ userId: 'admin' }, { authOnRetrieve: true });
+ * export default app; // For Cloudflare Workers
+ * ```
+ */
 export declare function fleet(settings?: Partial<Settings>, { app, authOnRetrieve, enableTesting, }?: Options): {
     app: hono.Hono;
     launch: (port: number) => ServerType;

package/dist/server/hono/server.js

@@ -15,7 +15,9 @@ const createContext = (settings) => {
     const _settings = {
         ...DEFAULTS,
         ...settings,
-        retrieve: agent.factory(settings.get ?? DEFAULTS.get),
+        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
@@ -40,6 +42,49 @@ const createRequestContext = (context) => {
         timestamp: undefined,
     };
 };
+/**
+ * Creates and configures a Fleet server instance using Hono.
+ *
+ * This function implements the **Factory Pattern** combined with **Dependency Injection**
+ * to provide a flexible, testable, and configurable server setup. Hono is chosen for its
+ * ultrafast performance, edge-runtime compatibility, and minimal footprint.
+ *
+ * @see {@link https://hono.dev/docs/ Hono Documentation}
+ * @see {@link https://hono.dev/docs/concepts/routers Hono Routers}
+ * @see {@link https://hono.dev/docs/guides/middleware Hono Middleware Guide}
+ *
+ * ## Security Considerations
+ *
+ * - Authentication middleware is applied conditionally via `auth` setting
+ * - `authOnRetrieve` flag controls whether agent retrieval requires authentication
+ * - Consider enabling `authOnRetrieve` in production environments
+ *
+ * @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 Hono 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 Hono 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 and edge deployment
+ * const { app } = fleet({ userId: 'admin' }, { authOnRetrieve: true });
+ * export default app; // For Cloudflare Workers
+ * ```
+ */
 export function fleet(settings = DEFAULTS, { app = new hono.Hono(), authOnRetrieve = false, enableTesting = true, } = {}) {
     const context = createContext(settings);
     const { basePath, agentPath, fallbackPath, deploymentPath, testPath, auth, user, evaluate, deploy, retrieve, set, } = context;

package/dist/settings.d.ts

@@ -5,14 +5,38 @@
 import { RequestAgentRoute, TestAgentRoute } from "./routes/index.js";
 import { CreateAgentRoute } from "./routes/create/index.js";
 import { Configuration } from "./types.js";
+import { Middleware } from "./routes/intercept.js";
+/**
+ * Route path configuration parameters for the Fleet server.
+ *
+ * Extends {@link Configuration} with customizable URL paths for each endpoint,
+ * allowing flexible integration with existing API structures.
+ */
 export interface Params extends Configuration {
+    /** Base path prefix for all Fleet routes. Defaults to `/`. */
     basePath?: string;
+    /** Fallback path for agent requests. Defaults to `/.well-known/agent`. */
     fallbackPath?: string;
+    /** Path for agent deployment requests. Defaults to `/deploy`. */
     deploymentPath?: string;
+    /** Path for agent test/evaluation requests. Defaults to `/test`. */
     testPath?: string;
+    /** Middleware addons are currently only supported on the Request Agent route. */
+    middleware?: Middleware;
 }
+/**
+ * Complete settings combining route paths with handler implementations.
+ *
+ * Defines the core operations for agent management:
+ * - `get`: Retrieve and execute agent requests
+ * - `set`: Deploy new agents or update existing ones
+ * - `test`: Evaluate agent behavior (optional)
+ */
 export interface Settings extends Params {
+    /** Implementation for retrieving and processing agent requests. */
     get: RequestAgentRoute["implementation"];
+    /** Implementation for deploying or updating agents. */
     set: CreateAgentRoute["implementation"];
+    /** Implementation for testing/evaluating agents. Optional. */
     test?: TestAgentRoute["implementation"];
 }

package/dist/ship.d.ts

@@ -3,4 +3,48 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { CreateAgentRoute } from "./routes/create/index.js";
-export declare function ship<T extends CreateAgentRoute["request"]>(fleetUrl: string | undefined, request: T): Promise<CreateAgentRoute["response"]>;
+/**
+ * Deploys an agent configuration to a remote Fleet server.
+ *
+ * This function serves as a client for agent deployment,
+ * implementing schema validation on both request and response to ensure type safety
+ * and data integrity across network boundaries.
+ *
+ * @see {@link https://zod.dev/ Zod Schema Validation}
+ *
+ * Schema validation will throw if the request or response doesn't match the expected
+ * structure. Network errors from `fetch` will propagate as-is.
+ *
+ * @template T - The agent request type, constrained to `CreateAgentRoute["request"]`
+ *
+ * @param fleetUrl - Base URL of the Fleet server. Defaults to `http://localhost:3000`
+ *   for local development. In production, use environment variables.
+ * @param request - Agent configuration to deploy. Must conform to {@link armada.CreateAgentRequestSchema}.
+ * @param headers - Optional custom HTTP headers to include with the request. Useful for authentication tokens, correlation IDs, or distributed tracing headers.
+ *
+ * @returns Promise resolving to the deployment response, validated against {@link API.CreateAgentResponseSchema}.
+ *
+ * @example
+ * ```typescript
+ * // Deploy to local development server
+ * const result = await ship("http://localhost:3000", {
+ *   config: {
+ *     schemaVersion: "0.1.0",
+ *     uri: "my-agent",
+ *     name: "My Agent",
+ *     description: "A helpful assistant",
+ *     modelId: "gpt-4",
+ *     instructions: "You are a helpful assistant.",
+ *     version: "1.0.0",
+ *   },
+ * });
+ *
+ * // Deploy with authentication header
+ * const authResult = await ship(
+ *   process.env.FLEET_URL!,
+ *   agentConfig,
+ *   { Authorization: `Bearer ${token}` }
+ * );
+ * ```
+ */
+export declare function ship<T extends CreateAgentRoute["request"]>(fleetUrl: string | undefined, request: T, headers?: Record<string, string>): Promise<CreateAgentRoute["response"]>;

package/dist/ship.js

@@ -5,13 +5,58 @@
 import * as sdk from "@artinet/sdk";
 import * as armada from "@artinet/armada";
 import { API } from "@artinet/types";
-export async function ship(fleetUrl = "http://localhost:3000", request) {
+/**
+ * Deploys an agent configuration to a remote Fleet server.
+ *
+ * This function serves as a client for agent deployment,
+ * implementing schema validation on both request and response to ensure type safety
+ * and data integrity across network boundaries.
+ *
+ * @see {@link https://zod.dev/ Zod Schema Validation}
+ *
+ * Schema validation will throw if the request or response doesn't match the expected
+ * structure. Network errors from `fetch` will propagate as-is.
+ *
+ * @template T - The agent request type, constrained to `CreateAgentRoute["request"]`
+ *
+ * @param fleetUrl - Base URL of the Fleet server. Defaults to `http://localhost:3000`
+ *   for local development. In production, use environment variables.
+ * @param request - Agent configuration to deploy. Must conform to {@link armada.CreateAgentRequestSchema}.
+ * @param headers - Optional custom HTTP headers to include with the request. Useful for authentication tokens, correlation IDs, or distributed tracing headers.
+ *
+ * @returns Promise resolving to the deployment response, validated against {@link API.CreateAgentResponseSchema}.
+ *
+ * @example
+ * ```typescript
+ * // Deploy to local development server
+ * const result = await ship("http://localhost:3000", {
+ *   config: {
+ *     schemaVersion: "0.1.0",
+ *     uri: "my-agent",
+ *     name: "My Agent",
+ *     description: "A helpful assistant",
+ *     modelId: "gpt-4",
+ *     instructions: "You are a helpful assistant.",
+ *     version: "1.0.0",
+ *   },
+ * });
+ *
+ * // Deploy with authentication header
+ * const authResult = await ship(
+ *   process.env.FLEET_URL!,
+ *   agentConfig,
+ *   { Authorization: `Bearer ${token}` }
+ * );
+ * ```
+ */
+export async function ship(fleetUrl = "http://localhost:3000", request, headers = {}) {
     const requestBody = await sdk.validateSchema(armada.CreateAgentRequestSchema, request);
     sdk.logger.debug(`deployAgent request:`, { requestBody });
     const response = await fetch(`${fleetUrl}/deploy`, {
         method: "POST",
         headers: {
             "Content-Type": "application/json",
+            ...headers,
         },
         body: JSON.stringify(requestBody),
     });

package/dist/storage/in-memory.d.ts

@@ -3,7 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import * as armada from "@artinet/armada";
-import * as SDK from "@artinet/sdk";
-export declare class InMemoryStore extends SDK.Manager<armada.StoredAgent> implements armada.IDataStore<armada.StoredAgent> {
+import * as sdk from "@artinet/sdk";
+export declare class InMemoryStore extends sdk.Manager<armada.StoredAgent> implements armada.IDataStore<armada.StoredAgent> {
     search(query: string): Promise<armada.StoredAgent[]>;
 }

package/dist/storage/in-memory.js

@@ -2,8 +2,8 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import * as SDK from "@artinet/sdk";
-export class InMemoryStore extends SDK.Manager {
+import * as sdk from "@artinet/sdk";
+export class InMemoryStore extends sdk.Manager {
     async search(query) {
         return Array.from(this.data.values()).filter((value) => value.uri.includes(query) ||
             value.name.includes(query) ||

package/dist/types.d.ts

@@ -4,8 +4,45 @@
  */
 import { RequestAgentRoute, TestAgentRoute } from "./routes/index.js";
 import { CreateAgentRoute } from "./routes/create/index.js";
+/**
+ * Combined context type for all route handlers.
+ *
+ * Represents the intersection of context requirements across agent request,
+ * creation, and testing routes. Used internally for handler type safety.
+ */
 export type Config = RequestAgentRoute["context"] & CreateAgentRoute["context"] & TestAgentRoute["context"];
+/**
+ * Configuration type without agent-specific identifiers.
+ *
+ * Omits `agentId` from {@link Config} for use in settings and initialization
+ * where the agent ID is not yet known.
+ */
 export type Configuration = Omit<Config, "agentId">;
+/**
+ * Discriminated union for operation results.
+ *
+ * Provides a type-safe way to represent three possible outcomes:
+ * - `success`: Operation completed with a result
+ * - `error`: Operation failed with an error
+ * - `stream`: Operation returns an async iterable stream
+ *
+ * @see {@link https://www.typescriptlang.org/docs/handbook/2/narrowing.html#discriminated-unions Discriminated Unions}
+ *
+ * @template Result - Type of successful result. Defaults to `unknown`.
+ * @template Error - Type of error payload. Defaults to `unknown`.
+ * @template Stream - Type of streamed items. Defaults to `unknown`.
+ *
+ * @example
+ * ```typescript
+ * function handle(result: ResultOrError<User, ApiError, Chunk>) {
+ *   switch (result.type) {
+ *     case "success": return result.result; // User
+ *     case "error": throw result.error;     // ApiError
+ *     case "stream": return result.stream;  // AsyncIterable<Chunk>
+ *   }
+ * }
+ * ```
+ */
 export type ResultOrError<Result = unknown, Error = unknown, Stream = unknown> = {
     type: "success";
     result: Result;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@artinet/fleet",
-  "version": "0.1.0",
+  "version": "0.1.5",
   "description": "A an agentic orchestration server for on premise deployment.",
   "type": "module",
   "main": "./dist/index.js",
@@ -62,53 +62,52 @@
   ],
   "rootDir": ".",
   "dependencies": {
-    "@artinet/armada": "^0.1.0",
-    "@artinet/sdk": "^0.6.0",
-    "@artinet/types": "^0.0.9",
+    "@artinet/armada": "^0.1.4",
+    "@artinet/sdk": "^0.6.4",
+    "@artinet/types": "^0.1.4",
     "@sindresorhus/slugify": "^3.0.0",
-    "agent-def": "^0.1.0",
-    "orc8": "^0.1.0",
+    "agent-def": "^0.1.4",
+    "orc8": "^0.1.4",
     "zod": "^3.25"
   },
   "peerDependencies": {
     "@a2a-js/sdk": "^0.3.7",
     "@modelcontextprotocol/sdk": "^1.24.3",
     "@opentelemetry/api": "^1.9.0",
+    "drizzle-orm": "^0.45.1",
     "express": "^5.2.1",
     "hono": "^4.11.3",
     "openai": "^6.15.0",
-    "pino": "^10.1.0",
-    "drizzle-orm": "^0.45.1"
+    "pino": "^10.1.0"
   },
   "devDependencies": {
     "@a2a-js/sdk": "^0.3.7",
-    "@artinet/loader": "^0.0.1",
-    "@eslint/js": "^9.25.1",
+    "@eslint/js": "^9.39.2",
     "@modelcontextprotocol/sdk": "^1.24.3",
     "@types/better-sqlite3": "^7.6.13",
-    "@types/express": "^5.0.0",
+    "@types/express": "^5.0.6",
     "@types/jest": "^29.5.14",
-    "@types/node": "^22.19.3",
+    "@types/node": "^25.0.9",
     "@types/supertest": "^6.0.3",
     "autocannon": "^8.0.0",
     "better-sqlite3": "^12.5.0",
     "drizzle-orm": "^0.45.1",
-    "eslint": "^9.25.1",
+    "eslint": "^9.39.2",
     "express": "^5.2.1",
-    "globals": "^16.0.0",
-    "hono": "^4.11.3",
-    "jest": "^29.7.0",
-    "pino": "^10.1.0",
+    "globals": "^17.0.0",
+    "hono": "^4.11.4",
+    "jest": "29.7.0",
+    "pino": "^10.2.0",
     "pm2": "^6.0.14",
-    "rimraf": "^5.0.5",
+    "rimraf": "^6.1.2",
     "supertest": "latest",
-    "ts-jest": "^29.3.2",
+    "ts-jest": "^29.4.6",
     "ts-node": "^10.9.2",
-    "typescript": "^5.8.3",
-    "typescript-eslint": "^8.31.1",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.53.0",
     "undici": "^5.29.0"
   },
   "engines": {
-    "node": ">=18.9.1"
+    "node": ">=20.0.0"
   }
 }