@artinet/sdk 0.5.18 → 0.6.0-preview.1

package/dist/browser/browser.d.ts

@@ -5,5 +5,5 @@ export { executeStreamEvents } from "./transport/streaming/event-stream.js";
 export * from "./utils/common/constants.js";
 export * from "./utils/common/errors.js";
 export * from "./utils/common/utils.js";
-export * from "./utils/logging/log.js";
+export * from "./config/index.js";
 export { A2AClient } from "./client/a2a-client.js";

package/dist/browser/browser.js

@@ -6,5 +6,5 @@ export { executeStreamEvents } from "./transport/streaming/event-stream.js";
 export * from "./utils/common/constants.js";
 export * from "./utils/common/errors.js";
 export * from "./utils/common/utils.js";
-export * from "./utils/logging/log.js";
+export * from "./config/index.js";
 export { A2AClient } from "./client/a2a-client.js";

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

@@ -2,8 +2,8 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import type { AgentCard, MessageSendParams, TaskQueryParams, TaskIdParams, TaskPushNotificationConfig, Task, Message, UpdateEvent } from "../types/index.js";
-import type { Client } from "../types/interfaces/client.js";
+import { A2A } from "../types/index.js";
+import type { Client } from "../types/client.js";
 /**
  * A2AClient is the main client class for interacting with Agent2Agent (A2A) protocol-compliant services.
  * It provides methods for sending tasks, retrieving statuses, canceling operations, and handling streaming responses.
@@ -35,68 +35,69 @@ export declare class A2AClient implements Client {
      * Caches the result after the first successful fetch.
      * @returns A promise resolving to the AgentCard.
      */
-    agentCard(): Promise<AgentCard>;
+    agentCard(): Promise<A2A.AgentCard>;
     /**
-     * Refreshes the cached AgentCard by fetching it again from the server.
-     * @returns A promise resolving to the updated AgentCard.
+     * Retrieves the AgentCard from the A2A server.
+     * @returns A promise resolving to the AgentCard.
      */
-    refreshAgentCard(): Promise<AgentCard>;
+    getAgentCard(): Promise<A2A.AgentCard>;
     /**
-     * Sends a Message to an agent server.
-     * @param params The parameters for the message/send method.
-     * @returns A promise resolving to Message/Task response from the agent server or null.
+     * Refreshes the cached AgentCard by fetching it again from the server.
+     * @returns A promise resolving to the updated AgentCard.
      */
-    sendMessage(params: MessageSendParams | string): Promise<Message | Task | null>;
+    refreshAgentCard(): Promise<A2A.AgentCard>;
+    sendMessage(params: A2A.MessageSendParams): Promise<A2A.Message | A2A.Task | null>;
+    sendMessage(params: string | A2A.MessageSendParams["message"]): Promise<A2A.Message | A2A.Task | null>;
     /**
      * @deprecated Use sendMessage instead.
      * Sends a task request to the agent (non-streaming).
      * @param params The parameters for the message/send method.
      * @returns A promise resolving to the Task object or null.
      */
-    sendTask(params: MessageSendParams): Promise<Message | Task | null>;
+    sendTask(params: A2A.MessageSendParams): Promise<A2A.Message | A2A.Task | null>;
     /**
      * Sends a Message and returns a stream of status and artifact updates.
      * @param params Task parameters for the request
      * @returns An AsyncIterable that yields TaskStatusUpdateEvent/TaskArtifactUpdateEvent/Task/Message payloads.
      */
-    sendStreamingMessage(params: MessageSendParams | string): AsyncIterable<UpdateEvent>;
+    sendStreamingMessage(params: A2A.MessageSendParams | string): AsyncIterable<A2A.Update>;
     /**
      * @deprecated Use sendStreamingMessage instead.
      * Sends a task and returns a subscription to status and artifact updates.
      * @param params Task parameters for the request
      * @returns An AsyncIterable that yields TaskStatusUpdateEvent or TaskArtifactUpdateEvent payloads.
      */
-    sendTaskSubscribe(params: MessageSendParams): AsyncIterable<UpdateEvent>;
+    sendTaskSubscribe(params: A2A.MessageSendParams): AsyncIterable<A2A.Update>;
     /**
      * Retrieves the current state of a task.
      * @param params The parameters for the tasks/get method.
      * @returns A promise resolving to the Task object or null.
      */
-    getTask(params: TaskQueryParams): Promise<Task | null>;
+    getTask(params: A2A.TaskQueryParams): Promise<A2A.Task | null>;
     /**
      * Cancels a currently running task.
      * @param params The parameters for the tasks/cancel method.
      * @returns A promise resolving to the updated Task object (usually canceled state) or null.
      */
-    cancelTask(params: TaskIdParams): Promise<Task | null>;
+    cancelTask(params: A2A.TaskIdParams): Promise<A2A.Task | null>;
     /**
      * Sets or updates the push notification config for a task.
      * @param params The parameters for the tasks/pushNotificationConfig/set method (which is TaskPushNotificationConfig).
      * @returns A promise resolving to the confirmed TaskPushNotificationConfig or null.
      */
-    setTaskPushNotification(params: TaskPushNotificationConfig): Promise<TaskPushNotificationConfig | null>;
+    setTaskPushNotification(params: A2A.TaskPushNotificationConfig): Promise<A2A.TaskPushNotificationConfig | null>;
     /**
      * Retrieves the currently configured push notification config for a task.
      * @param params The parameters for the tasks/pushNotificationConfig/get method.
      * @returns A promise resolving to the TaskPushNotificationConfig or null.
      */
-    getTaskPushNotification(params: TaskIdParams): Promise<TaskPushNotificationConfig | null>;
+    getTaskPushNotification(params: A2A.TaskIdParams): Promise<A2A.TaskPushNotificationConfig | null>;
     /**
      * Resubscribes to an existing task's update stream.
      * @param params Parameters identifying the task to resubscribe to
      * @returns An AsyncIterable that yields TaskStatusUpdateEvent or TaskArtifactUpdateEvent payloads.
      */
-    resubscribeTask(params: TaskQueryParams): AsyncIterable<UpdateEvent>;
+    resubscribeTask(params: A2A.TaskQueryParams): AsyncIterable<A2A.Update>;
     /**
      * Checks if the server supports a specific capability based on the agent card.
      * @param capability The capability to check (e.g., 'streaming', 'pushNotifications').

package/dist/browser/client/a2a-client.js

@@ -5,7 +5,7 @@
 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 { logger } from "../config/index.js";
 import { createMessageSendParams } from "../services/a2a/helpers/message-builder.js";
 /**
  * A2AClient is the main client class for interacting with Agent2Agent (A2A) protocol-compliant services.
@@ -61,6 +61,7 @@ export class A2AClient {
                 this.cachedAgentCard = card;
             }
             catch (error) {
+                logger.error("A2AClient:agentCard: Failed to fetch agent card (well-known):", error);
                 const fallbackUrl = new URL(this.fallbackPath, this.baseUrl);
                 if (this.mergePath) {
                     fallbackUrl.pathname = this.baseUrl.pathname + fallbackUrl.pathname;
@@ -69,18 +70,25 @@ export class A2AClient {
                 if (!fallbackCard.name ||
                     fallbackCard.name === null ||
                     fallbackCard.name === undefined) {
-                    throw new Error("No fallback agent card found");
+                    throw new Error("No fallback agent card found" + error);
                 }
                 this.cachedAgentCard = fallbackCard;
             }
         }
         catch (error) {
-            logError("A2AClient:agentCard", "Failed to fetch or parse agent card:", error);
-            throw INTERNAL_ERROR(`Could not retrieve agent card: ${error instanceof Error ? error.message : String(error)}`);
+            logger.error("A2AClient:agentCard: Failed to fetch or parse agent card:", error);
+            throw INTERNAL_ERROR(error);
         }
         this.agentUrl = new URL(this.cachedAgentCard.url, this.baseUrl);
         return this.cachedAgentCard;
     }
+    /**
+     * Retrieves the AgentCard from the A2A server.
+     * @returns A promise resolving to the AgentCard.
+     */
+    getAgentCard() {
+        return this.agentCard();
+    }
     /**
      * Refreshes the cached AgentCard by fetching it again from the server.
      * @returns A promise resolving to the updated AgentCard.
@@ -95,7 +103,11 @@ export class A2AClient {
      * @returns A promise resolving to Message/Task response from the agent server or null.
      */
     async sendMessage(params) {
-        return await executeJsonRpcRequest(this.agentUrl, "message/send", createMessageSendParams(params), this.customHeaders);
+        return await executeJsonRpcRequest(this.agentUrl, "message/send", typeof params === "string"
+            ? createMessageSendParams(params)
+            : typeof params === "object" && "message" in params
+                ? params
+                : createMessageSendParams({ message: params }), this.customHeaders);
     }
     /**
      * @deprecated Use sendMessage instead.
@@ -186,7 +198,7 @@ export class A2AClient {
             }
         }
         catch (error) {
-            logError("A2AClient:supports", `Failed to determine support for capability '${capability}':`, error);
+            logger.error(`A2AClient:supports: Failed to determine support for capability '${capability}':`, error);
             return false; // Assume not supported if card fetch fails
         }
     }

package/dist/browser/config/index.d.ts

@@ -0,0 +1,158 @@
+/**
+ * @fileoverview Global configuration for the Artinet runtime.
+ *
+ * Provides a centralized configuration interface that consumers use to
+ * inject their implementations of observability, storage, and other
+ * platform-specific dependencies.
+ *
+ * Design principles:
+ * - Single configuration point for the entire SDK
+ * - No-op defaults for all optional dependencies
+ * - Type-safe configuration interface
+ * - Configure once at application startup
+ *
+ * @module config
+ *
+ * @example
+ * ```typescript
+ * import { configure, getLogger, getTracer } from '@artinet/core';
+ * import pino from 'pino';
+ *
+ * // Configure at app startup
+ * configure({
+ *   logger: {
+ *     debug: (msg, ctx) => pino().debug(ctx, msg),
+ *     info: (msg, ctx) => pino().info(ctx, msg),
+ *     warn: (msg, ctx) => pino().warn(ctx, msg),
+ *     error: (msg, ctx) => pino().error(ctx, msg),
+ *   },
+ * });
+ *
+ * // Later in your code
+ * const logger = getLogger();
+ * logger.info('Application started');
+ * ```
+ */
+import { ILogger } from "./observability.js";
+import { Tracer } from "@opentelemetry/api";
+/**
+ * Artinet SDK configuration interface.
+ *
+ * All properties are optional - the SDK provides sensible no-op defaults.
+ * Configure only what you need.
+ */
+export interface ArtinetConfig {
+    /**
+     * Logger implementation for structured logging.
+     * @default noopLogger (no logging)
+     */
+    logger?: ILogger;
+    /**
+     * Tracer implementation for distributed tracing.
+     * @default trace.getTracer('artinet') (no tracing)
+     */
+    tracer?: Tracer;
+}
+/**
+ * Configure the Artinet SDK.
+ *
+ * Call this once at application startup to inject your implementations.
+ * Subsequent calls will merge with existing configuration.
+ *
+ * @param config - Configuration options
+ *
+ * @example
+ * ```typescript
+ * // Basic configuration with console
+ * configure({ logger: console });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Production configuration with Pino and OpenTelemetry
+ * import pino from 'pino';
+ * import { trace } from '@opentelemetry/api';
+ *
+ * const pinoLogger = pino();
+ *
+ * configure({
+ *   logger: {
+ *     debug: (msg, ...args) => pinoLogger.debug(Object.assign({}, ...args), msg),
+ *     info: (msg, ...args) => pinoLogger.info(Object.assign({}, ...args), msg),
+ *     warn: (msg, ...args) => pinoLogger.warn(Object.assign({}, ...args), msg),
+ *     error: (msg, ...args) => pinoLogger.error(Object.assign({}, ...args), msg),
+ *   },
+ *   tracer: {
+ *     startSpan: (name, attrs) => {
+ *       const span = trace.getTracer('my-app').startSpan(name);
+ *       // ... wrap span
+ *       return wrappedSpan;
+ *     },
+ *   },
+ * });
+ * ```
+ */
+export declare function configure(config: ArtinetConfig): void;
+/**
+ * Reset configuration to defaults.
+ *
+ * Primarily useful for testing to ensure clean state between tests.
+ *
+ * @example
+ * ```typescript
+ * beforeEach(() => {
+ *   resetConfig();
+ * });
+ * ```
+ */
+export declare function resetConfig(): void;
+/**
+ * Get the current configuration.
+ *
+ * Returns a copy to prevent external mutation.
+ *
+ * @returns Current configuration (readonly copy)
+ */
+export declare function getConfig(): Readonly<ArtinetConfig>;
+/**
+ * Get the configured logger or no-op default.
+ *
+ * @returns Logger implementation
+ *
+ * @example
+ * ```typescript
+ * const logger = getLogger();
+ * logger.info('Processing request', { requestId: '123' }, 'extra data');
+ * ```
+ */
+export declare function getLogger(): ILogger;
+/**
+ * Get the configured tracer or no-op default.
+ *
+ * @returns Tracer implementation
+ *
+ * @example
+ * ```typescript
+ * const tracer = getTracer();
+ * const span = tracer.startSpan('processRequest', { requestId: '123' });
+ * try {
+ *   // ... do work
+ *   span.setStatus('ok');
+ * } catch (error) {
+ *   span.setStatus('error', error.message);
+ *   throw error;
+ * } finally {
+ *   span.end();
+ * }
+ * ```
+ */
+export declare function getTracer(): Tracer;
+export declare const logger: {
+    debug: (msg: string, ...args: unknown[]) => void;
+    info: (msg: string, ...args: unknown[]) => void;
+    warn: (msg: string, ...args: unknown[]) => void;
+    error: (msg: string, err: unknown) => void;
+    setLevel: (level: "debug" | "info" | "warn" | "error") => void | undefined;
+    getLevel: () => "error" | "trace" | "verbose" | "debug" | "info" | "warn" | "silent";
+    child: (context: Record<string, unknown>) => ILogger;
+};

package/dist/browser/config/index.js

@@ -0,0 +1,155 @@
+/**
+ * @fileoverview Global configuration for the Artinet runtime.
+ *
+ * Provides a centralized configuration interface that consumers use to
+ * inject their implementations of observability, storage, and other
+ * platform-specific dependencies.
+ *
+ * Design principles:
+ * - Single configuration point for the entire SDK
+ * - No-op defaults for all optional dependencies
+ * - Type-safe configuration interface
+ * - Configure once at application startup
+ *
+ * @module config
+ *
+ * @example
+ * ```typescript
+ * import { configure, getLogger, getTracer } from '@artinet/core';
+ * import pino from 'pino';
+ *
+ * // Configure at app startup
+ * configure({
+ *   logger: {
+ *     debug: (msg, ctx) => pino().debug(ctx, msg),
+ *     info: (msg, ctx) => pino().info(ctx, msg),
+ *     warn: (msg, ctx) => pino().warn(ctx, msg),
+ *     error: (msg, ctx) => pino().error(ctx, msg),
+ *   },
+ * });
+ *
+ * // Later in your code
+ * const logger = getLogger();
+ * logger.info('Application started');
+ * ```
+ */
+import { noopLogger } from "./observability.js";
+import { trace } from "@opentelemetry/api";
+/**
+ * Internal configuration state.
+ * @internal
+ */
+let _config = {};
+/**
+ * Configure the Artinet SDK.
+ *
+ * Call this once at application startup to inject your implementations.
+ * Subsequent calls will merge with existing configuration.
+ *
+ * @param config - Configuration options
+ *
+ * @example
+ * ```typescript
+ * // Basic configuration with console
+ * configure({ logger: console });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Production configuration with Pino and OpenTelemetry
+ * import pino from 'pino';
+ * import { trace } from '@opentelemetry/api';
+ *
+ * const pinoLogger = pino();
+ *
+ * configure({
+ *   logger: {
+ *     debug: (msg, ...args) => pinoLogger.debug(Object.assign({}, ...args), msg),
+ *     info: (msg, ...args) => pinoLogger.info(Object.assign({}, ...args), msg),
+ *     warn: (msg, ...args) => pinoLogger.warn(Object.assign({}, ...args), msg),
+ *     error: (msg, ...args) => pinoLogger.error(Object.assign({}, ...args), msg),
+ *   },
+ *   tracer: {
+ *     startSpan: (name, attrs) => {
+ *       const span = trace.getTracer('my-app').startSpan(name);
+ *       // ... wrap span
+ *       return wrappedSpan;
+ *     },
+ *   },
+ * });
+ * ```
+ */
+export function configure(config) {
+    _config = { ..._config, ...config };
+}
+/**
+ * Reset configuration to defaults.
+ *
+ * Primarily useful for testing to ensure clean state between tests.
+ *
+ * @example
+ * ```typescript
+ * beforeEach(() => {
+ *   resetConfig();
+ * });
+ * ```
+ */
+export function resetConfig() {
+    _config = {};
+}
+/**
+ * Get the current configuration.
+ *
+ * Returns a copy to prevent external mutation.
+ *
+ * @returns Current configuration (readonly copy)
+ */
+export function getConfig() {
+    return { ..._config };
+}
+/**
+ * Get the configured logger or no-op default.
+ *
+ * @returns Logger implementation
+ *
+ * @example
+ * ```typescript
+ * const logger = getLogger();
+ * logger.info('Processing request', { requestId: '123' }, 'extra data');
+ * ```
+ */
+export function getLogger() {
+    return _config.logger ?? noopLogger;
+}
+/**
+ * Get the configured tracer or no-op default.
+ *
+ * @returns Tracer implementation
+ *
+ * @example
+ * ```typescript
+ * const tracer = getTracer();
+ * const span = tracer.startSpan('processRequest', { requestId: '123' });
+ * try {
+ *   // ... do work
+ *   span.setStatus('ok');
+ * } catch (error) {
+ *   span.setStatus('error', error.message);
+ *   throw error;
+ * } finally {
+ *   span.end();
+ * }
+ * ```
+ */
+export function getTracer() {
+    return _config.tracer ?? trace.getTracer("artinet");
+}
+export const logger = {
+    debug: (msg, ...args) => getLogger()?.debug?.(msg, ...args),
+    info: (msg, ...args) => getLogger()?.info?.(msg, ...args),
+    warn: (msg, ...args) => getLogger()?.warn?.(msg, ...args),
+    error: (msg, err) => getLogger()?.error?.(msg, err),
+    setLevel: (level) => getLogger()?.setLevel?.(level),
+    getLevel: () => getLogger()?.getLevel?.() ?? "info",
+    child: (context) => getLogger()?.child?.(context) ?? noopLogger,
+};

package/dist/browser/config/observability.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/** //todo move to @artinet/sdk from core v0.1
+ * @fileoverview Zero-dependency observability interfaces for the Artinet ecosystem.
+ *
+ * Provides minimal interfaces for logging and tracing that consumers can implement
+ * with their preferred tools (Pino, Winston, OpenTelemetry, etc.).
+ *
+ * Design principles:
+ * - Zero runtime dependencies
+ * - No-op defaults for zero overhead when not configured
+ * - Environment agnostic (Node, Deno, Bun, edge, browser)
+ * - Consumer brings their own implementation
+ *
+ * @module utils/observability
+ */
+/**
+ * Minimal logger interface.
+ *
+ * Consumers provide their own implementation using their preferred
+ * logging library (Pino, Winston, console, etc.).
+ *
+ * Uses spread args for maximum compatibility - works naturally with
+ * console.log, Pino, Winston, and most logging libraries.
+ *
+ * @example
+ * ```typescript
+ * // Console implementation (just works)
+ * const logger: ILogger = console;
+ *
+ * // Pino implementation
+ * import pino from 'pino';
+ * const pinoLogger = pino();
+ *
+ * const logger: ILogger = {
+ *   debug: (msg, ...args) => pinoLogger.debug(Object.assign({}, ...args), msg),
+ *   info: (msg, ...args) => pinoLogger.info(Object.assign({}, ...args), msg),
+ *   warn: (msg, ...args) => pinoLogger.warn(Object.assign({}, ...args), msg),
+ *   error: (msg, ...args) => pinoLogger.error(Object.assign({}, ...args), msg),
+ * };
+ *
+ * // Winston implementation
+ * import winston from 'winston';
+ * const winstonLogger = winston.createLogger({ ... });
+ *
+ * const logger: ILogger = {
+ *   debug: (msg, ...args) => winstonLogger.debug(msg, ...args),
+ *   info: (msg, ...args) => winstonLogger.info(msg, ...args),
+ *   warn: (msg, ...args) => winstonLogger.warn(msg, ...args),
+ *   error: (msg, ...args) => winstonLogger.error(msg, ...args),
+ * };
+ * ```
+ */
+export interface ILogger {
+    /**
+     * Log level.
+     * @default "info"
+     */
+    level?: "trace" | "verbose" | "debug" | "info" | "warn" | "error" | "silent";
+    /**
+     * Log debug-level message.
+     * @param msg - Log message
+     * @param args - Optional additional arguments (context, data, etc.)
+     */
+    debug(msg: string, ...args: unknown[]): void;
+    /**
+     * Log info-level message.
+     * @param msg - Log message
+     * @param args - Optional additional arguments (context, data, etc.)
+     */
+    info(msg: string, ...args: unknown[]): void;
+    /**
+     * Log warn-level message.
+     * @param msg - Log message
+     * @param args - Optional additional arguments (context, data, etc.)
+     */
+    warn(msg: string, ...args: unknown[]): void;
+    /**
+     * Log error-level message.
+     * @param msg - Log message
+     * @param err - Error to log
+     */
+    error(msg: string, err: unknown): void;
+    /**
+     * Set log level.
+     * @param level - Log level
+     */
+    setLevel?(level: "trace" | "verbose" | "debug" | "info" | "warn" | "error" | "silent"): void;
+    /**
+     * Get log level.
+     * @returns Current log level or undefined if not set
+     */
+    getLevel?(): "trace" | "verbose" | "debug" | "info" | "warn" | "error" | "silent";
+    /**
+     * Create child logger with bound context.
+     * @param context - Context to bind to the child logger
+     * @returns Child logger or undefined if not implemented
+     */
+    child?(context: Record<string, unknown>): ILogger;
+}
+/**
+ * Format error for logging.
+ * @param err - Error to format
+ * @returns Formatted error
+ */
+export declare function formatError(err: unknown): Record<string, unknown>;
+/**
+ * No-op logger implementation.
+ * Used when no logger is configured - zero overhead.
+ *
+ * @example
+ * ```typescript
+ * const logger = config.logger ?? noopLogger;
+ * logger.info('This does nothing if no logger configured');
+ * ```
+ */
+export declare const noopLogger: ILogger;

package/dist/browser/config/observability.js

@@ -0,0 +1,35 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Format error for logging.
+ * @param err - Error to format
+ * @returns Formatted error
+ */
+export function formatError(err) {
+    if (err instanceof Error) {
+        return {
+            message: err.message,
+            stack: err.stack,
+            name: err.name,
+        };
+    }
+    return { error: String(err) };
+}
+/**
+ * No-op logger implementation.
+ * Used when no logger is configured - zero overhead.
+ *
+ * @example
+ * ```typescript
+ * const logger = config.logger ?? noopLogger;
+ * logger.info('This does nothing if no logger configured');
+ * ```
+ */
+export const noopLogger = {
+    debug: () => { },
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+};

package/dist/browser/services/a2a/helpers/message-builder.d.ts

@@ -1,12 +1,17 @@
-import { MessageSendParams, Message as MessageType, MessageSendConfiguration } from "../../../types/index.js";
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2A } from "../../../types/index.js";
 export declare class MessageBuilder {
-    message: MessageType;
-    constructor(message?: Partial<MessageType>);
-    valueOf(): MessageType;
+    message: A2A.Message;
+    constructor(message?: Partial<A2A.Message>);
+    valueOf(): A2A.Message;
 }
+export declare const MESSAGE: (message?: Partial<A2A.Message>) => A2A.Message;
 export declare class MessageSendConfigurationBuilder {
-    configuration: MessageSendConfiguration;
-    constructor(configuration?: Partial<MessageSendConfiguration> | null);
-    valueOf(): MessageSendConfiguration;
+    configuration: A2A.MessageSendConfiguration;
+    constructor(configuration?: Partial<A2A.MessageSendConfiguration> | null);
+    valueOf(): A2A.MessageSendConfiguration;
 }
-export declare const createMessageSendParams: (messageSendParams: Partial<MessageSendParams> | string) => MessageSendParams;
+export declare const createMessageSendParams: (messageSendParams: Partial<A2A.MessageSendParams> | string) => A2A.MessageSendParams;