@artinet/sdk 0.5.17 → 0.5.18

package/dist/client/a2a-client.js

@@ -2,9 +2,10 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import { executeJsonRpcRequest, executeGetRequest, executeStreamEvents, } from "../transport/index.js";
-import { INTERNAL_ERROR } from "../utils/index.js";
-import { logError } from "../utils/logging/index.js";
+import { executeJsonRpcRequest, executeGetRequest, } from "../transport/rpc/rpc-client.js";
+import { executeStreamEvents } from "../transport/streaming/event-stream.js";
+import { INTERNAL_ERROR } from "../utils/common/errors.js";
+import { logError } from "../utils/logging/log.js";
 import { createMessageSendParams } from "../services/a2a/helpers/message-builder.js";
 /**
  * A2AClient is the main client class for interacting with Agent2Agent (A2A) protocol-compliant services.
@@ -16,6 +17,7 @@ export class A2AClient {
     customHeaders = {};
     fallbackPath;
     agentUrl;
+    mergePath;
     /**
      * Creates a new A2AClient instance.
      * @param baseUrl The base URL for the A2A server.
@@ -30,11 +32,12 @@ export class A2AClient {
      * const card = await client.agentCard();
      * console.log(card);
      */
-    constructor(baseUrl, headers = {}, fallbackPath) {
+    constructor(baseUrl, headers = {}, fallbackPath, mergePath = false) {
         this.baseUrl = typeof baseUrl === "string" ? new URL(baseUrl) : baseUrl;
         this.customHeaders = headers;
         this.fallbackPath = fallbackPath ?? "/agent-card";
         this.agentUrl = this.baseUrl;
+        this.mergePath = mergePath;
     }
     /**
      * Retrieves the AgentCard from the A2A server.
@@ -47,6 +50,9 @@ export class A2AClient {
         }
         // Standard location for agent cards
         const wellKnownUrl = new URL("/.well-known/agent-card.json", this.baseUrl);
+        if (this.mergePath) {
+            wellKnownUrl.pathname = this.baseUrl.pathname + wellKnownUrl.pathname;
+        }
         try {
             try {
                 if (!URL.canParse(wellKnownUrl)) {
@@ -60,6 +66,9 @@ export class A2AClient {
             }
             catch (error) {
                 const fallbackUrl = new URL(this.fallbackPath, this.baseUrl);
+                if (this.mergePath) {
+                    fallbackUrl.pathname = this.baseUrl.pathname + fallbackUrl.pathname;
+                }
                 const fallbackCard = await executeGetRequest(fallbackUrl, this.customHeaders, "agent card (fallback)");
                 if (!fallbackCard.name ||
                     fallbackCard.name === null ||

package/dist/server/express/errors.js

@@ -13,7 +13,7 @@ export const errorHandler = (err, req, res, _) => {
     if (res.headersSent) {
         headersSent = true;
     }
-    logError("errorHandler", JSON.stringify(err), err);
+    logError("errorHandler", JSON.stringify(err, null, 2), err);
     let reqId = null;
     try {
         if (req.body && typeof req.body === "object" && "id" in req.body) {

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

@@ -3,5 +3,5 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { NextFunction, Request, Response } from "express";
-import { A2AServiceInterface } from "../../types/index.js";
-export declare function jsonRPCMiddleware(service: A2AServiceInterface, req: Request, res: Response, next: NextFunction): Promise<void>;
+import { A2AServiceInterface, AgentCard } from "../../types/index.js";
+export declare function jsonRPCMiddleware(service: A2AServiceInterface, req: Request, res: Response, next: NextFunction, extendedAgentCard?: AgentCard): Promise<void>;

package/dist/server/express/middeware.js

@@ -2,7 +2,7 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import { PUSH_NOTIFICATION_NOT_SUPPORTED, INVALID_REQUEST, INVALID_PARAMS, METHOD_NOT_FOUND, } from "../../utils/index.js";
+import { PUSH_NOTIFICATION_NOT_SUPPORTED, INVALID_REQUEST, INVALID_PARAMS, METHOD_NOT_FOUND, AUTHENTICATED_EXTENDED_CARD_NOT_CONFIGURED, } from "../../utils/index.js";
 import { logError } from "../../utils/logging/index.js";
 const isValidMethod = (method) => {
     return (method &&
@@ -12,8 +12,15 @@ const isValidMethod = (method) => {
         typeof method === "string");
 };
 const checkParams = (params, method) => {
-    if (!params ||
-        (typeof params === "object" && Object.keys(params).length === 0)) {
+    if (!params || (typeof params !== "object" && !Array.isArray(params))) {
+        throw INVALID_PARAMS({
+            data: {
+                message: "Invalid params",
+                method,
+            },
+        });
+    }
+    else if (typeof params === "object" && Object.keys(params).length === 0) {
         throw INVALID_PARAMS({
             data: {
                 message: "No params provided",
@@ -22,10 +29,10 @@ const checkParams = (params, method) => {
         });
     }
 };
-export async function jsonRPCMiddleware(service, req, res, next) {
+export async function jsonRPCMiddleware(service, req, res, next, extendedAgentCard) {
     const { method, params, id, jsonrpc } = req.body;
-    // Validate JSON-RPC format
-    if (jsonrpc !== "2.0" || !id) {
+    if (jsonrpc !== "2.0" ||
+        (id && typeof id !== "string" && typeof id !== "number" && id !== null)) {
         res.json({
             jsonrpc: "2.0",
             id: id || null,
@@ -98,6 +105,19 @@ export async function jsonRPCMiddleware(service, req, res, next) {
                     },
                 });
             }
+            case "agent/getAuthenticatedExtendedCard": {
+                if (!extendedAgentCard ||
+                    service.agentCard.supportsAuthenticatedExtendedCard !== true) {
+                    throw AUTHENTICATED_EXTENDED_CARD_NOT_CONFIGURED({
+                        data: {
+                            message: "Authenticated Extended Card is not configured",
+                            method,
+                        },
+                    });
+                }
+                result = extendedAgentCard;
+                break;
+            }
             default:
                 throw METHOD_NOT_FOUND({
                     data: {

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

@@ -3,12 +3,13 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import express from "express";
-import { Agent, FactoryParams as CreateAgentParams } from "../../types/index.js";
+import { Agent, AgentCard, FactoryParams as CreateAgentParams } from "../../types/index.js";
 import { CorsOptions } from "cors";
 export interface ServerParams {
     app?: express.Express;
     corsOptions?: CorsOptions;
     basePath?: string;
+    extendedAgentCard?: AgentCard;
 }
 export declare function createAgentServer(params: ServerParams & {
     agent: Agent | CreateAgentParams;

package/dist/server/express/server.js

@@ -3,11 +3,27 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import express from "express";
-import { INVALID_REQUEST } from "../../utils/index.js";
+import { INVALID_REQUEST, PARSE_ERROR } from "../../utils/index.js";
 import { createAgent } from "../../services/index.js";
 import cors from "cors";
 import { jsonRPCMiddleware } from "./middeware.js";
 import { errorHandler } from "./errors.js";
+function rpcParser(req, res, next) {
+    express.json()(req, res, (err) => {
+        if (err) {
+            if (err instanceof SyntaxError &&
+                "status" in err &&
+                err.status === 400 &&
+                "body" in err) {
+                return next(PARSE_ERROR({
+                    data: err.message,
+                }));
+            }
+            return next(err);
+        }
+        next();
+    });
+}
 function ensureAgent(agentOrParams) {
     if (agentOrParams &&
         typeof agentOrParams === "object" &&
@@ -40,9 +56,19 @@ function ensureAgent(agentOrParams) {
 export function createAgentServer(params) {
     const { app = express(), basePath = "/", agentCardPath = "/.well-known/agent-card.json", agent, } = params;
     const agentInstance = ensureAgent(agent);
-    app.use(express.json());
     app.use(cors(params.corsOptions));
-    app.get(agentCardPath, (_, res) => {
+    if (agentCardPath !== "/.well-known/agent-card.json") {
+        // mount at the root for compliance with RFC8615 standard
+        app.use("/.well-known/agent-card.json", (_, res) => {
+            res.json(agentInstance.agentCard);
+        });
+    }
+    app.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) => {
         res.json(agentInstance.agentCard);
     });
     /**
@@ -51,10 +77,10 @@ export function createAgentServer(params) {
      * transport layer.
      */
     //a standard express middleware to handle json-rpc requests
-    app.post(basePath, express.json(), async (req, res, next) => {
+    app.post(basePath, rpcParser, async (req, res, next) => {
         const { jsonrpc } = req.body;
         if (jsonrpc === "2.0") {
-            return await jsonRPCMiddleware(agentInstance, req, res, next);
+            return await jsonRPCMiddleware(agentInstance, req, res, next, params.extendedAgentCard);
         }
         next(INVALID_REQUEST({ data: { message: "Invalid JSON-RPC request" } }));
     });
@@ -73,7 +99,7 @@ export function createAgentServer(params) {
           },
         })
       );
-     * we could also just use trpc directly or any other transport layer
+     * we could also use trpc directly or any other transport layer
      */
     return { app, agent: agentInstance };
 }

package/dist/services/a2a/factory/builder.js

@@ -299,6 +299,7 @@ export function createAgentExecutor(stepsList) {
         }
         const taskStarted = SUBMITTED_UPDATE(taskId, contextId);
         yield taskStarted;
+        let finalState = TaskState.completed;
         const finalMessage = {
             taskId: taskId,
             contextId: contextId,
@@ -308,6 +309,10 @@ export function createAgentExecutor(stepsList) {
             parts: [],
         };
         for (const step of stepsList) {
+            if (context.isCancelled()) {
+                finalState = TaskState.canceled;
+                break;
+            }
             const ret = await step.step({ ...stepArgs });
             let parts = [];
             if (Array.isArray(ret)) {
@@ -350,7 +355,7 @@ export function createAgentExecutor(stepsList) {
             id: taskId,
             contextId: contextId,
             status: {
-                state: TaskState.completed,
+                state: finalState,
                 timestamp: new Date().toISOString(),
                 message: finalMessage,
             },

package/dist/services/a2a/factory/service.js

@@ -7,6 +7,6 @@ import { ContextManager, ConnectionManager, CancellationManager, TaskManager, }
 import { createMethods } from "./method.js";
 import { createAgentCard } from "../helpers/agentcard-builder.js";
 export function createService(params) {
-    return new A2AService(createAgentCard(params.agentCard), params.engine, params.contexts ?? new ContextManager(), params.connections ?? new ConnectionManager(), params.cancellations ?? new CancellationManager(), params.tasks ?? new TaskManager(), createMethods(params.methods), params.events);
+    return new A2AService(createAgentCard(params.agentCard), params.engine, params.contexts ?? new ContextManager(), params.connections ?? new ConnectionManager(), params.cancellations ?? new CancellationManager(), params.tasks ?? new TaskManager(), createMethods(params.methods), params.events, params.enforceParamValidation ?? false);
 }
 export const createAgent = createService;

package/dist/services/a2a/helpers/agentcard-builder.js

@@ -11,6 +11,7 @@ export class AgentCardBuilder {
             defaultInputModes: agentCard.defaultInputModes ?? [],
             defaultOutputModes: agentCard.defaultOutputModes ?? [],
             skills: agentCard.skills ?? [],
+            preferredTransport: agentCard.preferredTransport ?? "JSONRPC",
         };
     }
     valueOf() {

package/dist/services/a2a/helpers/history.d.ts

@@ -0,0 +1,2 @@
+import { Message, Task } from "../../../types/index.js";
+export declare function getLatestHistory(task: Task, length?: number): Message[];

package/dist/services/a2a/helpers/history.js

@@ -0,0 +1,3 @@
+export function getLatestHistory(task, length) {
+    return length ? task.history?.slice(-length) ?? [] : task.history ?? [];
+}

package/dist/services/a2a/helpers/index.d.ts

@@ -2,3 +2,5 @@ export * from "./part.js";
 export * from "./content.js";
 export * from "./message-builder.js";
 export * from "./agentcard-builder.js";
+export * from "./history.js";
+export * from "../../../utils/common/schema-validation.js";

package/dist/services/a2a/helpers/index.js

@@ -2,3 +2,5 @@ export * from "./part.js";
 export * from "./content.js";
 export * from "./message-builder.js";
 export * from "./agentcard-builder.js";
+export * from "./history.js";
+export * from "../../../utils/common/schema-validation.js";

package/dist/services/a2a/methods/get-task.js

@@ -3,6 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { TASK_NOT_FOUND } from "../../../utils/index.js";
+import { getLatestHistory } from "../helpers/index.js";
 export async function getTask(input, params) {
     const { service } = params;
     const state = await service.getState(input.id);
@@ -10,5 +11,6 @@ export async function getTask(input, params) {
     if (!task) {
         throw TASK_NOT_FOUND({ taskId: input.id });
     }
+    task.history = getLatestHistory(task, input.historyLength);
     return task;
 }

package/dist/services/a2a/methods/send-message.js

@@ -3,6 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { createContext } from "../factory/context.js";
+import { getLatestHistory } from "../helpers/index.js";
 export async function sendMessage(input, params) {
     const { service, engine, contextManager, signal } = params;
     const contextId = input.message.contextId;
@@ -13,7 +14,23 @@ export async function sendMessage(input, params) {
     context.events.on("error", () => {
         context.events.onComplete();
     });
+    if (input.configuration?.blocking === false) {
+        const result = await Promise.race([
+            service.execute(engine, context).then(() => {
+                const state = context.events.getState();
+                return state.task ?? state;
+            }),
+            new Promise((resolve) => {
+                context.events.on("start", (_, state) => {
+                    resolve(state.task ?? state);
+                });
+            }),
+        ]);
+        return result;
+    }
     await service.execute(engine, context);
     const state = context.events.getState();
-    return state.task ?? state;
+    const task = state.task ?? state;
+    task.history = getLatestHistory(task, input.configuration?.historyLength);
+    return task;
 }

package/dist/services/a2a/service.d.ts

@@ -12,7 +12,8 @@ export declare class A2AService implements A2AServiceInterface {
     private contexts;
     private methods;
     readonly eventOverrides: EventManagerOptions<Command, State, Update> | undefined;
-    constructor(agentCard: AgentCard, engine: A2AEngine, contexts: ContextManagerInterface<Command, State, Update>, connections: ConnectionManagerInterface, cancellations: CancellationManagerInterface, tasks: TaskManagerInterface<TaskAndHistory>, methods: MethodOptions, eventOverrides?: EventManagerOptions<Command, State, Update>);
+    private enforceParamValidation;
+    constructor(agentCard: AgentCard, engine: A2AEngine, contexts: ContextManagerInterface<Command, State, Update>, connections: ConnectionManagerInterface, cancellations: CancellationManagerInterface, tasks: TaskManagerInterface<TaskAndHistory>, methods: MethodOptions, eventOverrides?: EventManagerOptions<Command, State, Update>, enforceParamValidation?: boolean);
     execute(engine: A2AEngine, context: CoreContext<Command, State, Update>): Promise<void>;
     stop(): Promise<void>;
     addConnection(id: string): void;

package/dist/services/a2a/service.js

@@ -2,8 +2,10 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
+import { MessageSendParamsSchema, TaskQueryParamsSchema, TaskIdParamsSchema, } from "../../types/index.js";
 import { coreExecute } from "../core/execution/execute.js";
 import { createMessageSendParams } from "./helpers/message-builder.js";
+import { validateSchema } from "../../utils/common/schema-validation.js";
 export class A2AService {
     agentCard;
     engine;
@@ -13,7 +15,8 @@ export class A2AService {
     contexts;
     methods;
     eventOverrides;
-    constructor(agentCard, engine, contexts, connections, cancellations, tasks, methods, eventOverrides) {
+    enforceParamValidation = false;
+    constructor(agentCard, engine, contexts, connections, cancellations, tasks, methods, eventOverrides, enforceParamValidation = false) {
         this.engine = engine;
         this.agentCard = agentCard;
         this.contexts = contexts;
@@ -22,6 +25,7 @@ export class A2AService {
         this.tasks = tasks;
         this.methods = methods;
         this.eventOverrides = eventOverrides;
+        this.enforceParamValidation = enforceParamValidation;
     }
     async execute(engine, context) {
         await coreExecute(engine ?? this.engine, context);
@@ -55,16 +59,22 @@ export class A2AService {
         await this.tasks.setState(id, data);
     }
     async getTask(input) {
-        return await this.methods.getTask(input, { service: this });
+        return await this.methods.getTask(this.enforceParamValidation
+            ? await validateSchema(TaskQueryParamsSchema, input)
+            : input, { service: this });
     }
     async cancelTask(input) {
-        return await this.methods.cancelTask(input, {
+        return await this.methods.cancelTask(this.enforceParamValidation
+            ? await validateSchema(TaskIdParamsSchema, input)
+            : input, {
             service: this,
             contextManager: this.contexts,
         });
     }
     async sendMessage(message, params) {
-        return await this.methods.sendMessage(createMessageSendParams(message), {
+        return await this.methods.sendMessage(this.enforceParamValidation
+            ? await validateSchema(MessageSendParamsSchema, message)
+            : createMessageSendParams(message), {
             ...params, //we may include additional params in the future that may not need to be handled by the service
             service: this,
             engine: params?.engine ?? this.engine,
@@ -73,7 +83,9 @@ export class A2AService {
         });
     }
     async *streamMessage(message, params) {
-        yield* this.methods.streamMessage(createMessageSendParams(message), {
+        yield* this.methods.streamMessage(this.enforceParamValidation
+            ? await validateSchema(MessageSendParamsSchema, message)
+            : createMessageSendParams(message), {
             ...params,
             service: this,
             engine: params?.engine ?? this.engine,
@@ -82,7 +94,9 @@ export class A2AService {
         });
     }
     async *resubscribe(input, params) {
-        yield* this.methods.resubscribe(input, {
+        yield* this.methods.resubscribe(this.enforceParamValidation
+            ? await validateSchema(TaskIdParamsSchema, input)
+            : input, {
             ...params,
             service: this,
             engine: params?.engine ?? this.engine,

package/dist/services/mcp/service.js

@@ -61,7 +61,6 @@ export class BaseMCPService extends McpServer {
         this.registerResource("agent-card", uri, {
             title: "Agent Card",
             description: AgentCardSchema.description,
-            outputSchema: AgentCardSchema.shape,
             mimeType: "application/json",
         }, async (uri) => {
             return {

package/dist/transport/rpc/parser.js

@@ -3,8 +3,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { JSONRPCErrorSchema, } from "../../types/index.js";
-import { SystemError, PARSE_ERROR } from "../../utils/index.js";
-import { logError } from "../../utils/logging/index.js";
+import { SystemError, PARSE_ERROR } from "../../utils/common/errors.js";
+import { logError } from "../../utils/logging/log.js";
 /**
  * Parses a JSON-RPC response string and validates its structure.
  * If the response contains an error, it is thrown as an A2AError.

package/dist/transport/rpc/rpc-client.js

@@ -7,9 +7,9 @@
  * Handles the common pattern of sending JSON-RPC requests and processing responses.
  */
 import { v4 as uuidv4 } from "uuid";
-import { SystemError, INTERNAL_ERROR, PARSE_ERROR } from "../../utils/index.js";
+import { SystemError, INTERNAL_ERROR, PARSE_ERROR, } from "../../utils/common/errors.js";
 import { parseResponse } from "./parser.js";
-import { logError, logWarn } from "../../utils/logging/index.js";
+import { logError, logWarn } from "../../utils/logging/log.js";
 /**
  * Creates a JSON-RPC request body with the specified method and parameters.
  *, ErrorCodeParseError

package/dist/types/interfaces/services/a2a/service.d.ts

@@ -67,6 +67,8 @@ export interface FactoryParams {
     methods?: Partial<MethodOptions>;
     /** Optional event manager configuration overrides */
     events?: EventManagerOptions<Command, State, Update>;
+    /** Enforce parameter validation */
+    enforceParamValidation?: boolean;
 }
 /**
  * Parameters passed to A2A method implementations.
@@ -109,6 +111,8 @@ export interface MethodParams {
     contextManager: ContextManagerInterface<Command, State, Update>;
     /** Abort signal for cancellation handling */
     signal: AbortSignal;
+    /** Enforce input validation */
+    enforceValidation?: boolean;
 }
 /**
  * Custom method implementation options for A2A services.

package/dist/utils/common/constants.js

@@ -3,7 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { TaskState } from "../../types/index.js";
-import { getCurrentTimestamp } from "../index.js";
+import { getCurrentTimestamp } from "./utils.js";
 //todo: protocol specific so move to a2a folder
 export const STATUS_UPDATE = (taskId, contextId, status, message, timestamp = getCurrentTimestamp(), final = false) => {
     return {

package/dist/utils/common/errors.d.ts

@@ -2,7 +2,7 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import { A2AError, InvalidParamsError, InvalidRequestError, JSONRPCError, MethodNotFoundError, InternalError, TaskNotFoundError, TaskNotCancelableError, ContentTypeNotSupportedError, InvalidAgentResponseError, TaskStatusUpdateEvent, JSONParseError } from "../../types/index.js";
+import { A2AError, InvalidParamsError, InvalidRequestError, JSONRPCError, MethodNotFoundError, InternalError, TaskNotFoundError, TaskNotCancelableError, ContentTypeNotSupportedError, InvalidAgentResponseError, TaskStatusUpdateEvent, JSONParseError, AuthenticatedExtendedCardNotConfiguredError } from "../../types/index.js";
 export declare class SystemError<T extends JSONRPCError> extends Error {
     message: string;
     code: T["code"];
@@ -17,6 +17,7 @@ export declare const INTERNAL_ERROR: <T extends InternalError>(data: T["data"])
 export declare const TASK_NOT_FOUND: <T extends TaskNotFoundError>(data: T["data"]) => SystemError<T>;
 export declare const TASK_NOT_CANCELABLE: <T extends TaskNotCancelableError>(data: T["data"]) => SystemError<T>;
 export declare const PUSH_NOTIFICATION_NOT_SUPPORTED: <T extends A2AError>(data: T["data"]) => SystemError<T>;
+export declare const AUTHENTICATED_EXTENDED_CARD_NOT_CONFIGURED: <T extends AuthenticatedExtendedCardNotConfiguredError>(data: T["data"]) => SystemError<T>;
 export declare const UNSUPPORTED_OPERATION: <T extends A2AError>(data: T["data"]) => SystemError<T>;
 export declare const CONTENT_TYPE_NOT_SUPPORTED: <T extends ContentTypeNotSupportedError>(data: T["data"]) => SystemError<T>;
 export declare const INVALID_AGENT_RESPONSE: <T extends InvalidAgentResponseError>(data: T["data"]) => SystemError<T>;

package/dist/utils/common/errors.js

@@ -2,7 +2,7 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import { ErrorCodeInternalError, ErrorCodeInvalidRequest, ErrorCodeMethodNotFound, ErrorCodeParseError, ErrorCodeInvalidParams, ErrorCodeTaskNotFound, ErrorCodeTaskNotCancelable, ErrorCodeUnsupportedOperation, ErrorCodePushNotificationNotSupported, ErrorCodeContentTypeNotSupported, ErrorCodeInvalidAgentResponse, TaskState, } from "../../types/index.js";
+import { ErrorCodeInternalError, ErrorCodeInvalidRequest, ErrorCodeMethodNotFound, ErrorCodeParseError, ErrorCodeInvalidParams, ErrorCodeTaskNotFound, ErrorCodeTaskNotCancelable, ErrorCodeUnsupportedOperation, ErrorCodePushNotificationNotSupported, ErrorCodeContentTypeNotSupported, ErrorCodeInvalidAgentResponse, TaskState, ErrorCodeAuthenticatedExtendedCardNotConfigured, } from "../../types/index.js";
 export class SystemError extends Error {
     message;
     code;
@@ -24,6 +24,7 @@ export const INTERNAL_ERROR = (data) => new SystemError("Internal error", ErrorC
 export const TASK_NOT_FOUND = (data) => new SystemError("Task not found", ErrorCodeTaskNotFound, data);
 export const TASK_NOT_CANCELABLE = (data) => new SystemError("Task cannot be canceled", ErrorCodeTaskNotCancelable, data);
 export const PUSH_NOTIFICATION_NOT_SUPPORTED = (data) => new SystemError("Push Notifications is not supported", ErrorCodePushNotificationNotSupported, data);
+export const AUTHENTICATED_EXTENDED_CARD_NOT_CONFIGURED = (data) => new SystemError("Authenticated Extended Card is not configured", ErrorCodeAuthenticatedExtendedCardNotConfigured, data);
 export const UNSUPPORTED_OPERATION = (data) => new SystemError("This operation is not supported", ErrorCodeUnsupportedOperation, data);
 export const CONTENT_TYPE_NOT_SUPPORTED = (data) => new SystemError("Content type not supported", ErrorCodeContentTypeNotSupported, data);
 export const INVALID_AGENT_RESPONSE = (data) => new SystemError("Invalid agent response", ErrorCodeInvalidAgentResponse, data);

package/dist/utils/common/schema-validation.d.ts

@@ -0,0 +1,2 @@
+import { z } from "zod/v3";
+export declare function validateSchema<T extends z.ZodSchema>(schema: T, data: unknown): Promise<z.infer<T>>;

package/dist/utils/common/schema-validation.js

@@ -0,0 +1,12 @@
+import { INVALID_PARAMS } from "../index.js";
+import { logError } from "../logging/index.js";
+export async function validateSchema(schema, data) {
+    return await schema.parseAsync(data).catch((error) => {
+        logError("Schema validation failed", error.message, error);
+        throw INVALID_PARAMS({
+            data: {
+                message: error.message,
+            },
+        });
+    });
+}

package/dist/utils/index.d.ts

@@ -4,6 +4,7 @@
  */
 export * from "./common/constants.js";
 export * from "./common/errors.js";
+export * from "./common/schema-validation.js";
 export * from "./common/utils.js";
 export * from "./common/zAsyncIterable-v3.js";
 export * from "./logging/index.js";

package/dist/utils/index.js

@@ -4,6 +4,7 @@
  */
 export * from "./common/constants.js";
 export * from "./common/errors.js";
+export * from "./common/schema-validation.js";
 export * from "./common/utils.js";
 export * from "./common/zAsyncIterable-v3.js";
 export * from "./logging/index.js";