@artinet/fleet 0.1.0 → 0.1.1

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/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>;

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,11 +28,12 @@ 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];
     if (!agentId) {

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.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

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.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

package/dist/settings.d.ts

@@ -5,11 +5,14 @@
 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";
 export interface Params extends Configuration {
     basePath?: string;
     fallbackPath?: string;
     deploymentPath?: string;
     testPath?: string;
+    /**Middleware addons are currently only supported on the Request Agent route */
+    middleware?: Middleware;
 }
 export interface Settings extends Params {
     get: RequestAgentRoute["implementation"];

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@artinet/fleet",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "A an agentic orchestration server for on premise deployment.",
   "type": "module",
   "main": "./dist/index.js",