@artinet/sdk 0.6.0-preview.3 → 0.6.0

package/dist/server/adapters/a2a_request_handler.js

@@ -0,0 +1,241 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2AError, DefaultPushNotificationSender, } from "@a2a-js/sdk/server";
+import { A2A } from "../../types/index.js";
+import { PushNotifications } from "./notifications.js";
+import { logger } from "../../config/index.js";
+import { SystemError, validateSchema } from "../../utils/index.js";
+/**We want to avoid pulling @a2a-js/sdk logic into our business logic. */
+const toServiceOptions = (context, notify) => {
+    return {
+        userId: context?.user?.userName,
+        extensions: context?.activatedExtensions?.map((extension) => ({
+            uri: extension,
+        })) ?? [],
+        notifier: notify,
+    };
+};
+const toA2AError = (error) => {
+    if (error instanceof A2AError) {
+        return error;
+    }
+    if (error instanceof SystemError) {
+        return new A2AError(error.code, error.message, error.data, error.taskId);
+    }
+    return error;
+};
+const isGetTaskPushNotificationConfigParam = (params) => {
+    return A2A.GetTaskPushNotificationConfigParamSchema.safeParse(params).success;
+};
+const paramsRequired = (params) => {
+    if (!params || Object.keys(params).length === 0) {
+        throw A2AError.invalidParams("Params Required");
+    }
+};
+const validateParams = async (schema, params) => {
+    paramsRequired(params);
+    return await validateSchema(schema, params);
+};
+export class Native {
+    _service;
+    _pushNotifications;
+    _extendAgentCard;
+    constructor(_service, _pushNotifications, _extendAgentCard) {
+        this._service = _service;
+        this._pushNotifications = _pushNotifications;
+        this._extendAgentCard = _extendAgentCard;
+    }
+    get service() {
+        return this._service;
+    }
+    async getAgentCard() {
+        return await this.service.getAgentCard();
+    }
+    async getTask(params, context) {
+        if (!params || Object.keys(params).length === 0) {
+            throw A2AError.invalidParams("Params Required");
+        }
+        return await this.service
+            .getTask(params, toServiceOptions(context))
+            .catch((error) => {
+            throw toA2AError(error);
+        });
+    }
+    async cancelTask(params, context) {
+        paramsRequired(params);
+        return await this.service
+            .cancelTask(params, toServiceOptions(context))
+            .catch((error) => {
+            throw toA2AError(error);
+        });
+    }
+    async sendMessage(params, context) {
+        paramsRequired(params);
+        return await this.service
+            .sendMessage(params, toServiceOptions(context, {
+            notify: this.notify,
+            register: this.registerConfig,
+        }))
+            .catch((error) => {
+            throw toA2AError(error);
+        });
+    }
+    async *sendMessageStream(params, context) {
+        paramsRequired(params);
+        try {
+            yield* this.service.sendMessageStream(params, toServiceOptions(context, {
+                notify: this.notify,
+                register: this.registerConfig,
+            }));
+        }
+        catch (error) {
+            throw toA2AError(error);
+        }
+    }
+    async *resubscribe(params, context) {
+        paramsRequired(params);
+        try {
+            yield* this.service.resubscribe(params, toServiceOptions(context, {
+                notify: this.notify,
+                register: this.registerConfig,
+            }));
+        }
+        catch (error) {
+            throw toA2AError(error);
+        }
+    }
+    get pushNotifications() {
+        return this._pushNotifications;
+    }
+    async pushNotificationsEnabled(taskId) {
+        if (!(await this._service.getAgentCard())?.capabilities?.pushNotifications ||
+            !this.pushNotifications) {
+            throw A2AError.pushNotificationNotSupported();
+        }
+        if (taskId && !(await this._service.tasks.has(taskId))) {
+            throw A2AError.taskNotFound(taskId ?? "Unknown task");
+        }
+        return;
+    }
+    async setTaskPushNotificationConfig(_params, _context) {
+        const params = await validateParams(A2A.TaskPushNotificationConfigSchema, _params);
+        await this.pushNotificationsEnabled(params.taskId);
+        const { taskId, pushNotificationConfig } = params;
+        pushNotificationConfig.id = pushNotificationConfig.id ?? taskId;
+        await this.pushNotifications.save(taskId, pushNotificationConfig);
+        logger.debug("Setting push notification config for task: ", {
+            taskId,
+            pushNotificationConfigId: pushNotificationConfig.id,
+        });
+        return {
+            taskId,
+            pushNotificationConfig,
+        };
+    }
+    async getTaskPushNotificationConfig(_params, _context) {
+        const params = await validateParams(A2A.GetTaskPushNotificationConfigParamsSchema, _params);
+        await this.pushNotificationsEnabled(params.id);
+        const { id: taskId } = params;
+        const configs = await this.pushNotifications.load(taskId);
+        if (!configs) {
+            throw A2AError.internalError(`Push notification config not found for task: ${taskId}`);
+        }
+        let configId = taskId;
+        if (isGetTaskPushNotificationConfigParam(params) &&
+            params.pushNotificationConfigId) {
+            configId = params.pushNotificationConfigId;
+        }
+        const pushNotificationConfig = configs.find((config) => config.id === configId);
+        if (!pushNotificationConfig) {
+            throw A2AError.internalError(`Push notification config not found for task: ${taskId} and config: ${configId}`);
+        }
+        return {
+            taskId,
+            pushNotificationConfig,
+        };
+    }
+    async listTaskPushNotificationConfigs(_params, _context) {
+        const params = await validateParams(A2A.ListTaskPushNotificationConfigParamsSchema, _params);
+        await this.pushNotificationsEnabled(params.id);
+        const { id: taskId } = params;
+        const configs = await this.pushNotifications.load(taskId);
+        if (!configs) {
+            return [];
+        }
+        return configs.map((pushNotificationConfig) => ({
+            taskId,
+            pushNotificationConfig,
+        }));
+    }
+    async deleteTaskPushNotificationConfig(_params, _context) {
+        const params = await validateParams(A2A.DeleteTaskPushNotificationConfigParamsSchema, _params);
+        await this.pushNotificationsEnabled(params.id);
+        const { id: taskId } = params;
+        await this.pushNotifications.delete(taskId);
+    }
+    registerConfig = async (taskId, config) => {
+        await this.pushNotificationsEnabled(taskId);
+        await this.pushNotifications?.save(taskId, config);
+    };
+    notify = async (task, _update, _context) => {
+        const enabled = await this.pushNotificationsEnabled(task.id)
+            .then(() => true)
+            .catch(() => {
+            logger.warn("Push notifications not enabled for task: ", {
+                taskId: task.id,
+            });
+            return false;
+        });
+        if (!enabled) {
+            return;
+        }
+        return await this.pushNotifications.send(task);
+    };
+    async getAuthenticatedExtendedAgentCard(context) {
+        if (!(await this.getAgentCard()).supportsAuthenticatedExtendedCard) {
+            throw A2AError.unsupportedOperation("Agent does not support authenticated extended card.");
+        }
+        if (!this._extendAgentCard) {
+            throw A2AError.authenticatedExtendedCardNotConfigured();
+        }
+        if (typeof this._extendAgentCard === "function") {
+            return await this._extendAgentCard(context);
+        }
+        if (context?.user?.isAuthenticated) {
+            return this._extendAgentCard;
+        }
+        return await this.getAgentCard();
+    }
+    static create(service, _pushNotifications, extendAgentCard) {
+        if (!_pushNotifications) {
+            const pushNotifications = new PushNotifications();
+            pushNotifications.sender = new DefaultPushNotificationSender(pushNotifications);
+            return new Native(service, pushNotifications, extendAgentCard);
+        }
+        if (_pushNotifications instanceof PushNotifications) {
+            return new Native(service, _pushNotifications, extendAgentCard);
+        }
+        const pushNotifications = new PushNotifications(_pushNotifications?.store);
+        pushNotifications.sender =
+            _pushNotifications?.sender ??
+                new DefaultPushNotificationSender(pushNotifications);
+        return new Native(service, pushNotifications, extendAgentCard);
+    }
+}
+/**
+ * native adapter for `@a2a-js/sdk`
+ * @param service - The service to wrap
+ * @param pushNotifications - (optional) arguments for creating {@link PushNotifications}
+ * @param extendAgentCard - (optional) The extend agent card/provider to use
+ * @returns A {@link A2ARequestHandler} instance
+ * @example
+ * ```typescript
+ * const agent = cr8("Custom Agent")
+ *   .text("Hello!")
+ *   .agent;
+ * const nativeAdapter = native(agent, pushNotifications, extendAgentCard);
+ * ```
+ */
+export const native = Native.create;

package/dist/server/adapters/loadable.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2A } from "../../types/index.js";
+import { TaskStore } from "@a2a-js/sdk/server";
+export declare const tasks: (taskStore: TaskStore) => A2A.Tasks;

package/dist/server/adapters/loadable.js

@@ -0,0 +1,73 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2A } from "../../types/index.js";
+import { logger } from "../../config/index.js";
+import { handleUpdate } from "../../services/a2a/handlers/update.js";
+import { v4 } from "uuid";
+import { getCurrentTimestamp } from "../../utils/utils.js";
+class LoadManager {
+    _loadable;
+    constructor(_loadable) {
+        this._loadable = _loadable;
+    }
+    async get(id, _context) {
+        return await this._loadable.load(id, _context);
+    }
+    async set(id, data, context) {
+        return await this._loadable.save(data, context, id);
+    }
+    async delete(id) {
+        logger.warn("Delete not supported for loadable", { id });
+        return;
+    }
+    async has(id) {
+        return (await this._loadable.load(id)) !== undefined;
+    }
+}
+class TaskManager extends LoadManager {
+    constructor(_loadable) {
+        super(_loadable);
+    }
+    async update(context, update) {
+        logger.info(`TaskManager[update]: updating task`, {
+            taskId: context.taskId,
+        });
+        logger.debug(`TaskManager[update]: update`, { update });
+        logger.debug(`TaskManager[update]: context`, { context });
+        const task = await handleUpdate({
+            context,
+            task: await context.getTask(),
+            update,
+        });
+        logger.debug(`TaskManager[update]: task`, task);
+        await this.set(task.id, task);
+        return task;
+    }
+    async create(params) {
+        if (params.id) {
+            const task = await this.get(params.id);
+            if (task) {
+                return task;
+            }
+        }
+        logger.info(`TaskManager[create]: creating task`, { id: params.id });
+        const task = {
+            ...params,
+            id: params.id ?? v4(),
+            contextId: params.contextId ?? v4(),
+            kind: "task",
+            status: {
+                state: A2A.TaskState.submitted,
+                timestamp: getCurrentTimestamp(),
+            },
+        };
+        logger.debug(`TaskManager[create]:`, { taskId: task.id });
+        await this.set(task.id, task);
+        return task;
+    }
+}
+export const tasks = (taskStore) => {
+    return new TaskManager(taskStore);
+};

package/dist/server/adapters/notifications.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { PushNotificationStore, PushNotificationSender } from "@a2a-js/sdk/server";
+import { A2A, core } from "../../types/index.js";
+import { Manager } from "../../services/core/manager.js";
+export interface Notifications extends core.Manager<A2A.PushNotificationConfig[]> {
+    save: (taskId: string, pushNotificationConfig: A2A.PushNotificationConfig) => Promise<void>;
+    load: (taskId: string) => Promise<A2A.PushNotificationConfig[]>;
+    delete: (taskId: string, configId?: string) => Promise<void>;
+    send: (task: A2A.Task) => Promise<void>;
+}
+/** Cached Push Notifications Manager */
+export declare class PushNotifications extends Manager<A2A.PushNotificationConfig[]> implements Notifications {
+    private readonly _store;
+    private _sender;
+    constructor(store?: PushNotificationStore, sender?: PushNotificationSender);
+    get store(): PushNotificationStore | undefined;
+    get sender(): PushNotificationSender | undefined;
+    set sender(sender: PushNotificationSender | undefined);
+    save(taskId: string, pushNotificationConfig: A2A.PushNotificationConfig): Promise<void>;
+    load(taskId: string): Promise<A2A.PushNotificationConfig[]>;
+    delete(taskId: string, configId?: string): Promise<void>;
+    send(task: A2A.Task): Promise<void>;
+}

package/dist/server/adapters/notifications.js

@@ -0,0 +1,77 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { InMemoryPushNotificationStore, } from "@a2a-js/sdk/server";
+import { Manager } from "../../services/core/manager.js";
+/** Cached Push Notifications Manager */
+export class PushNotifications
+//May be more efficient to use a Record/Map instead of an array
+ extends Manager {
+    _store;
+    _sender;
+    constructor(store, sender) {
+        if (store && store instanceof InMemoryPushNotificationStore) {
+            /** We snatch its internal store to avoid creating a new Map and doubling memory usage */
+            super(store?.store);
+        }
+        else {
+            super();
+        }
+        this._store = store;
+        this._sender = sender;
+    }
+    get store() {
+        return this._store;
+    }
+    get sender() {
+        return this._sender;
+    }
+    set sender(sender) {
+        this._sender = sender;
+    }
+    async save(taskId, pushNotificationConfig) {
+        pushNotificationConfig.id = pushNotificationConfig.id ?? taskId;
+        /** Cache the configs in memory for faster access */
+        const configs = await this.get(taskId);
+        await this.set(taskId, [
+            ...(configs?.filter(
+            /**
+             * Since this is pure memory we can stomach the heavy filter operation for now,
+             * and its unlikely that an individual task will have excessive configs.
+             * @note Consider adding a warning when the filter operation is called with a large number of configs.
+             */
+            (config) => config.id !== pushNotificationConfig.id) ?? []),
+            pushNotificationConfig,
+        ]);
+        return await this.store?.save(taskId, pushNotificationConfig);
+    }
+    async load(taskId) {
+        let configs = await this.get(taskId);
+        /**
+         * Cache the configs in memory for faster access regardless of the storage layer.
+         * @note this may be removed once we have a persistant storage layer plugin.
+         */
+        if (!configs || configs.length === 0) {
+            configs = await this.store?.load(taskId);
+            if (configs && configs.length > 0) {
+                await this.set(taskId, configs);
+            }
+        }
+        return configs ?? [];
+    }
+    async delete(taskId, configId) {
+        if (configId) {
+            await this.set(taskId, (await this.get(taskId))?.filter((config) => config.id !== configId) ??
+                []);
+        }
+        else {
+            /**We dont need to maintain backward compatibility, so we can just delete all configs for the task*/
+            await super.delete(taskId);
+        }
+        await this.store?.delete(taskId, configId);
+    }
+    async send(task) {
+        return await this.sender?.send(task);
+    }
+}

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

@@ -3,31 +3,19 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import express from "express";
-import { A2A } from "../../types/index.js";
-import { Agent } from "../../services/a2a/index.js";
-import { ServiceParams as CreateAgentParams } from "../../services/index.js";
 import { CorsOptions } from "cors";
-export interface ServerParams {
+import { ServerParams as BaseServerParams } from "../params.js";
+export type ServerParams = BaseServerParams & {
     app?: express.Express;
     corsOptions?: CorsOptions;
-    basePath?: string;
-    port?: number;
-    /**
-     * Your agentCard must have supportsAuthenticatedExtendedCard set to true
-     */
-    extendedAgentCard?: A2A.AgentCard;
-    agent: Agent | CreateAgentParams;
-    agentCardPath?: string;
-    register?: boolean;
-}
-export declare function rpcParser(req: express.Request, res: express.Response, next: express.NextFunction): void;
+};
 /**
  * @note Best used with the `cr8` builder.
  * @param {ServerParams} params - The server parameters
  * @returns {ExpressAgentServer} - The express agent server
  * @example
  * ```typescript
- * const { app, agent, start } = createAgentServer({
+ * const { app, agent, start } = serve({
  *   agent: cr8("MyAgent")
  *     .text("Hello, world!")
  *     .agent,
@@ -35,9 +23,13 @@ export declare function rpcParser(req: express.Request, res: express.Response, n
  * });
  * ```
  */
-export declare function createAgentServer({ app, basePath, agentCardPath, agent, corsOptions, extendedAgentCard, register, port, }: ServerParams): {
+export declare function serve({ app, basePath, agentCardPath, agent, corsOptions, extendedAgentCard, register, port, userBuilder, }: ServerParams): {
     app: express.Express;
-    agent: Agent;
+    agent: import("../../index.js").Agent;
     start: (_port?: number) => import("node:http").Server<typeof import("node:http").IncomingMessage, typeof import("node:http").ServerResponse>;
 };
-export type ExpressAgentServer = ReturnType<typeof createAgentServer>;
+/**
+ * @deprecated Use `cr8.serve` instead.
+ */
+export declare const createAgentServer: typeof serve;
+export type ExpressAgentServer = ReturnType<typeof serve>;

package/dist/server/express/server.js

@@ -3,58 +3,18 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import express from "express";
-import { createAgent, Service, } from "../../services/index.js";
 import cors from "cors";
-import { jsonRPCMiddleware } from "./middeware.js";
-import { errorHandler } from "./errors.js";
 import { logger } from "../../config/index.js";
-import { A2AError } from "@a2a-js/sdk/server";
-import { formatJson } from "../../utils/common/utils.js";
-export function rpcParser(req, res, next) {
-    express.json()(req, res, (err) => {
-        if (!req.body || typeof req.body !== "object") {
-            return next(A2AError.parseError(`Invalid request body: ${formatJson(req.body)}`));
-        }
-        if (err) {
-            if (err instanceof SyntaxError &&
-                "status" in err &&
-                err.status === 400 &&
-                "body" in err) {
-                return next(A2AError.parseError(`Invalid request body: ${formatJson(req.body)}`));
-            }
-            return next(err);
-        }
-        next();
-    });
-}
-const isParams = (agentOrParams) => {
-    return (agentOrParams &&
-        typeof agentOrParams === "object" &&
-        "engine" in agentOrParams &&
-        typeof agentOrParams.engine === "function" &&
-        "agentCard" in agentOrParams &&
-        typeof agentOrParams.agentCard === "object");
-};
-const ensureAgent = (agentOrParams) => {
-    if (agentOrParams instanceof Service) {
-        return agentOrParams;
-    }
-    else if (isParams(agentOrParams)) {
-        return createAgent(agentOrParams);
-    }
-    throw new Error("invalid agent or params");
-};
-const registerAgent = async (agentCard) => {
-    logger.debug("registerAgent: not implemented", { agentCard });
-    return Promise.resolve(agentCard);
-};
+import { native } from "../adapters/a2a_request_handler.js";
+import { jsonRpcHandler, UserBuilder } from "@a2a-js/sdk/server/express";
+import { ensureAgent, registerAgent, } from "../params.js";
 /**
  * @note Best used with the `cr8` builder.
  * @param {ServerParams} params - The server parameters
  * @returns {ExpressAgentServer} - The express agent server
  * @example
  * ```typescript
- * const { app, agent, start } = createAgentServer({
+ * const { app, agent, start } = serve({
  *   agent: cr8("MyAgent")
  *     .text("Hello, world!")
  *     .agent,
@@ -62,38 +22,39 @@ const registerAgent = async (agentCard) => {
  * });
  * ```
  */
-export function createAgentServer({ app = express(), basePath = "/", agentCardPath = "/.well-known/agent-card.json", agent, corsOptions, extendedAgentCard, register = false, port, }) {
+export function serve({ app = express(), basePath = "/", agentCardPath = "/.well-known/agent-card.json", agent, corsOptions, extendedAgentCard, register = false, port, userBuilder = UserBuilder.noAuthentication, }) {
     const agentInstance = ensureAgent(agent);
-    app.use(cors(corsOptions));
+    /**
+     * Now that agents are services we can wrap them in any kind of transport layer
+     * or in express we can use json-rpc, but we could also use websockets, etc
+     */
+    agentInstance.getAgentCard().then((card) => {
+        const url = new URL(card.url);
+        if (!url.pathname.startsWith(basePath)) {
+            logger.warn(`AgentCard may be misconfigured: URL pathname ${url.pathname} does not start with base path ${basePath}, this may cause issues with the client.`);
+        }
+    });
+    const router = express.Router();
+    router.use(cors(corsOptions));
     if (agentCardPath !== "/.well-known/agent-card.json") {
-        // mount at the root for compliance with RFC8615 standard
         // todo: align with emerging multi-agent standards
-        app.use("/.well-known/agent-card.json", (_, res) => {
+        router.use(`/.well-known/agent-card.json`, (_, res) => {
             res.json(agentInstance.agentCard);
         });
     }
-    app.use(agentCardPath, (_, res) => {
+    router.use(`${agentCardPath}`, (_, res) => {
         // mount at the custom path
         res.json(agentInstance.agentCard);
     });
     // mount at the old agent card path for backwards compatibility
-    app.use("/.well-known/agent.json", (_, res) => {
+    router.use(`/.well-known/agent.json`, (_, res) => {
         res.json(agentInstance.agentCard);
     });
-    /**
-     * Now that agents are services we can wrap them in any kind of transport layer
-     * for express we can use json-rpc, but we could also use websockets, or any other
-     * transport layer.
-     */
-    //a standard express middleware to handle json-rpc requests
-    app.post(basePath, rpcParser, async (req, res, next) => {
-        const { jsonrpc } = req.body;
-        if (jsonrpc !== "2.0") {
-            return next(A2AError.invalidRequest("Invalid JSON-RPC request"));
-        }
-        return await jsonRPCMiddleware(agentInstance, req, res, next, extendedAgentCard);
-    });
-    app.use(errorHandler);
+    router.use(jsonRpcHandler({
+        requestHandler: native(agentInstance, undefined, extendedAgentCard),
+        userBuilder: userBuilder,
+    }));
+    app.use(basePath, router);
     /** this is an example of using trpc as express middleware
       app.use(
         `${basePath}`,
@@ -128,3 +89,7 @@ export function createAgentServer({ app = express(), basePath = "/", agentCardPa
     };
     return { app, agent: agentInstance, start };
 }
+/**
+ * @deprecated Use `cr8.serve` instead.
+ */
+export const createAgentServer = serve;

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

@@ -0,0 +1,14 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * @archive Helper utilities for express servers.
+ * @note We recommend using the @a2a-js/sdk/express middleware instead as these utilities will no longer be robustly maintained.
+ */
+import { type ErrorRequestHandler } from "express";
+import express from "express";
+export declare function rpcParser(req: express.Request, res: express.Response, next: express.NextFunction): void;
+/**
+ * Express error handler middleware.
+ */
+export declare const errorHandler: ErrorRequestHandler;

package/dist/server/express/{errors.js → utils.js}

@@ -1,11 +1,33 @@
 /**
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
+ *
+ * @archive Helper utilities for express servers.
+ * @note We recommend using the @a2a-js/sdk/express middleware instead as these utilities will no longer be robustly maintained.
  */
 import { SystemError } from "../../utils/index.js";
 import { logger } from "../../config/index.js";
 import escapeHtml from "escape-html";
 import { A2AError } from "@a2a-js/sdk/server";
+import { formatJson } from "../../utils/index.js";
+import express from "express";
+export function rpcParser(req, res, next) {
+    express.json()(req, res, (err) => {
+        if (!req.body || typeof req.body !== "object") {
+            return next(A2AError.parseError(`Invalid request body: ${formatJson(req.body)}`));
+        }
+        if (err) {
+            if (err instanceof SyntaxError &&
+                "status" in err &&
+                err.status === 400 &&
+                "body" in err) {
+                return next(A2AError.parseError(`Invalid request body: ${formatJson(req.body)}`));
+            }
+            return next(err);
+        }
+        next();
+    });
+}
 /**
  * Express error handler middleware.
  */

package/dist/server/index.d.ts

@@ -1 +1,4 @@
-export * from "./express/index.js";
+export { native } from "./adapters/a2a_request_handler.js";
+export { tasks } from "./adapters/loadable.js";
+export { serve, type ServerParams, type ExpressAgentServer, createAgentServer, } from "./express/server.js";
+export { rpcParser, errorHandler } from "./express/utils.js";

package/dist/server/index.js

@@ -1 +1,4 @@
-export * from "./express/index.js";
+export { native } from "./adapters/a2a_request_handler.js";
+export { tasks } from "./adapters/loadable.js";
+export { serve, createAgentServer, } from "./express/server.js";
+export { rpcParser, errorHandler } from "./express/utils.js";