@artinet/sdk 0.5.18 → 0.6.0-preview.2

package/dist/browser/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/browser/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/browser/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/browser/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);
 }

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

@@ -0,0 +1,382 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AgentCard, Message, Task, AgentExtension, TaskQueryParams, TaskIdParams, MessageSendParams, SendMessageSuccessResult } from "@artinet/types/a2a";
+import { core } from "../core/index.js";
+import { z } from "zod/v4";
+export type AgentCardParams = (Partial<AgentCard> & Required<Pick<AgentCard, "name">>) | string;
+export declare const UpdateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    role: z.ZodEnum<{
+        user: "user";
+        agent: "agent";
+    }>;
+    parts: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        kind: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        kind: z.ZodLiteral<"file">;
+        file: z.ZodUnion<readonly [z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            mimeType: z.ZodOptional<z.ZodString>;
+            bytes: z.ZodString;
+            uri: z.ZodOptional<z.ZodNever>;
+        }, z.core.$strip>, z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            mimeType: z.ZodOptional<z.ZodString>;
+            uri: z.ZodString;
+            bytes: z.ZodOptional<z.ZodNever>;
+        }, z.core.$strip>]>;
+    }, z.core.$strip>, z.ZodObject<{
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        kind: z.ZodLiteral<"data">;
+        data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>]>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    referenceTaskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    messageId: z.ZodString;
+    taskId: z.ZodOptional<z.ZodString>;
+    contextId: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"message">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    contextId: z.ZodString;
+    status: z.ZodObject<{
+        state: z.ZodEnum<{
+            failed: "failed";
+            unknown: "unknown";
+            completed: "completed";
+            canceled: "canceled";
+            rejected: "rejected";
+            working: "working";
+            submitted: "submitted";
+            "input-required": "input-required";
+            "auth-required": "auth-required";
+        }>;
+        message: z.ZodOptional<z.ZodObject<{
+            role: z.ZodEnum<{
+                user: "user";
+                agent: "agent";
+            }>;
+            parts: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                kind: z.ZodLiteral<"text">;
+                text: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                kind: z.ZodLiteral<"file">;
+                file: z.ZodUnion<readonly [z.ZodObject<{
+                    name: z.ZodOptional<z.ZodString>;
+                    mimeType: z.ZodOptional<z.ZodString>;
+                    bytes: z.ZodString;
+                    uri: z.ZodOptional<z.ZodNever>;
+                }, z.core.$strip>, z.ZodObject<{
+                    name: z.ZodOptional<z.ZodString>;
+                    mimeType: z.ZodOptional<z.ZodString>;
+                    uri: z.ZodString;
+                    bytes: z.ZodOptional<z.ZodNever>;
+                }, z.core.$strip>]>;
+            }, z.core.$strip>, z.ZodObject<{
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                kind: z.ZodLiteral<"data">;
+                data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>]>>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            referenceTaskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            messageId: z.ZodString;
+            taskId: z.ZodOptional<z.ZodString>;
+            contextId: z.ZodOptional<z.ZodString>;
+            kind: z.ZodLiteral<"message">;
+        }, z.core.$strip>>;
+        timestamp: z.ZodOptional<z.ZodISODateTime>;
+    }, z.core.$strip>;
+    history: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        role: z.ZodEnum<{
+            user: "user";
+            agent: "agent";
+        }>;
+        parts: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            kind: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            kind: z.ZodLiteral<"file">;
+            file: z.ZodUnion<readonly [z.ZodObject<{
+                name: z.ZodOptional<z.ZodString>;
+                mimeType: z.ZodOptional<z.ZodString>;
+                bytes: z.ZodString;
+                uri: z.ZodOptional<z.ZodNever>;
+            }, z.core.$strip>, z.ZodObject<{
+                name: z.ZodOptional<z.ZodString>;
+                mimeType: z.ZodOptional<z.ZodString>;
+                uri: z.ZodString;
+                bytes: z.ZodOptional<z.ZodNever>;
+            }, z.core.$strip>]>;
+        }, z.core.$strip>, z.ZodObject<{
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            kind: z.ZodLiteral<"data">;
+            data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>]>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        referenceTaskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        messageId: z.ZodString;
+        taskId: z.ZodOptional<z.ZodString>;
+        contextId: z.ZodOptional<z.ZodString>;
+        kind: z.ZodLiteral<"message">;
+    }, z.core.$strip>>>;
+    artifacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        artifactId: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        parts: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            kind: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            kind: z.ZodLiteral<"file">;
+            file: z.ZodUnion<readonly [z.ZodObject<{
+                name: z.ZodOptional<z.ZodString>;
+                mimeType: z.ZodOptional<z.ZodString>;
+                bytes: z.ZodString;
+                uri: z.ZodOptional<z.ZodNever>;
+            }, z.core.$strip>, z.ZodObject<{
+                name: z.ZodOptional<z.ZodString>;
+                mimeType: z.ZodOptional<z.ZodString>;
+                uri: z.ZodString;
+                bytes: z.ZodOptional<z.ZodNever>;
+            }, z.core.$strip>]>;
+        }, z.core.$strip>, z.ZodObject<{
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            kind: z.ZodLiteral<"data">;
+            data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>]>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        extension: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    kind: z.ZodLiteral<"task">;
+}, z.core.$strip>, z.ZodObject<{
+    taskId: z.ZodString;
+    contextId: z.ZodString;
+    kind: z.ZodLiteral<"status-update">;
+    status: z.ZodObject<{
+        state: z.ZodEnum<{
+            failed: "failed";
+            unknown: "unknown";
+            completed: "completed";
+            canceled: "canceled";
+            rejected: "rejected";
+            working: "working";
+            submitted: "submitted";
+            "input-required": "input-required";
+            "auth-required": "auth-required";
+        }>;
+        message: z.ZodOptional<z.ZodObject<{
+            role: z.ZodEnum<{
+                user: "user";
+                agent: "agent";
+            }>;
+            parts: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                kind: z.ZodLiteral<"text">;
+                text: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                kind: z.ZodLiteral<"file">;
+                file: z.ZodUnion<readonly [z.ZodObject<{
+                    name: z.ZodOptional<z.ZodString>;
+                    mimeType: z.ZodOptional<z.ZodString>;
+                    bytes: z.ZodString;
+                    uri: z.ZodOptional<z.ZodNever>;
+                }, z.core.$strip>, z.ZodObject<{
+                    name: z.ZodOptional<z.ZodString>;
+                    mimeType: z.ZodOptional<z.ZodString>;
+                    uri: z.ZodString;
+                    bytes: z.ZodOptional<z.ZodNever>;
+                }, z.core.$strip>]>;
+            }, z.core.$strip>, z.ZodObject<{
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                kind: z.ZodLiteral<"data">;
+                data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>]>>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            referenceTaskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            messageId: z.ZodString;
+            taskId: z.ZodOptional<z.ZodString>;
+            contextId: z.ZodOptional<z.ZodString>;
+            kind: z.ZodLiteral<"message">;
+        }, z.core.$strip>>;
+        timestamp: z.ZodOptional<z.ZodISODateTime>;
+    }, z.core.$strip>;
+    final: z.ZodBoolean;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>, z.ZodObject<{
+    taskId: z.ZodString;
+    contextId: z.ZodString;
+    kind: z.ZodLiteral<"artifact-update">;
+    artifact: z.ZodObject<{
+        artifactId: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        parts: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            kind: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            kind: z.ZodLiteral<"file">;
+            file: z.ZodUnion<readonly [z.ZodObject<{
+                name: z.ZodOptional<z.ZodString>;
+                mimeType: z.ZodOptional<z.ZodString>;
+                bytes: z.ZodString;
+                uri: z.ZodOptional<z.ZodNever>;
+            }, z.core.$strip>, z.ZodObject<{
+                name: z.ZodOptional<z.ZodString>;
+                mimeType: z.ZodOptional<z.ZodString>;
+                uri: z.ZodString;
+                bytes: z.ZodOptional<z.ZodNever>;
+            }, z.core.$strip>]>;
+        }, z.core.$strip>, z.ZodObject<{
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            kind: z.ZodLiteral<"data">;
+            data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>]>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        extension: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    append: z.ZodOptional<z.ZodBoolean>;
+    lastChunk: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>]>;
+export type Update = z.output<typeof UpdateSchema>;
+export type Engine = (context: Context) => AsyncGenerator<Update, void, unknown>;
+export interface BaseContext extends core.Context<Task> {
+    readonly service: Service;
+    /**
+     * Considering ommit OnStart & OnComplete from Context consumers.
+     * That way the user cannot inadvertently trigger a start/completion out of band.
+     */
+    readonly publisher: EventPublisher;
+}
+export interface Context extends BaseContext {
+    readonly taskId: string;
+    readonly userMessage: Message;
+    readonly messages: MessageConsumerProxy;
+    extensions?: AgentExtension[];
+    references?: Task[];
+    getTask: () => Promise<Task>;
+}
+export type ContextParams = Omit<BaseContext, "publisher" | "isCancelled" | "getState" | "abortSignal"> & Omit<Partial<Context>, "userMessage" | "taskId"> & {
+    messenger: MessageConsumerProxy;
+    task: Task;
+    overrides?: Partial<Omit<EventConsumer, "contextId">>;
+    abortSignal?: AbortSignal;
+};
+export interface Contexts extends core.Contexts<Context> {
+    create: (params: ContextParams) => Promise<Context>;
+    list: () => Promise<Context[]>;
+}
+export interface Tasks extends core.Manager<Task> {
+    update: (context: Context, update: Update) => Promise<Task>;
+    create: (params: Partial<Task>) => Promise<Task>;
+    has: (id: string) => Promise<boolean>;
+}
+export interface Cancellations extends Omit<core.Manager<void>, "get"> {
+    has: (id: string) => Promise<boolean>;
+}
+export interface Connections extends Omit<core.Manager<void>, "get"> {
+}
+export interface ServiceOptions {
+    abortSignal?: AbortSignal;
+}
+export interface RequestHandler {
+    getTask: (input: TaskQueryParams, context?: Context, options?: ServiceOptions) => Promise<Task>;
+    cancelTask: (input: TaskIdParams, context?: Context, options?: ServiceOptions) => Promise<Task>;
+    sendMessage: (message: MessageSendParams, context?: Context, options?: ServiceOptions) => Promise<SendMessageSuccessResult>;
+    streamMessage: (message: MessageSendParams, context?: Context, options?: ServiceOptions) => AsyncGenerator<Update>;
+    resubscribe: (input: TaskIdParams, context?: Context, options?: ServiceOptions) => AsyncGenerator<Update>;
+    getAgentCard: () => Promise<AgentCard>;
+}
+export interface ExtendedHandler extends RequestHandler {
+    getAuthenticatedExtendedCard: () => Promise<AgentCard>;
+}
+export interface Stream {
+    readonly contextId: string;
+    isAlive: boolean;
+    kill: () => Promise<void>;
+    updates: Update[];
+    context: Context;
+    run: (params: {
+        service: Service;
+    }) => AsyncGenerator<Update>;
+    subscribe: () => AsyncGenerator<Update>;
+}
+export interface Streams extends Omit<core.Manager<Stream>, "set"> {
+    create: (params: core.Optional<Stream> & {
+        context: Context;
+    }) => Promise<Stream>;
+    has: (id: string) => Promise<boolean>;
+}
+export interface Service extends core.Service<{
+    engine: Engine;
+    context: Context;
+}>, RequestHandler {
+    readonly events?: Events;
+    readonly connections: Connections;
+    readonly cancellations: Cancellations;
+    readonly tasks: Tasks;
+    readonly contexts: Contexts;
+    readonly streams: Streams;
+    engine: Engine;
+    agentCard: AgentCard;
+}
+export interface MessageProducer {
+    isOpen: boolean;
+    send: (message: MessageSendParams) => Promise<void>;
+}
+export type MessageMap = {
+    message: [MessageSendParams];
+    close: [];
+};
+export interface MessageConsumer extends core.Consumer<MessageSendParams, MessageMap> {
+    message: MessageSendParams;
+    messages: MessageSendParams[];
+    close: () => Promise<void>;
+    next: () => Promise<IteratorResult<MessageSendParams>>;
+    return: (value: MessageSendParams) => Promise<IteratorResult<MessageSendParams>>;
+}
+export type MessageConsumerProxy = MessageConsumer & MessageSendParams;
+export interface EventConsumer {
+    readonly contextId: string;
+    readonly onStart?: (context: Context) => Promise<Task>;
+    readonly onCancel: (update: Update, current: Task) => Promise<void>;
+    readonly onUpdate: (update: Update, current: Task) => Promise<Task>;
+    readonly onError: (error: any, current: Task) => Promise<void>;
+    onComplete: (current: Task) => Promise<void>;
+}
+export type Emissions = {
+    start: [MessageSendParams, Task];
+    cancel: [Update];
+    update: [Task, Update];
+    error: [any, Task];
+    complete: [Task];
+};
+export interface EventPublisher extends Omit<EventConsumer, "onComplete" | "onCancel" | "onError" | "onUpdate">, core.Publisher<Emissions> {
+    readonly onStart?: (context: Context) => Promise<Task>;
+    readonly onCancel: (update: Update) => Promise<void>;
+    readonly onUpdate: (update: Update) => Promise<Task>;
+    readonly onError: (error: any) => Promise<void>;
+    onComplete: () => Promise<void>;
+}
+export interface Events extends core.Manager<EventPublisher> {
+    create: (params: core.Optional<EventPublisher>) => Promise<EventPublisher>;
+}
+export * from "@artinet/types/a2a";

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

@@ -0,0 +1,14 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+//lets stay really granular with the imports
+import { TaskArtifactUpdateEventSchema, MessageSchema, TaskSchema, TaskStatusUpdateEventSchema, } from "@artinet/types/a2a";
+import { z } from "zod/v4";
+export const UpdateSchema = z.discriminatedUnion("kind", [
+    MessageSchema,
+    TaskSchema,
+    TaskStatusUpdateEventSchema,
+    TaskArtifactUpdateEventSchema,
+]);
+export * from "@artinet/types/a2a";

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

@@ -0,0 +1,5 @@
+export * as A2A from "./a2a.js";
+/**
+ * @deprecated Use {@link A2A.Engine} instead.
+ */
+export type { Engine as AgentEngine } from "./a2a.js";

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

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