@artinet/sdk 0.5.17 → 0.6.0-preview.1

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

@@ -0,0 +1,127 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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.
+ */
+export declare class A2AClient implements Client {
+    private baseUrl;
+    private cachedAgentCard;
+    private customHeaders;
+    private fallbackPath;
+    private agentUrl;
+    private mergePath;
+    /**
+     * Creates a new A2AClient instance.
+     * @param baseUrl The base URL for the A2A server.
+     * @param headers Optional custom headers to include in all requests.
+     * @param fallbackPath Optional fallback path to use if the agent card is not found at the base URL.
+     * @example
+     * const client = new A2AClient("http://localhost:4000/a2a");
+     * const card = await client.agentCard();
+     * console.log(card);
+     * @example
+     * const client = new A2AClient("http://localhost:4000/a2a", {}, "/agent-card");
+     * const card = await client.agentCard();
+     * console.log(card);
+     */
+    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.
+     * @returns A promise resolving to the AgentCard.
+     */
+    agentCard(): Promise<A2A.AgentCard>;
+    /**
+     * Retrieves the AgentCard from the A2A server.
+     * @returns A promise resolving to the AgentCard.
+     */
+    getAgentCard(): Promise<A2A.AgentCard>;
+    /**
+     * Refreshes the cached AgentCard by fetching it again from the server.
+     * @returns A promise resolving to the updated AgentCard.
+     */
+    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: 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: 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: 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: 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: 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: 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: 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: 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').
+     * @returns A promise resolving to true if the capability is supported.
+     */
+    supports(capability: "streaming" | "pushNotifications" | "stateTransitionHistory"): Promise<boolean>;
+    /**
+     * Sets custom headers to be included in all requests.
+     * @param headers A record of header name/value pairs.
+     */
+    setHeaders(headers: Record<string, string>): void;
+    /**
+     * Adds a single custom header to be included in all requests.
+     * @param name The header name.
+     * @param value The header value.
+     */
+    addHeader(name: string, value: string): void;
+    /**
+     * Removes a custom header.
+     * @param name The header name to remove.
+     */
+    removeHeader(name: string): void;
+    /**
+     * Clears all custom headers.
+     */
+    clearHeaders(): void;
+}

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

@@ -0,0 +1,233 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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 { 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.
+ * It provides methods for sending tasks, retrieving statuses, canceling operations, and handling streaming responses.
+ */
+export class A2AClient {
+    /**
+     * Creates a new A2AClient instance.
+     * @param baseUrl The base URL for the A2A server.
+     * @param headers Optional custom headers to include in all requests.
+     * @param fallbackPath Optional fallback path to use if the agent card is not found at the base URL.
+     * @example
+     * const client = new A2AClient("http://localhost:4000/a2a");
+     * const card = await client.agentCard();
+     * console.log(card);
+     * @example
+     * const client = new A2AClient("http://localhost:4000/a2a", {}, "/agent-card");
+     * const card = await client.agentCard();
+     * console.log(card);
+     */
+    constructor(baseUrl, headers = {}, fallbackPath, mergePath = false) {
+        this.cachedAgentCard = null;
+        this.customHeaders = {};
+        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.
+     * Caches the result after the first successful fetch.
+     * @returns A promise resolving to the AgentCard.
+     */
+    async agentCard() {
+        if (this.cachedAgentCard) {
+            return this.cachedAgentCard;
+        }
+        // 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)) {
+                    throw new Error("Invalid well-known URL");
+                }
+                const card = await executeGetRequest(wellKnownUrl, this.customHeaders, "agent card (well-known)");
+                if (!card.name || card.name === null || card.name === undefined) {
+                    throw new Error("No agent card found");
+                }
+                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;
+                }
+                const fallbackCard = await executeGetRequest(fallbackUrl, this.customHeaders, "agent card (fallback)");
+                if (!fallbackCard.name ||
+                    fallbackCard.name === null ||
+                    fallbackCard.name === undefined) {
+                    throw new Error("No fallback agent card found" + error);
+                }
+                this.cachedAgentCard = fallbackCard;
+            }
+        }
+        catch (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.
+     */
+    async refreshAgentCard() {
+        this.cachedAgentCard = null;
+        return this.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.
+     */
+    async sendMessage(params) {
+        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.
+     * 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.
+     */
+    async sendTask(params) {
+        return await this.sendMessage(params);
+    }
+    /**
+     * 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) {
+        return executeStreamEvents(this.agentUrl, "message/stream", createMessageSendParams(params), this.customHeaders);
+    }
+    /**
+     * @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) {
+        return this.sendStreamingMessage(params);
+    }
+    /**
+     * 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.
+     */
+    async getTask(params) {
+        return await executeJsonRpcRequest(this.agentUrl, "tasks/get", params, this.customHeaders);
+    }
+    /**
+     * 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.
+     */
+    async cancelTask(params) {
+        return await executeJsonRpcRequest(this.agentUrl, "tasks/cancel", params, this.customHeaders);
+    }
+    /**
+     * 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.
+     */
+    async setTaskPushNotification(params) {
+        return await executeJsonRpcRequest(this.agentUrl, "tasks/pushNotificationConfig/set", params, this.customHeaders);
+    }
+    /**
+     * 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.
+     */
+    async getTaskPushNotification(params) {
+        return await executeJsonRpcRequest(this.agentUrl, "tasks/pushNotificationConfig/get", params, this.customHeaders);
+    }
+    /**
+     * 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) {
+        return executeStreamEvents(this.agentUrl, "tasks/resubscribe", params, this.customHeaders);
+    }
+    /**
+     * Checks if the server supports a specific capability based on the agent card.
+     * @param capability The capability to check (e.g., 'streaming', 'pushNotifications').
+     * @returns A promise resolving to true if the capability is supported.
+     */
+    async supports(capability) {
+        try {
+            const card = await this.agentCard();
+            if (!card.capabilities) {
+                return false;
+            }
+            switch (capability) {
+                case "streaming":
+                    return !!card.capabilities.streaming;
+                case "pushNotifications":
+                    return !!card.capabilities.pushNotifications;
+                case "stateTransitionHistory":
+                    return !!card.capabilities.stateTransitionHistory;
+                default:
+                    return false;
+            }
+        }
+        catch (error) {
+            logger.error(`A2AClient:supports: Failed to determine support for capability '${capability}':`, error);
+            return false; // Assume not supported if card fetch fails
+        }
+    }
+    /**
+     * Sets custom headers to be included in all requests.
+     * @param headers A record of header name/value pairs.
+     */
+    setHeaders(headers) {
+        this.customHeaders = { ...headers };
+    }
+    /**
+     * Adds a single custom header to be included in all requests.
+     * @param name The header name.
+     * @param value The header value.
+     */
+    addHeader(name, value) {
+        this.customHeaders[name] = value;
+    }
+    /**
+     * Removes a custom header.
+     * @param name The header name to remove.
+     */
+    removeHeader(name) {
+        delete this.customHeaders[name];
+    }
+    /**
+     * Clears all custom headers.
+     */
+    clearHeaders() {
+        this.customHeaders = {};
+    }
+}

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

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

package/dist/browser/client/index.js

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

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,
+};