@artinet/sdk 0.5.17 → 0.5.18

package/dist/browser/types/schemas/a2a/task.js

@@ -0,0 +1,134 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { z } from "zod";
+import { MessageSchema, ArtifactSchema } from "./parameters.js";
+import { JSONRPCErrorResponseSchema, JSONRPCRequestSchema, JSONRPCSuccessResponseSchema, } from "./rpc.js";
+import { KindSchema } from "./kind.js";
+/**
+ * @description Represents the state of a task within the A2A protocol.
+ */
+export const TaskStateSchema = z
+    .enum([
+    "submitted",
+    "working",
+    "input-required",
+    "completed",
+    "canceled",
+    "failed",
+    "rejected",
+    "auth-required",
+    "unknown",
+])
+    .describe("Defines the lifecycle states of a Task.");
+export const TaskState = TaskStateSchema.enum;
+/**
+ * Basic parameters used for task ID operations.
+ */
+export const TaskIdParamsSchema = z
+    .object({
+    id: z.string().describe("The ID of the task to query."),
+    metadata: z
+        .record(z.string(), z.unknown())
+        .optional()
+        .describe("Additional metadata to include in the request."),
+})
+    .describe("Defines the parameters for a request to get a task.");
+/**
+ * Parameters used for querying task-related information by ID.
+ */
+export const TaskQueryParamsSchema = TaskIdParamsSchema.extend({
+    historyLength: z.number().optional(),
+});
+/**
+ * Represents the status of a task at a specific point in time.
+ */
+export const TaskStatusSchema = z.object({
+    state: TaskStateSchema,
+    message: MessageSchema.optional(),
+    timestamp: z.string().datetime().optional(),
+});
+/**
+ * Represents a task being processed by an agent.
+ */
+export const TaskSchema = z.object({
+    id: z.string(),
+    contextId: z.string(),
+    status: TaskStatusSchema,
+    history: z.array(MessageSchema).optional(),
+    artifacts: z.array(ArtifactSchema).optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+    kind: KindSchema.refine((kind) => kind === "task"),
+});
+/**
+ * Represents a status update event for a task, typically used in streaming scenarios.
+ */
+export const TaskStatusUpdateEventSchema = z.object({
+    taskId: z.string(),
+    contextId: z.string(),
+    kind: KindSchema.refine((kind) => kind === "status-update"),
+    status: TaskStatusSchema,
+    final: z.boolean(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+});
+/**
+ * Represents an artifact update event for a task, typically used in streaming scenarios.
+ */
+export const TaskArtifactUpdateEventSchema = z.object({
+    taskId: z.string(),
+    contextId: z.string(),
+    kind: KindSchema.refine((kind) => kind === "artifact-update"),
+    artifact: ArtifactSchema,
+    append: z.boolean().optional(),
+    lastChunk: z.boolean().optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+});
+/**
+ * @description Request to retrieve the current state of a task.
+ */
+export const GetTaskRequestSchema = JSONRPCRequestSchema.extend({
+    method: z.literal("tasks/get"),
+    params: TaskQueryParamsSchema.describe("Defines the parameters for a request to get a task."),
+}).describe("Represents a JSON-RPC request for the `tasks/get` method.");
+/**
+ * @description Represents a successful JSON-RPC response for the `tasks/get` method.
+ */
+export const GetTaskSuccessResponseSchema = JSONRPCSuccessResponseSchema.extend({
+    /**
+     * @required The result of the request, which can be a direct reply Message or the initial Task object.
+     */
+    result: TaskSchema.describe("The result of the request, which can be a direct reply Message or the initial Task object."),
+}).describe("JSON-RPC success response model for the 'tasks/get' method.");
+/**
+ * @description Represents a JSON-RPC response for the `tasks/get` method.
+ */
+export const GetTaskResponseSchema = z
+    .union([GetTaskSuccessResponseSchema, JSONRPCErrorResponseSchema])
+    .describe("Represents a JSON-RPC response for the `tasks/get` method.");
+/**
+ * @description Request to re-subscribe to a task's updates.
+ */
+export const TaskResubscriptionRequestSchema = JSONRPCRequestSchema.extend({
+    method: z.literal("tasks/resubscribe"),
+    params: TaskIdParamsSchema.describe("Defines the parameters for a request to re-subscribe to a task's updates."),
+}).describe("Represents a JSON-RPC request for the `tasks/resubscribe` method.");
+/**
+ * @description Request to cancel a task.
+ */
+export const CancelTaskRequestSchema = JSONRPCRequestSchema.extend({
+    method: z.literal("tasks/cancel"),
+    params: TaskIdParamsSchema.describe("Defines the parameters for a request to cancel a task."),
+}).describe("Represents a JSON-RPC request for the `tasks/cancel` method.");
+/**
+ * @description Represents a successful JSON-RPC response for the `tasks/cancel` method.
+ */
+export const CancelTaskSuccessResponseSchema = JSONRPCSuccessResponseSchema.extend({
+    result: TaskSchema.describe("The result of the request, which can be a direct reply Message or the initial Task object."),
+}).describe("JSON-RPC success response model for the 'tasks/cancel' method.");
+/**
+ * @description Represents a JSON-RPC response for the `tasks/cancel` method.
+ */
+export const CancelTaskResponseSchema = z
+    .union([CancelTaskSuccessResponseSchema, JSONRPCErrorResponseSchema])
+    .describe("Represents a JSON-RPC response for the `tasks/cancel` method.");

package/dist/browser/types/schemas/a2a/transport.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { z } from "zod";
+/**
+ * @description Supported A2A transport protocols.
+ */
+export declare const TransportProtocolSchema: z.ZodEnum<["JSONRPC", "GRPC", "HTTP+JSON"]>;
+export type TransportProtocol = z.infer<typeof TransportProtocolSchema>;
+/**
+ * @description Declares a combination of a target URL and a transport protocol for interacting with the agent.
+ * This allows agents to expose the same functionality over multiple transport mechanisms.
+ */
+export declare const AgentInterfaceSchema: z.ZodObject<{
+    /**
+     * @required The URL where this interface is available. Must be a valid absolute HTTPS URL in production.
+     */
+    url: z.ZodString;
+    /**
+     * @required The transport protocol supported at this URL.
+     */
+    transport: z.ZodUnion<[z.ZodEnum<["JSONRPC", "GRPC", "HTTP+JSON"]>, z.ZodString]>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    transport: string;
+}, {
+    url: string;
+    transport: string;
+}>;
+export type AgentInterface = z.infer<typeof AgentInterfaceSchema>;

package/dist/browser/types/schemas/a2a/transport.js

@@ -0,0 +1,28 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { z } from "zod";
+/**
+ * @description Supported A2A transport protocols.
+ */
+export const TransportProtocolSchema = z.enum(["JSONRPC", "GRPC", "HTTP+JSON"]);
+/**
+ * @description Declares a combination of a target URL and a transport protocol for interacting with the agent.
+ * This allows agents to expose the same functionality over multiple transport mechanisms.
+ */
+export const AgentInterfaceSchema = z.object({
+    /**
+     * @required The URL where this interface is available. Must be a valid absolute HTTPS URL in production.
+     */
+    url: z
+        .string()
+        .url()
+        .describe("The URL where this interface is available. Must be a valid absolute HTTPS URL in production."),
+    /**
+     * @required The transport protocol supported at this URL.
+     */
+    transport: z
+        .union([TransportProtocolSchema, z.string()])
+        .describe("The transport protocol supported at this URL."),
+});

package/dist/browser/types/schemas/index.d.ts

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

package/dist/browser/types/schemas/index.js

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

package/dist/browser/types/utils/index.d.ts

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

package/dist/browser/types/utils/index.js

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

package/dist/browser/types/utils/transform.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Type-safe object key transformation utilities using built-in TypeScript utility types
+ */
+/**
+ * Forces TypeScript to evaluate and flatten intersection types into a single object type
+ * This makes IDE tooltips and type displays much cleaner
+ */
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/**
+ * Configuration for renaming keys - maps old key names to new key names
+ * For best results, use `as const` to preserve literal string types
+ */
+export type RenameConfig<T extends object> = {
+    readonly [K in keyof T]?: string;
+};
+/**
+ * Transform object type by renaming specified keys using built-in utility types
+ * This combines Pick/Omit patterns with Record to achieve key renaming
+ * Uses Simplify to flatten the final type for cleaner IDE display
+ */
+export type TransformKeys<T extends object, Config extends RenameConfig<T>> = Simplify<Omit<T, keyof Config> & {
+    [OriginalKey in keyof Config & keyof T as Config[OriginalKey] extends string ? Config[OriginalKey] : OriginalKey]: T[OriginalKey];
+}>;
+/**
+ * Runtime function to transform object keys based on configuration
+ * Uses the TransformKeys utility type for return type inference
+ */
+export declare function transformKeys<T extends object, Config extends RenameConfig<T>>(obj: T, config: Config): TransformKeys<T, Config>;
+/**
+ * Helper type to extract the transformed type for a given object and config
+ * Useful for declaring variables with the expected transformed type
+ * Uses Simplify to show clean, flattened types in IDE
+ */
+export type Transformed<T extends object, Config extends RenameConfig<T>> = Simplify<TransformKeys<T, Config>>;
+/**
+ * Utility to create a type-safe rename configuration with better intellisense
+ * The returned function preserves literal string types
+ */
+export declare function createRenameConfig<T extends object>(): <Config extends RenameConfig<T>>(config: Config) => Config;
+/**
+ * Common transformation patterns using built-in utility types
+ */
+export declare namespace TransformPatterns {
+    /**
+     * Convert snake_case keys to camelCase
+     * This is a type-level template but would need runtime implementation
+     */
+    type SnakeToCamel<T extends string> = T extends `${infer First}_${infer Rest}` ? `${First}${Capitalize<SnakeToCamel<Rest>>}` : T;
+    /**
+     * Pick specific keys and optionally rename them
+     */
+    type PickAndRename<T extends object, Keys extends keyof T, Config extends Partial<Record<Keys, string>>> = Simplify<TransformKeys<Pick<T, Keys>, Config>>;
+    /**
+     * Omit specific keys and optionally rename remaining ones
+     */
+    type OmitAndRename<T extends object, OmitKeys extends keyof T, Config extends RenameConfig<Omit<T, OmitKeys>>> = Simplify<TransformKeys<Omit<T, OmitKeys>, Config>>;
+}
+export {};

package/dist/browser/types/utils/transform.js

@@ -0,0 +1,35 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Runtime function to transform object keys based on configuration
+ * Uses the TransformKeys utility type for return type inference
+ */
+export function transformKeys(obj, config) {
+    const result = {};
+    // Process each property in the original object
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            const newKeyName = config[key];
+            if (typeof newKeyName === "string") {
+                // Rename the key
+                result[newKeyName] = obj[key];
+            }
+            else {
+                // Keep original key
+                result[key] = obj[key];
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Utility to create a type-safe rename configuration with better intellisense
+ * The returned function preserves literal string types
+ */
+export function createRenameConfig() {
+    return function (config) {
+        return config;
+    };
+}

package/dist/browser/utils/common/constants.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TaskState, TaskStatusUpdateEvent, Message } from "../../types/index.js";
+export declare const STATUS_UPDATE: (taskId: string, contextId: string, status: TaskState, message?: Message, timestamp?: string, final?: boolean) => TaskStatusUpdateEvent;
+export declare const WORKING_UPDATE: (taskId: string, contextId: string, message?: Message, timestamp?: string) => TaskStatusUpdateEvent;
+export declare const CANCEL_UPDATE: (taskId: string, contextId: string, message?: Message, timestamp?: string) => TaskStatusUpdateEvent;
+export declare const SUBMITTED_UPDATE: (taskId: string, contextId: string, message?: Message, timestamp?: string) => TaskStatusUpdateEvent;
+export declare const FAILED_UPDATE_EVENT: (taskId: string, contextId: string, message?: Message, timestamp?: string) => TaskStatusUpdateEvent;
+export declare const FINAL_STATES: TaskState[];

package/dist/browser/utils/common/constants.js

@@ -0,0 +1,38 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TaskState } from "../../types/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 {
+        taskId: taskId,
+        contextId: contextId,
+        kind: "status-update",
+        status: {
+            state: status,
+            message: message,
+            timestamp: timestamp,
+        },
+        final: final,
+    };
+};
+export const WORKING_UPDATE = (taskId, contextId, message, timestamp) => {
+    return STATUS_UPDATE(taskId, contextId, TaskState.working, message, timestamp);
+};
+export const CANCEL_UPDATE = (taskId, contextId, message, timestamp) => {
+    return STATUS_UPDATE(taskId, contextId, TaskState.canceled, message, timestamp, true);
+};
+export const SUBMITTED_UPDATE = (taskId, contextId, message, timestamp) => {
+    return STATUS_UPDATE(taskId, contextId, TaskState.submitted, message, timestamp);
+};
+export const FAILED_UPDATE_EVENT = (taskId, contextId, message, timestamp) => {
+    return STATUS_UPDATE(taskId, contextId, TaskState.failed, message, timestamp, true);
+};
+export const FINAL_STATES = [
+    TaskState.completed,
+    TaskState.failed,
+    TaskState.canceled,
+    TaskState.rejected,
+];

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

@@ -0,0 +1,24 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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"];
+    data: T["data"];
+    constructor(message: string, code: T["code"], data: T["data"]);
+}
+export declare const PARSE_ERROR: <T extends JSONParseError>(data: T["data"]) => SystemError<T>;
+export declare const INVALID_REQUEST: <T extends InvalidRequestError>(data: T["data"]) => SystemError<T>;
+export declare const METHOD_NOT_FOUND: <T extends MethodNotFoundError>(data: T["data"]) => SystemError<T>;
+export declare const INVALID_PARAMS: <T extends InvalidParamsError>(data: T["data"]) => SystemError<T>;
+export declare const INTERNAL_ERROR: <T extends InternalError>(data: T["data"]) => SystemError<T>;
+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>;
+export declare const FAILED_UPDATE: (taskId: string, contextId: string, messageId: string | undefined, errMessage: string) => TaskStatusUpdateEvent;

package/dist/browser/utils/common/errors.js

@@ -0,0 +1,42 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ErrorCodeInternalError, ErrorCodeInvalidRequest, ErrorCodeMethodNotFound, ErrorCodeParseError, ErrorCodeInvalidParams, ErrorCodeTaskNotFound, ErrorCodeTaskNotCancelable, ErrorCodeUnsupportedOperation, ErrorCodePushNotificationNotSupported, ErrorCodeContentTypeNotSupported, ErrorCodeInvalidAgentResponse, TaskState, ErrorCodeAuthenticatedExtendedCardNotConfigured, } from "../../types/index.js";
+export class SystemError extends Error {
+    constructor(message, code, data) {
+        super(message);
+        // this.name = "RpcError";
+        this.message = message;
+        this.code = code;
+        this.data = data;
+    }
+}
+// Factory methods for common errors
+export const PARSE_ERROR = (data) => new SystemError("Invalid JSON payload", ErrorCodeParseError, data);
+export const INVALID_REQUEST = (data) => new SystemError("Request payload validation error", ErrorCodeInvalidRequest, data);
+export const METHOD_NOT_FOUND = (data) => new SystemError("Method not found", ErrorCodeMethodNotFound, data);
+export const INVALID_PARAMS = (data) => new SystemError("Invalid parameters", ErrorCodeInvalidParams, data);
+export const INTERNAL_ERROR = (data) => new SystemError("Internal error", ErrorCodeInternalError, data);
+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);
+export const FAILED_UPDATE = (taskId, contextId, messageId = "failed-update", errMessage) => ({
+    taskId,
+    contextId,
+    kind: "status-update",
+    final: true,
+    status: {
+        state: TaskState.failed,
+        message: {
+            messageId,
+            role: "agent",
+            parts: [{ kind: "text", text: errMessage }],
+            kind: "message",
+        },
+    },
+});

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

@@ -0,0 +1,9 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Generates a timestamp in ISO 8601 format.
+ * @returns The current timestamp as a string.
+ */
+export declare function getCurrentTimestamp(): string;

package/dist/browser/utils/common/utils.js

@@ -0,0 +1,11 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Generates a timestamp in ISO 8601 format.
+ * @returns The current timestamp as a string.
+ */
+export function getCurrentTimestamp() {
+    return new Date().toISOString();
+}

package/dist/browser/utils/logging/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./log.js";
+export * from "./logger.js";

package/dist/browser/utils/logging/index.js

@@ -0,0 +1,2 @@
+export * from "./log.js";
+export * from "./logger.js";

package/dist/browser/utils/logging/log.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Logger utility for server operations
+ * @param context The context of the log (e.g., "A2AServer", "TaskStore")
+ * @param message The message to log
+ * @param data Optional data to include in the log
+ */
+export declare function logDebug(context: string, message: string, data?: unknown): void;
+/**
+ * Logger utility for server errors
+ * @param context The context of the log (e.g., "A2AServer", "TaskStore")
+ * @param message The message to log
+ * @param error The error object
+ * @param data Optional additional data
+ */
+export declare function logError(context: string, message: string, error: unknown, data?: unknown): void;
+/**
+ * Logger utility for server warnings
+ * @param context The context of the log (e.g., "A2AServer", "TaskStore")
+ * @param message The message to log
+ * @param data Optional data to include in the log
+ */
+export declare function logWarn(context: string, message: string, data?: unknown): void;
+/**
+ * Logger utility for server information
+ * @param context The context of the log (e.g., "A2AServer", "TaskStore")
+ * @param message The message to log
+ * @param data Optional data to include in the log
+ */
+export declare function logInfo(context: string, message: string, data?: unknown): void;

package/dist/browser/utils/logging/log.js

@@ -0,0 +1,75 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { logger, level } from "./logger.js";
+/**
+ * Logger utility for server operations
+ * @param context The context of the log (e.g., "A2AServer", "TaskStore")
+ * @param message The message to log
+ * @param data Optional data to include in the log
+ */
+export function logDebug(context, message, data) {
+    const logData = { component: context };
+    if (data !== undefined) {
+        logData.data = data;
+    }
+    if (level === "silent" || level === "warning" || level === "error" || level === "info") {
+        return;
+    }
+    logger.debug(logData, message);
+}
+/**
+ * Logger utility for server errors
+ * @param context The context of the log (e.g., "A2AServer", "TaskStore")
+ * @param message The message to log
+ * @param error The error object
+ * @param data Optional additional data
+ */
+export function logError(context, message, error, data) {
+    const logData = {
+        component: context,
+        err: error instanceof Error ? error : new Error(String(error)),
+    };
+    if (data !== undefined) {
+        logData.data = data;
+    }
+    if (level === "silent") {
+        return;
+    }
+    logger.error(logData, message);
+}
+/**
+ * Logger utility for server warnings
+ * @param context The context of the log (e.g., "A2AServer", "TaskStore")
+ * @param message The message to log
+ * @param data Optional data to include in the log
+ */
+export function logWarn(context, message, data) {
+    const logData = { component: context };
+    if (data !== undefined) {
+        logData.data = data;
+    }
+    if (level === "silent" || level === "error") {
+        return;
+    }
+    logger.warn(logData, message);
+}
+/**
+ * Logger utility for server information
+ * @param context The context of the log (e.g., "A2AServer", "TaskStore")
+ * @param message The message to log
+ * @param data Optional data to include in the log
+ */
+export function logInfo(context, message, data) {
+    const logData = { component: context };
+    if (data !== undefined) {
+        logData.data = data;
+    }
+    if (level === "error" ||
+        level === "warning" ||
+        level === "silent") {
+        return;
+    }
+    logger.info(logData, message);
+}

package/dist/browser/utils/logging/logger.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * A lightweight cross-platform logger instance
+ */
+export declare const logger: Console;
+export declare let level: "trace" | "verbose" | "debug" | "info" | "warning" | "error" | "silent";
+/**
+ * Configures the logger with the specified options
+ * @param options - Logger configuration options
+ */
+export declare function configureLogger(options: {
+    level?: "trace" | "verbose" | "debug" | "info" | "warning" | "error" | "silent";
+    name?: string;
+    prettyPrint?: boolean;
+}): Console;

package/dist/browser/utils/logging/logger.js

@@ -0,0 +1,18 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * A lightweight cross-platform logger instance
+ */
+export const logger = console;
+export let level = "silent";
+/**
+ * Configures the logger with the specified options
+ * @param options - Logger configuration options
+ */
+export function configureLogger(options) {
+    level = options.level || "silent";
+    return logger;
+}
+configureLogger({ level: "silent" });

package/dist/client/a2a-client.d.ts

@@ -14,6 +14,7 @@ export declare class A2AClient implements Client {
     private customHeaders;
     private fallbackPath;
     private agentUrl;
+    private mergePath;
     /**
      * Creates a new A2AClient instance.
      * @param baseUrl The base URL for the A2A server.
@@ -28,7 +29,7 @@ export declare class A2AClient implements Client {
      * const card = await client.agentCard();
      * console.log(card);
      */
-    constructor(baseUrl: URL | string, headers?: Record<string, string>, fallbackPath?: string);
+    constructor(baseUrl: URL | string, headers?: Record<string, string>, fallbackPath?: string, mergePath?: boolean);
     /**
      * Retrieves the AgentCard from the A2A server.
      * Caches the result after the first successful fetch.