@artinet/sdk 0.5.18 → 0.6.0-preview.1

package/dist/services/mcp/service.js

@@ -3,22 +3,23 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { MessageSendParamsSchema, TaskIdParamsSchema, TaskSchema, AgentCardSchema, } from "../../types/index.js";
+import { A2A } from "../../types/index.js";
+import { formatJson } from "../../utils/common/utils.js";
 export class BaseMCPService extends McpServer {
     agent;
     _registerBaseTools(uri = "agent://card") {
         this.registerTool("send-message", {
             title: "Send Message",
-            description: MessageSendParamsSchema.description,
-            inputSchema: MessageSendParamsSchema.shape,
-            outputSchema: TaskSchema.shape, //defaulting to task because unions are not supported
+            description: A2A.MessageSendParamsSchema.description,
+            inputSchema: A2A.MessageSendParamsSchema.shape,
+            outputSchema: A2A.TaskSchema.shape, //defaulting to task because unions are not supported
         }, async (args) => {
             const task = await this.agent.sendMessage(args);
             return {
                 content: [
                     {
                         type: "text",
-                        text: JSON.stringify(task, null, 2),
+                        text: formatJson(task),
                     },
                 ],
                 structuredContent: task,
@@ -26,16 +27,16 @@ export class BaseMCPService extends McpServer {
         });
         this.registerTool("get-task", {
             title: "Get Task",
-            description: TaskIdParamsSchema.description,
-            inputSchema: TaskIdParamsSchema.shape,
-            outputSchema: TaskSchema.shape,
+            description: A2A.TaskIdParamsSchema.description,
+            inputSchema: A2A.TaskIdParamsSchema.shape,
+            outputSchema: A2A.TaskSchema.shape,
         }, async (args) => {
             const task = await this.agent.getTask(args);
             return {
                 content: [
                     {
                         type: "text",
-                        text: JSON.stringify(task, null, 2),
+                        text: formatJson(task),
                     },
                 ],
                 structuredContent: task,
@@ -43,16 +44,16 @@ export class BaseMCPService extends McpServer {
         });
         this.registerTool("cancel-task", {
             title: "Cancel Task",
-            description: TaskIdParamsSchema.description,
-            inputSchema: TaskIdParamsSchema.shape,
-            outputSchema: TaskSchema.shape,
+            description: A2A.TaskIdParamsSchema.description,
+            inputSchema: A2A.TaskIdParamsSchema.shape,
+            outputSchema: A2A.TaskSchema.shape,
         }, async (args) => {
             const task = await this.agent.cancelTask(args);
             return {
                 content: [
                     {
                         type: "text",
-                        text: JSON.stringify(task, null, 2),
+                        text: formatJson(task),
                     },
                 ],
                 structuredContent: task,
@@ -60,14 +61,14 @@ export class BaseMCPService extends McpServer {
         });
         this.registerResource("agent-card", uri, {
             title: "Agent Card",
-            description: AgentCardSchema.description,
+            description: A2A.AgentCardSchema.description,
             mimeType: "application/json",
         }, async (uri) => {
             return {
                 contents: [
                     {
                         uri: uri.href,
-                        text: JSON.stringify(this.agent.agentCard, null, 2),
+                        text: formatJson(await this.agent.getAgentCard()),
                         mimeType: "application/json",
                     },
                 ],

package/dist/transport/index.d.ts

@@ -1,4 +1,3 @@
 export * from "./rpc/rpc-client.js";
 export * from "./streaming/event-stream.js";
 export * from "./rpc/parser.js";
-export * from "./trpc/index.js";

package/dist/transport/index.js

@@ -1,4 +1,4 @@
 export * from "./rpc/rpc-client.js";
 export * from "./streaming/event-stream.js";
 export * from "./rpc/parser.js";
-export * from "./trpc/index.js";
+// export * from "./trpc/index.js";

package/dist/transport/rpc/parser.d.ts

@@ -2,7 +2,7 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import { JSONRPCResponse } from "../../types/index.js";
+import { MCP } from "../../types/index.js";
 /**
  * Parses a JSON-RPC response string and validates its structure.
  * If the response contains an error, it is thrown as an A2AError.
@@ -12,4 +12,4 @@ import { JSONRPCResponse } from "../../types/index.js";
  * @returns The parsed and validated response object
  * @throws A2AError if the response contains an error or is invalid
  */
-export declare function parseResponse<Res extends JSONRPCResponse>(data: string): Res;
+export declare function parseResponse<Res extends MCP.JSONRPCResponse | MCP.JSONRPCError>(data: string): Res;

package/dist/transport/rpc/parser.js

@@ -2,9 +2,9 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import { JSONRPCErrorSchema, } from "../../types/index.js";
+import { MCP } from "../../types/index.js";
 import { SystemError, PARSE_ERROR } from "../../utils/common/errors.js";
-import { logError } from "../../utils/logging/log.js";
+import { logger } from "../../config/index.js";
 /**
  * Parses a JSON-RPC response string and validates its structure.
  * If the response contains an error, it is thrown as an A2AError.
@@ -21,11 +21,11 @@ export function parseResponse(data) {
     try {
         const parsed = JSON.parse(data); //todo: leverage safe parse
         if (parsed.error) {
-            const parsedError = JSONRPCErrorSchema.safeParse(parsed.error);
+            const parsedError = MCP.JSONRPCErrorSchema.safeParse(parsed);
             if (!parsedError.success) {
                 throw PARSE_ERROR(parsedError.error);
             }
-            throw new SystemError(parsedError.data.message, parsedError.data.code, parsedError.data.data);
+            throw new SystemError(parsedError.data.error.message, parsedError.data.error.code, parsedError.data.error.data);
         }
         if (typeof parsed !== "object" ||
             parsed === null ||
@@ -39,10 +39,10 @@ export function parseResponse(data) {
     }
     catch (error) {
         if (error instanceof SystemError) {
-            logError("parseResponse", "SystemError:", error.message);
+            logger.error("parseResponse: SystemError:", error);
             throw error;
         }
-        logError("parseResponse", "Error parsing response:", data);
+        logger.error("parseResponse: Error parsing response:", error);
         throw PARSE_ERROR(error);
     }
 }

package/dist/transport/rpc/rpc-client.d.ts

@@ -2,7 +2,7 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import type { JSONRPCRequest, JSONRPCResponse, A2ARequest } from "../../types/index.js";
+import type { A2A, MCP } from "../../types/index.js";
 /**
  * Creates a JSON-RPC request body with the specified method and parameters.
  *, ErrorCodeParseError
@@ -11,7 +11,7 @@ import type { JSONRPCRequest, JSONRPCResponse, A2ARequest } from "../../types/in
  * @param requestId Optional request ID (generates a UUID v4 if not provided)
  * @returns A properly formatted JSON-RPC request object
  */
-export declare function createJsonRpcRequest<Req extends A2ARequest>(method: Req["method"], params: Req["params"], requestId?: string | number): JSONRPCRequest;
+export declare function createJsonRpcRequest<Req extends A2A.A2ARequest>(method: Req["method"], params: Req["params"], requestId?: string | number): MCP.JSONRPCRequest;
 /**
  * Sends a JSON-RPC request to the specified endpoint.
  *
@@ -23,7 +23,7 @@ export declare function createJsonRpcRequest<Req extends A2ARequest>(method: Req
  * @returns A Promise resolving to the fetch Response object
  * @throws RpcError if there's a network error
  */
-export declare function sendJsonRpcRequest<Req extends A2ARequest>(baseUrl: URL, method: Req["method"], params: Req["params"], headers?: Record<string, string>, acceptHeader?: "application/json" | "text/event-stream"): Promise<Response>;
+export declare function sendJsonRpcRequest<Req extends A2A.A2ARequest>(baseUrl: URL, method: Req["method"], params: Req["params"], headers?: Record<string, string>, acceptHeader?: "application/json" | "text/event-stream"): Promise<Response>;
 /**
  * Sends a GET request to the specified endpoint.
  * This is used for non-JSON-RPC calls like agent card retrieval.
@@ -43,7 +43,7 @@ export declare function sendGetRequest(url: URL, headers?: Record<string, string
  * @returns A promise resolving to the result payload
  * @throws RpcError if there's an error in the response
  */
-export declare function handleJsonRpcResponse<Res extends JSONRPCResponse>(response: Response, expectedMethod?: string): Promise<NonNullable<Res["result"]>>;
+export declare function handleJsonRpcResponse<Res extends MCP.JSONRPCResultResponse>(response: Response, expectedMethod?: string): Promise<NonNullable<Res["result"]>>;
 /**
  * Processes a JSON response from a regular GET request.
  * Handles error checking and returns the parsed JSON.
@@ -66,7 +66,7 @@ export declare function handleJsonResponse<T>(response: Response, endpoint?: str
  * @returns A Promise resolving to the result payload
  * @throws RpcError if there's a network error or error in the response
  */
-export declare function executeJsonRpcRequest<Req extends A2ARequest, Res extends JSONRPCResponse>(baseUrl: URL, method: Req["method"], params: Req["params"], headers?: Record<string, string>, acceptHeader?: "application/json" | "text/event-stream"): Promise<NonNullable<Res["result"]>>;
+export declare function executeJsonRpcRequest<Req extends A2A.A2ARequest, Res extends MCP.JSONRPCResultResponse>(baseUrl: URL, method: Req["method"], params: Req["params"], headers?: Record<string, string>, acceptHeader?: "application/json" | "text/event-stream"): Promise<NonNullable<Res["result"]>>;
 /**
  * Sends a GET request and processes the JSON response.
  * Helper for non-RPC REST endpoints.

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

@@ -9,7 +9,7 @@
 import { v4 as uuidv4 } from "uuid";
 import { SystemError, INTERNAL_ERROR, PARSE_ERROR, } from "../../utils/common/errors.js";
 import { parseResponse } from "./parser.js";
-import { logError, logWarn } from "../../utils/logging/log.js";
+import { logger } from "../../config/index.js";
 /**
  * Creates a JSON-RPC request body with the specified method and parameters.
  *, ErrorCodeParseError
@@ -55,7 +55,7 @@ export async function sendJsonRpcRequest(baseUrl, method, params, headers = {},
         });
     }
     catch (networkError) {
-        logError("SendJsonRpcRequest", "Network error during RPC call:", networkError);
+        logger.error("SendJsonRpcRequest: Network error during RPC call:", networkError);
         // Wrap network errors into a standard error format
         throw INTERNAL_ERROR(networkError);
     }
@@ -80,7 +80,7 @@ export async function sendGetRequest(url, headers = {}) {
         });
     }
     catch (networkError) {
-        logError("SendGetRequest", "Network error during GET request:", networkError);
+        logger.error("SendGetRequest: Network error during GET request:", networkError);
         throw INTERNAL_ERROR(networkError);
     }
 }
@@ -105,7 +105,7 @@ export async function handleJsonRpcResponse(response, expectedMethod) {
                 // But the HTTP status was not OK, so we throw a generic error
             }
             catch (parseError) {
-                logWarn("handleJsonRpcResponse", "Error parsing JSON-RPC response:", parseError);
+                logger.warn("handleJsonRpcResponse", "Error parsing JSON-RPC response:", parseError);
             }
             // Throw a generic HTTP error if we couldn't extract an RPC error
             throw new Error(`HTTP error ${response.status}: ${response.statusText}${responseBody ? ` - ${responseBody}` : ""}`);
@@ -119,7 +119,7 @@ export async function handleJsonRpcResponse(response, expectedMethod) {
         return jsonResponse.result;
     }
     catch (error) {
-        logError("handleJsonRpcResponse", `Error processing response [${expectedMethod}]:`, error);
+        logger.error(`handleJsonRpcResponse: Error processing response [${expectedMethod}]:`, error);
         // Re-throw RpcError instances directly, wrap others
         if (error instanceof SystemError) {
             throw error;
@@ -148,7 +148,7 @@ export async function handleJsonResponse(response, endpoint) {
         return JSON.parse(responseBody);
     }
     catch (error) {
-        logError("handleJsonResponse", `Error processing response for ${endpoint || "unknown endpoint"}:`, error);
+        logger.error(`handleJsonResponse: Error processing response for ${endpoint || "unknown endpoint"}:`, error);
         if (error instanceof SystemError) {
             throw error;
         }

package/dist/transport/streaming/event-stream.d.ts

@@ -2,7 +2,7 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import type { JSONRPCResponse, A2ARequest } from "../../types/index.js";
+import { A2A, MCP } from "../../types/index.js";
 /**
  * Creates an async generator for processing task events from an SSE stream
  *
@@ -10,7 +10,7 @@ import type { JSONRPCResponse, A2ARequest } from "../../types/index.js";
  * @param response The fetch Response object containing the event stream
  * @returns An async generator yielding the specified type of task events from StreamingResponse
  */
-export declare function handleEventStream<StreamRes extends JSONRPCResponse>(response: Response): AsyncGenerator<NonNullable<StreamRes["result"]>>;
+export declare function handleEventStream<StreamRes extends MCP.JSONRPCResultResponse>(response: Response): AsyncGenerator<NonNullable<StreamRes["result"]>>;
 /**
  * Executes a streaming JSON-RPC request and yields events as they arrive
  *
@@ -22,4 +22,4 @@ export declare function handleEventStream<StreamRes extends JSONRPCResponse>(res
  * @param customHeaders Any custom headers to include in the request
  * @returns An AsyncIterable yielding events from the stream
  */
-export declare function executeStreamEvents<Req extends A2ARequest, StreamRes extends JSONRPCResponse>(baseUrl: URL, method: Req["method"], params: Req["params"], customHeaders: Record<string, string>): AsyncIterable<NonNullable<StreamRes["result"]>>;
+export declare function executeStreamEvents<Req extends A2A.A2ARequest, StreamRes extends MCP.JSONRPCResultResponse>(baseUrl: URL, method: Req["method"], params: Req["params"], customHeaders: Record<string, string>): AsyncIterable<NonNullable<StreamRes["result"]>>;

package/dist/transport/streaming/event-stream.js

@@ -8,7 +8,7 @@
 import { parseResponse } from "../rpc/parser.js";
 import { createParser, } from "eventsource-parser";
 import { sendJsonRpcRequest } from "../rpc/rpc-client.js";
-import { logError, logWarn, logDebug } from "../../utils/logging/index.js";
+import { logger } from "../../config/index.js";
 /**
  * Creates an async generator for processing task events from an SSE stream
  *
@@ -23,8 +23,9 @@ export async function* handleEventStream(response) {
             errorText = await response.text();
         }
         catch (_) { }
-        logError("handleEventStream", `HTTP error [${response.status}:${response.statusText}] - ${errorText}`, new Error(`HTTP error [${response.status}:${response.statusText}] - ${errorText}`));
-        throw new Error(`HTTP error [${response.status}:${response.statusText}] - ${errorText}`);
+        const err = new Error(`HTTP error [${response.status}:${response.statusText}] - ${errorText}`);
+        logger.error(`handleEventStream: HTTP error [${response.status}:${response.statusText}] - ${errorText}`, err);
+        throw err;
     }
     // Use eventsource-parser to process the SSE stream
     const reader = response.body.getReader();
@@ -34,7 +35,7 @@ export async function* handleEventStream(response) {
         onEvent: (event) => {
             if (event.data) {
                 if (event.event === "close") {
-                    logDebug("handleEventStream", "Stream closed");
+                    logger.debug("handleEventStream", "Stream closed");
                     return;
                 }
                 try {
@@ -44,7 +45,7 @@ export async function* handleEventStream(response) {
                         events.push(eventResult);
                     }
                     else {
-                        logWarn("handleEventStream", "Failed to parse SSE data", parsedData);
+                        logger.warn("handleEventStream", "Failed to parse SSE data", parsedData);
                     }
                     // if (parsedData.final && parsedData.final === true) {
                     //   logDebug("handleEventStream", "Stream completed");
@@ -52,15 +53,15 @@ export async function* handleEventStream(response) {
                     // }
                 }
                 catch (e) {
-                    logWarn("handleEventStream", "Failed to parse SSE data", e);
+                    logger.warn("handleEventStream", "Failed to parse SSE data", e);
                 }
             }
         },
         onError: (error) => {
-            logError("handleEventStream", "Error parsing SSE data", error);
+            logger.error("handleEventStream: Error parsing SSE data", error);
         },
         onRetry: (retry) => {
-            logWarn("handleEventStream", "Retrying SSE connection", retry);
+            logger.warn("handleEventStream", "Retrying SSE connection", retry);
         },
     });
     try {
@@ -91,9 +92,9 @@ export async function* handleEventStream(response) {
  * @returns An AsyncIterable yielding events from the stream
  */
 export async function* executeStreamEvents(baseUrl, method, params, customHeaders) {
-    logDebug("executeStreamEvents", `Sending streaming request to: ${baseUrl.toString()}, method: ${method}`);
+    logger.debug("executeStreamEvents", `Sending streaming request to: ${baseUrl.toString()}, method: ${method}`);
     const responsePromise = sendJsonRpcRequest(baseUrl, method, params, customHeaders, "text/event-stream");
     const response = await responsePromise;
-    logDebug("executeStreamEvents", "Response", response);
+    logger.debug("executeStreamEvents", "Response", response);
     yield* handleEventStream(response);
 }