@artinet/fleet 0.1.5 → 0.1.7

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

@@ -2,26 +2,27 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import * as sdk from "@artinet/sdk";
-import { CreateAgent, CreateAgentRequestSchema, } from "../../routes/create/index.js";
-import { generateRequestId, generateRegistrationId } from "./utils.js";
-export async function handle(ctx, _next, context, deploy = CreateAgent) {
+import * as sdk from '@artinet/sdk';
+import { CreateAgent, CreateAgentRequestSchema, } from '../../routes/create/index.js';
+import { generateRequestId, generateRegistrationId } from './utils.js';
+export const factory = ({ implementation = CreateAgent }) => async (params) => await handle(params, implementation);
+export const handle = async ({ session: { ctx }, context, intercepts }, implementation = 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());
     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);
+    const result = await implementation(request, context, intercepts);
     ctx.res = ctx.json(result);
-}
-export const factory = (deploy = CreateAgent) => async (ctx, next, context) => await handle(ctx, next, context, deploy);
-export async function request({ ctx, next, context, handler = handle, user, }) {
-    const reqId = ctx.req.header("x-request-id") ?? sdk.safeParse(await ctx.req.text())?.id;
-    const requestContext = {
+};
+export const request = async ({ session, context, handler = handle, user, intercepts }, implementation = CreateAgent) => {
+    const { ctx } = session;
+    const reqId = ctx.req.header('x-request-id') ?? sdk.safeParse(await ctx.req.text())?.id;
+    const _context = {
         ...context,
         requestId: generateRequestId(context, reqId),
-        userId: await user?.(ctx),
+        userId: await user?.(session),
     };
-    await handler(ctx, next, requestContext);
-}
+    await handler({ session, context: _context, intercepts }, implementation);
+};

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

@@ -2,15 +2,13 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import * as hono from "hono";
-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;
-};
+import * as hono from 'hono';
+import { ResultOrError } from '../../types.js';
+/**
+ * Handle JSON-RPC response for Hono.
+ *
+ * Used by the deployment server to provide a standard agent endpoint interface.
+ *
+ * @module server/handlers/rpc
+ */
 export declare function handleJSONRPCResponse(ctx: hono.Context, id: string, method: string, response: ResultOrError): Promise<void>;

package/dist/server/hono/rpc.js

@@ -2,48 +2,47 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import * as sdk from "@artinet/sdk";
-import { streamSSE } from "hono/streaming";
-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");
-}
+import * as sdk from '@artinet/sdk';
+import { streamSSE } from 'hono/streaming';
+import { toJSONRPCResponse } from '../../utils.js';
+/**
+ * Handle JSON-RPC response for Hono.
+ *
+ * Used by the deployment server to provide a standard agent endpoint interface.
+ *
+ * @module server/handlers/rpc
+ */
 export async function handleJSONRPCResponse(ctx, id, method, response) {
-    if (response.type === "success" && method === "agentcard/get") {
+    if (response.type === 'success' && method === 'agentcard/get') {
         ctx.status(200);
         ctx.res = ctx.json(response.result);
         return;
     }
-    if (response.type === "success") {
+    if (response.type === 'success') {
         ctx.status(200);
         ctx.res = ctx.json(toJSONRPCResponse(String(id), response));
         return;
     }
-    if (response.type === "error") {
+    if (response.type === 'error') {
         ctx.status(500);
         ctx.res = ctx.json(toJSONRPCResponse(String(id), response));
         return;
     }
-    if (response.type === "stream") {
+    if (response.type === 'stream') {
         const stream = response.stream;
         ctx.res = streamSSE(ctx, async (responseStream) => {
             for await (const data of stream) {
                 responseStream.writeSSE({
-                    data: JSON.stringify({ jsonrpc: "2.0", id, result: data }),
+                    data: JSON.stringify({ jsonrpc: '2.0', id, result: data }),
                 });
             }
             responseStream.close();
         });
         ctx.status(200);
-        ctx.res.headers.set("Content-Type", "text/event-stream");
-        ctx.res.headers.set("Cache-Control", "no-cache");
-        ctx.res.headers.set("Connection", "keep-alive");
+        ctx.res.headers.set('Content-Type', 'text/event-stream');
+        ctx.res.headers.set('Cache-Control', 'no-cache');
+        ctx.res.headers.set('Connection', 'keep-alive');
         return;
     }
-    throw sdk.INTERNAL_ERROR({ message: "Unknown response type" });
+    throw sdk.INTERNAL_ERROR({ message: 'Unknown response type' });
 }

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

@@ -2,13 +2,14 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import * as hono from "hono";
-import { type ServerType } from "@hono/node-server";
-import { CreateAgentRoute } from "../../routes/create/index.js";
-import { Settings as FleetSettings } from "../../settings.js";
-import * as agent from "./agent-request.js";
-import * as testing from "./test-request.js";
-import * as deployment from "./deploy-request.js";
+import * as hono from 'hono';
+import { type ServerType } from '@hono/node-server';
+import { CreateAgentRoute } from '../../routes/create/index.js';
+import { Settings as FleetSettings } from '../../settings.js';
+import * as agent from './agent-request.js';
+import * as testing from './test-request.js';
+import * as deployment from './deploy-request.js';
+import { Session } from './types.js';
 /**
  * Extended settings for the Hono Fleet server.
  *
@@ -18,14 +19,14 @@ import * as deployment from "./deploy-request.js";
  * @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>;
+    /** Extracts the user ID from the session. Used for multi-tenant agent isolation. */
+    user?: (session: Session) => Promise<string>;
     /** Handler for agent retrieval requests. Generated via {@link agent.factory}. */
-    retrieve?: agent.handler;
+    retrieve?: agent.Mount['handler'];
     /** Handler for agent deployment requests. Generated via {@link deployment.factory}. */
-    deploy?: deployment.handler;
+    deploy?: deployment.Mount['handler'];
     /** Handler for agent test/evaluation requests. Generated via {@link testing.factory}. */
-    evaluate?: testing.handler;
+    evaluate?: testing.Mount['handler'];
     /**
      * Authentication middleware applied to protected routes.
      * @see {@link https://hono.dev/docs/guides/middleware#middleware-argument Middleware Guide}
@@ -89,10 +90,10 @@ export interface Options {
  * export default app; // For Cloudflare Workers
  * ```
  */
-export declare function fleet(settings?: Partial<Settings>, { app, authOnRetrieve, enableTesting, }?: Options): {
+export declare function fleet(settings?: Partial<Settings>, { app, authOnRetrieve, enableTesting }?: Options): {
     app: hono.Hono;
     launch: (port: number) => ServerType;
-    ship: (agents: CreateAgentRoute["request"][], userId?: string) => Promise<{
+    ship: (agents: CreateAgentRoute['request'][], userId?: string) => Promise<{
         launch: (port?: number) => ServerType;
     }>;
 };

package/dist/server/hono/server.js

@@ -2,27 +2,22 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import * as hono from "hono";
-import { serve } from "@hono/node-server";
-import * as sdk from "@artinet/sdk";
-import { DEFAULTS } from "../../default.js";
-import * as agent from "./agent-request.js";
-import * as testing from "./test-request.js";
-import * as deployment from "./deploy-request.js";
-import { AGENT_FIELD_NAME } from "./agent-request.js";
-import { errorHandler } from "./error-handler.js";
+import * as hono from 'hono';
+import { serve } from '@hono/node-server';
+import * as sdk from '@artinet/sdk';
+import { DEFAULTS, AGENT_FIELD_NAME } 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 { errorHandler } from './error-handler.js';
 const createContext = (settings) => {
     const _settings = {
         ...DEFAULTS,
         ...settings,
-        retrieve: agent.factory(settings.get ?? DEFAULTS.get, 
-        /**Middleware addons are currently only supported on the agent request route */
-        settings.middleware?.build() ?? []),
-        deploy: deployment.factory(settings.set ?? DEFAULTS.set),
-        evaluate: testing.factory(settings.test ?? DEFAULTS.test),
-        user: settings.user
-            ? settings.user
-            : (_ctx) => Promise.resolve(settings.userId ?? "default"),
+        retrieve: agent.factory({ implementation: settings.get ?? DEFAULTS.get }),
+        deploy: deployment.factory({ implementation: settings.set ?? DEFAULTS.set }),
+        evaluate: testing.factory({ implementation: settings.test ?? DEFAULTS.test }),
+        user: settings.user ? settings.user : (_session) => Promise.resolve(settings.userId ?? 'default'),
     };
     return _settings;
 };
@@ -85,11 +80,10 @@ const createRequestContext = (context) => {
  * export default app; // For Cloudflare Workers
  * ```
  */
-export function fleet(settings = DEFAULTS, { app = new hono.Hono(), authOnRetrieve = false, enableTesting = true, } = {}) {
+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;
+    const { basePath, agentPath, fallbackPath, deploymentPath, testPath, auth, user, evaluate, deploy, retrieve, set } = context;
     const router = new hono.Hono();
-    // router.use(hono.json());
     router.onError(errorHandler);
     if (auth) {
         router.use(testPath, auth);
@@ -101,33 +95,31 @@ export function fleet(settings = DEFAULTS, { app = new hono.Hono(), authOnRetrie
     }
     if (enableTesting === true && evaluate !== undefined) {
         router.post(testPath, async (ctx, next) => await testing.request({
-            ctx,
-            next,
+            session: { ctx, next },
             context: createRequestContext(context),
             handler: evaluate,
             user,
         }));
     }
     router.post(deploymentPath, async (ctx, next) => await deployment.request({
-        ctx,
-        next,
+        session: { ctx, next },
         context: createRequestContext(context),
         handler: deploy,
         user,
     }));
     router.use(`${agentPath}/:${AGENT_FIELD_NAME}/*`, async (ctx, next) => await agent.request({
-        ctx,
-        next,
+        session: { ctx, next },
         context: createRequestContext(context),
         handler: retrieve,
         user,
+        intercepts: settings.middleware?.build() ?? [],
     }));
     router.use(`${fallbackPath}/:${AGENT_FIELD_NAME}/*`, async (ctx, next) => await agent.request({
-        ctx,
-        next,
+        session: { ctx, next },
         context: createRequestContext(context),
         handler: retrieve,
         user,
+        intercepts: settings.middleware?.build() ?? [],
     }));
     app.route(basePath, router);
     const launch = (port = 3000) => {
@@ -147,19 +139,3 @@ export function fleet(settings = DEFAULTS, { app = new hono.Hono(), authOnRetrie
     };
     return { app, launch, ship };
 }
-// const swarm = await fleet().ship([
-//   {
-//     config: {
-//       uri: "my-agent",
-//       name: "my-agent",
-//       description: "A helpful assistant",
-//       modelId: "gpt-4",
-//       instructions: "You are a helpful assistant.",
-//       version: "1.0.0",
-//       skills: [],
-//       capabilities: {},
-//       services: [],
-//     },
-//   },
-// ]);
-// swarm.launch(3000);

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

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

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

@@ -2,25 +2,11 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import * as sdk from "@artinet/sdk";
-import { TestAgent, TestRequestSchema, } from "../../routes/request/index.js";
-import { v4 as uuidv4 } from "uuid";
-import { handleJSONRPCResponse } from "./rpc.js";
-import { generateRequestId } from "./utils.js";
-export async function handle(ctx, _next, context, test = TestAgent) {
-    /* 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());
-    let parsed = await sdk.validateSchema(TestRequestSchema, req);
-    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(ctx, String(id), request.method, response);
-}
-export const factory = (test = TestAgent) => async (ctx, next, context) => await handle(ctx, next, context, test);
+import * as sdk from '@artinet/sdk';
+import { TestAgent, TestRequestSchema, } from '../../routes/request/index.js';
+import { v4 as uuidv4 } from 'uuid';
+import { handleJSONRPCResponse } from './rpc.js';
+import { generateRequestId } from './utils.js';
 const MAX_TEST_ID_ATTEMPTS = 10;
 const getTestId = async (context) => {
     let testId = uuidv4();
@@ -42,15 +28,29 @@ const getTestId = async (context) => {
     }
     return testId;
 };
-export async function request({ ctx, next, context, handler = handle, user, }) {
+export const factory = ({ implementation = TestAgent }) => async (params) => await handle(params, implementation);
+export const handle = async ({ session: { ctx }, context, intercepts }, implementation = TestAgent) => {
+    /* 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());
+    let parsed = await sdk.validateSchema(TestRequestSchema, req);
+    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 implementation(request, context, intercepts);
+    return await handleJSONRPCResponse(ctx, String(id), request.method, response);
+};
+export const request = async ({ session, context, handler = handle, user, intercepts }, implementation = TestAgent) => {
+    const { ctx } = session;
     /* hono.Context.req uses a raw JSON.parse() so we prefer to use the text() and our own safeParse() */
-    const reqId = ctx.req.header("x-request-id") ?? sdk.safeParse(await ctx.req.text())?.id;
-    const requestContext = {
+    const reqId = ctx.req.header('x-request-id') ?? sdk.safeParse(await ctx.req.text())?.id;
+    const _context = {
         ...context,
         agentId: await getTestId(context),
         requestId: generateRequestId(context, reqId),
-        userId: await user?.(ctx),
+        userId: await user?.(session),
     };
-    await handler(ctx, next, requestContext);
-    return ctx.res;
-}
+    return await handler({ session, context: _context, intercepts }, implementation);
+};

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

@@ -0,0 +1,9 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as hono from 'hono';
+export type Session = {
+    ctx: hono.Context;
+    next: hono.Next;
+};

package/dist/server/hono/types.js

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

package/dist/utils.d.ts

@@ -0,0 +1,11 @@
+import { ResultOrError } from './types.js';
+export declare function sanitizeString(str: string): string;
+export declare function toJSONRPCResponse(id: string, result_or_error: ResultOrError): {
+    jsonrpc: '2.0';
+    id: string;
+    result: unknown;
+} | {
+    jsonrpc: '2.0';
+    id: string;
+    error: unknown;
+};

package/dist/utils.js

@@ -0,0 +1,13 @@
+import escapeHtml from 'escape-html';
+export function sanitizeString(str) {
+    return escapeHtml(str).trim();
+}
+export function toJSONRPCResponse(id, result_or_error) {
+    if (result_or_error.type === 'success') {
+        return { jsonrpc: '2.0', id: sanitizeString(id), result: result_or_error.result };
+    }
+    if (result_or_error.type === 'error') {
+        return { jsonrpc: '2.0', id: sanitizeString(id), error: result_or_error.error };
+    }
+    throw new Error('Invalid response type');
+}