@artinet/fleet 0.1.1 → 0.1.7

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

@@ -2,29 +2,98 @@
  * 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.
+ *
+ * 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 & {
-    user?: (ctx: hono.Context) => Promise<string>;
-    retrieve?: agent.handler;
-    deploy?: deployment.handler;
-    evaluate?: testing.handler;
+    /** 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.Mount['handler'];
+    /** Handler for agent deployment requests. Generated via {@link deployment.factory}. */
+    deploy?: deployment.Mount['handler'];
+    /** Handler for agent test/evaluation requests. Generated via {@link testing.factory}. */
+    evaluate?: testing.Mount['handler'];
+    /**
+     * Authentication middleware applied to protected routes.
+     * @see {@link https://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;
 }
-export declare function fleet(settings?: Partial<Settings>, { app, authOnRetrieve, enableTesting, }?: Options): {
+/**
+ * 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;
-    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;
 };
@@ -42,11 +37,53 @@ const createRequestContext = (context) => {
         timestamp: undefined,
     };
 };
-export function fleet(settings = DEFAULTS, { app = new hono.Hono(), authOnRetrieve = false, enableTesting = true, } = {}) {
+/**
+ * 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;
+    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);
@@ -58,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) => {
@@ -104,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/settings.d.ts

@@ -6,16 +6,37 @@ 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 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/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/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');
+}