@artinet/fleet 0.1.0-alpha.1

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

@@ -0,0 +1,11 @@
+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");

package/dist/src/routes/request/types/index.d.ts

@@ -0,0 +1 @@
+export * from "./definitions.js";

package/dist/src/routes/request/types/index.js

@@ -0,0 +1 @@
+export * from "./definitions.js";

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

@@ -0,0 +1,26 @@
+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;
+/**
+ * Handler utilities for agent HTTP requests.
+ *
+ * Exports a reusable handler function for routing requests to agent instances,
+ * verifying agentId route param, and returning agent metadata
+ * or dispatching to JSON-RPC middleware as appropriate.
+ *
+ * Used by the deployment server to provide a standard agent endpoint interface.
+ *
+ * @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>;

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

@@ -0,0 +1,44 @@
+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) {
+    const requestId = generateRequestId(context, req);
+    let parsed;
+    if (req?.path?.endsWith("agent-card.json") ||
+        req?.path?.endsWith("agent.json")) {
+        parsed = {
+            jsonrpc: "2.0",
+            id: requestId,
+            method: "agentcard/get",
+            params: null,
+        };
+    }
+    else {
+        parsed = await sdk.validateSchema(sdk.A2A.A2ARequestSchema, req?.body ?? {});
+    }
+    const params = await sdk.validateSchema(sdk.A2A.RequestParamSchema, parsed.params);
+    const agentRequest = {
+        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)}`);
+    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 async function request({ request: req, response: res, next, context, handler = handle, user, }) {
+    const agentId = req?.params?.[AGENT_FIELD_NAME];
+    if (!agentId) {
+        return next(INVALID_REQUEST({ message: `${AGENT_FIELD_NAME} is required` }));
+    }
+    const requestContext = {
+        ...context,
+        agentId,
+        requestId: generateRequestId(context, req),
+        userId: await user?.(req),
+    };
+    await handler(req, res, next, requestContext);
+}

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

@@ -0,0 +1,14 @@
+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>;

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

@@ -0,0 +1,19 @@
+import { CreateAgent, CreateAgentRequestSchema, } from "../../routes/create/index.js";
+import { generateRequestId, generateRegistrationId } from "./utils.js";
+import { logger, validateSchema } 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 ?? {});
+    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 = {
+        ...context,
+        requestId: generateRequestId(context, req),
+        userId: await user?.(req),
+    };
+    return await handler(req, res, next, requestContext);
+}

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

@@ -0,0 +1,3 @@
+export { fleet, type Settings as ExpressSettings, type Options as ExpressOptions, } from "./server.js";
+export type { Settings as FleetSettings } from "../../settings.js";
+export { ship } from "../../ship.js";

package/dist/src/server/express/fleet.js

@@ -0,0 +1,2 @@
+export { fleet, } from "./server.js";
+export { ship } from "../../ship.js";

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

@@ -0,0 +1,4 @@
+export * as agentRouter from "./agent-request.js";
+export * as deploymentRouter from "./deploy-request.js";
+export * as testRouter from "./test-request.js";
+export * from "./server.js";

package/dist/src/server/express/index.js

@@ -0,0 +1,4 @@
+export * as agentRouter from "./agent-request.js";
+export * as deploymentRouter from "./deploy-request.js";
+export * as testRouter from "./test-request.js";
+export * from "./server.js";

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

@@ -0,0 +1,12 @@
+import express from "express";
+import { ResultOrError } from "../../types.js";
+export declare function toJSONRPCResponse(id: string, result_or_error: ResultOrError): {
+    jsonrpc: "2.0";
+    id: string;
+    result: unknown;
+} | {
+    jsonrpc: "2.0";
+    id: string;
+    error: unknown;
+};
+export declare function handleJSONRPCResponse(res: express.Response, id: string, method: string, response: ResultOrError): Promise<void>;

package/dist/src/server/express/rpc.js

@@ -0,0 +1,38 @@
+import * as sdk from "@artinet/sdk";
+export function toJSONRPCResponse(id, result_or_error) {
+    if (result_or_error.type === "success") {
+        return { jsonrpc: "2.0", id, result: result_or_error.result };
+    }
+    if (result_or_error.type === "error") {
+        return { jsonrpc: "2.0", id, error: result_or_error.error };
+    }
+    throw new Error("Invalid response type");
+}
+export async function handleJSONRPCResponse(res, id, method, response) {
+    if (response.type === "success" && method === "agentcard/get") {
+        res.json(response.result);
+        return;
+    }
+    if (response.type === "success") {
+        res.json(toJSONRPCResponse(String(id), response));
+        return;
+    }
+    if (response.type === "error") {
+        res.status(500).json(toJSONRPCResponse(String(id), response));
+        return;
+    }
+    if (response.type === "stream") {
+        res.writeHead(200, {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+        });
+        const stream = response.stream;
+        for await (const data of stream) {
+            res.write(`data: ${JSON.stringify({ jsonrpc: "2.0", id, result: data })}\n\n`);
+        }
+        res.end();
+        return;
+    }
+    throw sdk.INTERNAL_ERROR({ message: "Unknown response type" });
+}

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

@@ -0,0 +1,26 @@
+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";
+export type Settings = FleetSettings & {
+    user?: (req: express.Request) => Promise<string>;
+    retrieve?: agent.handler;
+    deploy?: deployment.handler;
+    evaluate?: testing.handler;
+    auth?: (req: express.Request, res: express.Response, next: express.NextFunction) => Promise<void>;
+};
+export interface Options {
+    app?: express.Application;
+    authOnRetrieve?: boolean;
+    enableTesting?: boolean;
+}
+export declare function fleet(settings?: Partial<Settings>, { app, authOnRetrieve, enableTesting, }?: Options): {
+    app: express.Application;
+    launch: (port: number) => Server;
+    ship: (agents: CreateAgentRoute["request"][]) => Promise<{
+        launch: (port?: number) => Server;
+    }>;
+};

package/dist/src/server/express/server.js

@@ -0,0 +1,115 @@
+import * as sdk from "@artinet/sdk";
+import express from "express";
+import { DEFAULTS } from "../../default.js";
+import * as agent from "./agent-request.js";
+import * as testing from "./test-request.js";
+import * as deployment from "./deploy-request.js";
+import { AGENT_FIELD_NAME } from "./agent-request.js";
+const createContext = (settings) => {
+    const _settings = {
+        ...DEFAULTS,
+        ...settings,
+        retrieve: agent.factory(settings.get ?? DEFAULTS.get),
+        deploy: deployment.factory(settings.set ?? DEFAULTS.set),
+        evaluate: testing.factory(settings.test ?? DEFAULTS.test),
+        user: settings.user
+            ? settings.user
+            : (_req) => Promise.resolve(settings.userId ?? "default"),
+    };
+    return _settings;
+};
+const createRequestContext = (context) => {
+    //clear session data between requests
+    return {
+        ...context,
+        headers: undefined,
+        userId: undefined,
+        found: undefined,
+        target: undefined,
+        defaultInstructions: undefined,
+        agentId: undefined,
+        agents: undefined,
+        requestId: undefined,
+        timestamp: undefined,
+    };
+};
+export function fleet(settings = DEFAULTS, { app = express(), authOnRetrieve = false, enableTesting = true, } = {}) {
+    const context = createContext(settings);
+    const { basePath, agentPath, fallbackPath, deploymentPath, testPath, auth, user, evaluate, deploy, retrieve, set, } = context;
+    const router = express.Router();
+    router.use(express.json());
+    if (auth) {
+        router.use(testPath, auth);
+        router.use(deploymentPath, auth);
+        if (authOnRetrieve) {
+            router.use(agentPath, auth);
+            router.use(fallbackPath, auth);
+        }
+    }
+    if (enableTesting === true && evaluate !== undefined) {
+        router.post(testPath, async (req, res, next) => await testing.request({
+            request: req,
+            response: res,
+            next,
+            context: createRequestContext(context),
+            handler: evaluate,
+            user,
+        }), sdk.errorHandler);
+    }
+    router.post(deploymentPath, async (req, res, next) => await deployment.request({
+        request: req,
+        response: res,
+        next,
+        context: createRequestContext(context),
+        handler: deploy,
+        user,
+    }));
+    router.use(`${agentPath}/:${AGENT_FIELD_NAME}`, async (req, res, next) => await agent.request({
+        request: req,
+        response: res,
+        next,
+        context: createRequestContext(context),
+        handler: retrieve,
+        user,
+    }), sdk.errorHandler);
+    router.use(`${fallbackPath}/:${AGENT_FIELD_NAME}`, async (req, res, next) => await agent.request({
+        request: req,
+        response: res,
+        next,
+        context: createRequestContext(context),
+        handler: retrieve,
+        user,
+    }), sdk.errorHandler);
+    app.use(basePath, router);
+    const launch = (port = 3000) => {
+        return app.listen(port, () => {
+            sdk.logger.info(`Fleet server running on http://localhost:${port}`);
+        });
+    };
+    const ship = async (agents) => {
+        for (const agent of agents) {
+            const response = await set(agent, context);
+            if (response.success) {
+                sdk.logger.info(`Agent shipped: ${response.agentId}`);
+            }
+        }
+        return { launch };
+    };
+    return { app, launch, ship };
+}
+// const swarm = await fleet().ship([
+//   {
+//     config: {
+//       uri: "my-agent",
+//       name: "my-agent",
+//       description: "A helpful assistant",
+//       modelId: "gpt-4",
+//       instructions: "You are a helpful assistant.",
+//       version: "1.0.0",
+//       skills: [],
+//       capabilities: {},
+//       services: [],
+//     },
+//   },
+// ]);
+// swarm.launch(3000);

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

@@ -0,0 +1,14 @@
+import express from "express";
+import { TestAgentRoute } from "../../routes/request/index.js";
+export type handler = (req: express.Request, res: express.Response, next: express.NextFunction, context: TestAgentRoute["context"], test?: TestAgentRoute["implementation"]) => Promise<void>;
+export declare function handle(req: express.Request, res: express.Response, _next: express.NextFunction, context: TestAgentRoute["context"], test?: TestAgentRoute["implementation"]): Promise<void>;
+export declare const factory: (test?: TestAgentRoute["implementation"]) => handler;
+export interface Params {
+    request: express.Request;
+    response: express.Response;
+    next: express.NextFunction;
+    context: Omit<TestAgentRoute["context"], "agentId">;
+    handler: handler;
+    user: (request: express.Request) => Promise<string>;
+}
+export declare function request({ request: req, response: res, next, context, handler, user, }: Params): Promise<void>;

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

@@ -0,0 +1,47 @@
+import * as sdk from "@artinet/sdk";
+import { TestAgent, TestRequestSchema, } from "../../routes/request/index.js";
+import { v4 as uuidv4 } from "uuid";
+import { handleJSONRPCResponse } from "./rpc.js";
+import { generateRequestId } from "./utils.js";
+export async function handle(req, res, _next, context, test = TestAgent) {
+    let parsed = await sdk.validateSchema(TestRequestSchema, req?.body ?? {});
+    let id = parsed.id ?? uuidv4();
+    parsed.id = id;
+    let request = parsed;
+    context.target = parsed.config;
+    request.method = "test/invoke";
+    request.params = null;
+    const response = await test(request, context);
+    await handleJSONRPCResponse(res, String(id), request.method, response);
+}
+export const factory = (test = TestAgent) => async (req, res, next, context) => await handle(req, res, next, context, test);
+const MAX_TEST_ID_ATTEMPTS = 10;
+const getTestId = async (context) => {
+    let testId = uuidv4();
+    let free = false;
+    for (let i = 0; i < MAX_TEST_ID_ATTEMPTS; i++) {
+        if (await context.storage.get(testId)) {
+            testId = uuidv4();
+        }
+        else {
+            free = true;
+            break;
+        }
+    }
+    if (!free) {
+        throw sdk.INTERNAL_ERROR({
+            message: `Failed to find a free test agent ID after ${MAX_TEST_ID_ATTEMPTS} attempts`,
+            id: testId,
+        });
+    }
+    return testId;
+};
+export async function request({ request: req, response: res, next, context, handler = handle, user, }) {
+    const requestContext = {
+        ...context,
+        agentId: await getTestId(context),
+        requestId: generateRequestId(context, req),
+        userId: await user?.(req),
+    };
+    return await handler(req, res, next, requestContext);
+}

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

@@ -0,0 +1,5 @@
+import express from "express";
+export declare function generateRequestId(context: {
+    requestId?: string;
+}, req: express.Request): string;
+export declare const generateRegistrationId: (uri: string) => string;

package/dist/src/server/express/utils.js

@@ -0,0 +1,11 @@
+import { v4 as uuidv4 } from "uuid";
+import slugify from "@sindresorhus/slugify";
+export function generateRequestId(context, req) {
+    return (context.requestId ??
+        req?.headers?.["x-request-id"] ??
+        req?.body?.id ??
+        uuidv4());
+}
+export const generateRegistrationId = (uri) => {
+    return slugify(uri.replace(/^(agent|registration):/i, ""));
+};

package/dist/src/server/index.d.ts

@@ -0,0 +1 @@
+export * as exp from "./express/index.js";

package/dist/src/server/index.js

@@ -0,0 +1 @@
+export * as exp from "./express/index.js";

package/dist/src/settings.d.ts

@@ -0,0 +1,14 @@
+import { RequestAgentRoute, TestAgentRoute } from "./routes/index.js";
+import { CreateAgentRoute } from "./routes/create/index.js";
+import { Configuration } from "./types.js";
+export interface Params extends Configuration {
+    basePath?: string;
+    fallbackPath?: string;
+    deploymentPath?: string;
+    testPath?: string;
+}
+export interface Settings extends Params {
+    get: RequestAgentRoute["implementation"];
+    set: CreateAgentRoute["implementation"];
+    test?: TestAgentRoute["implementation"];
+}

package/dist/src/settings.js

@@ -0,0 +1 @@
+export {};

package/dist/src/ship.d.ts

@@ -0,0 +1,2 @@
+import { CreateAgentRoute } from "./routes/create/index.js";
+export declare function ship<T extends CreateAgentRoute["request"]>(fleetUrl: string | undefined, request: T): Promise<CreateAgentRoute["response"]>;

package/dist/src/ship.js

@@ -0,0 +1,15 @@
+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) {
+    const requestBody = await sdk.validateSchema(armada.CreateAgentRequestSchema, request);
+    sdk.logger.warn(`deployAgent request: ${JSON.stringify(requestBody)}`);
+    const response = await fetch(`${fleetUrl}/deploy`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(requestBody),
+    });
+    return await sdk.validateSchema(API.CreateAgentResponseSchema, response.json());
+}

package/dist/src/storage.d.ts

@@ -0,0 +1,5 @@
+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> {
+    search(query: string): Promise<armada.StoredAgent[]>;
+}

package/dist/src/storage.js

@@ -0,0 +1,8 @@
+import * as SDK from "@artinet/sdk";
+export class InMemoryStore extends SDK.Manager {
+    async search(query) {
+        return Array.from(this.data.values()).filter((value) => value.agentId.includes(query) ||
+            value.name.includes(query) ||
+            value.prompt.includes(query));
+    }
+}

package/dist/src/types.d.ts

@@ -0,0 +1,14 @@
+import { RequestAgentRoute, TestAgentRoute } from "./routes/index.js";
+import { CreateAgentRoute } from "./routes/create/index.js";
+export type Config = RequestAgentRoute["context"] & CreateAgentRoute["context"] & TestAgentRoute["context"];
+export type Configuration = Omit<Config, "agentId">;
+export type ResultOrError<Result = unknown, Error = unknown, Stream = unknown> = {
+    type: "success";
+    result: Result;
+} | {
+    type: "error";
+    error: Error;
+} | {
+    type: "stream";
+    stream: AsyncIterable<Stream>;
+};

package/dist/src/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,90 @@
+{
+  "name": "@artinet/fleet",
+  "version": "0.1.0-alpha.1",
+  "description": "A an agentic orchestration server for on premise deployment.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./express": {
+      "types": "./dist/server/express/fleet.d.ts",
+      "import": "./dist/server/express/fleet.js",
+      "default": "./dist/server/express/fleet.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc --project tsconfig.json",
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest",
+    "lint": "eslint .",
+    "clean": "rimraf dist",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "keywords": [
+    "artinet",
+    "a2a",
+    "mcp",
+    "agent",
+    "deployment",
+    "orchestration",
+    "artificial intelligence"
+  ],
+  "author": "artinet",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/the-artinet-project/artinet.git"
+  },
+  "bugs": {
+    "url": "https://github.com/the-artinet-project/artinet/issues"
+  },
+  "homepage": "https://github.com/the-artinet-project/artinet#readme",
+  "files": [
+    "dist",
+    "package.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "rootDir": ".",
+  "dependencies": {
+    "@artinet/armada": "^0.1.0-alpha.1",
+    "@artinet/sdk": "^0.6.0-preview.2",
+    "@artinet/types": "^0.0.9-alpha.4",
+    "@sindresorhus/slugify": "^3.0.0",
+    "agent-def": "^0.0.2-alpha.1",
+    "orc8": "^0.0.20-alpha.2",
+    "zod": "^3.25"
+  },
+  "peerDependencies": {
+    "@modelcontextprotocol/sdk": "^1.24.3",
+    "@opentelemetry/api": "^1.9.0",
+    "express": "^5.2.1",
+    "openai": "^6.15.0"
+  },
+  "devDependencies": {
+    "@artinet/loader": "^0.0.1",
+    "@eslint/js": "^9.25.1",
+    "@types/express": "^5.0.0",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.15.3",
+    "@types/supertest": "^6.0.3",
+    "eslint": "^9.25.1",
+    "globals": "^16.0.0",
+    "jest": "^29.7.0",
+    "pino": "^10.1.0",
+    "rimraf": "^5.0.5",
+    "supertest": "latest",
+    "ts-jest": "^29.3.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.31.1"
+  },
+  "engines": {
+    "node": ">=18.9.1"
+  }
+}