@artinet/sdk 0.5.17 → 0.6.0-preview.1

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

@@ -0,0 +1,100 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Event stream utilities for handling Server-Sent Events (SSE).
+ */
+import { parseResponse } from "../rpc/parser.js";
+import { createParser, } from "eventsource-parser";
+import { sendJsonRpcRequest } from "../rpc/rpc-client.js";
+import { logger } from "../../config/index.js";
+/**
+ * Creates an async generator for processing task events from an SSE stream
+ *
+ * @template T The type of task event to process (TaskStatusUpdateEvent or TaskArtifactUpdateEvent)
+ * @param response The fetch Response object containing the event stream
+ * @returns An async generator yielding the specified type of task events from StreamingResponse
+ */
+export async function* handleEventStream(response) {
+    if (!response.ok || !response.body) {
+        let errorText = null;
+        try {
+            errorText = await response.text();
+        }
+        catch (_) { }
+        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();
+    const decoder = new TextDecoder();
+    const events = [];
+    const parser = createParser({
+        onEvent: (event) => {
+            if (event.data) {
+                if (event.event === "close") {
+                    logger.debug("handleEventStream", "Stream closed");
+                    return;
+                }
+                try {
+                    const parsedData = parseResponse(event.data);
+                    const eventResult = parsedData.result;
+                    if (eventResult) {
+                        events.push(eventResult);
+                    }
+                    else {
+                        logger.warn("handleEventStream", "Failed to parse SSE data", parsedData);
+                    }
+                    // if (parsedData.final && parsedData.final === true) {
+                    //   logDebug("handleEventStream", "Stream completed");
+                    //   return;
+                    // }
+                }
+                catch (e) {
+                    logger.warn("handleEventStream", "Failed to parse SSE data", e);
+                }
+            }
+        },
+        onError: (error) => {
+            logger.error("handleEventStream: Error parsing SSE data", error);
+        },
+        onRetry: (retry) => {
+            logger.warn("handleEventStream", "Retrying SSE connection", retry);
+        },
+    });
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            const chunk = decoder.decode(value, { stream: true });
+            parser.feed(chunk);
+            while (events.length > 0) {
+                yield events.shift();
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+/**
+ * Executes a streaming JSON-RPC request and yields events as they arrive
+ *
+ * @template Req The type of request being made
+ * @template StreamRes The type of streaming response expected
+ * @param baseUrl The base URL for the API
+ * @param method The JSON-RPC method to call
+ * @param params The parameters for the method
+ * @param customHeaders Any custom headers to include in the request
+ * @returns An AsyncIterable yielding events from the stream
+ */
+export async function* executeStreamEvents(baseUrl, method, params, customHeaders) {
+    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;
+    logger.debug("executeStreamEvents", "Response", response);
+    yield* handleEventStream(response);
+}

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

@@ -0,0 +1,378 @@
+/**
+ * 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.infer<typeof UpdateSchema>;
+export type Engine = (context: Context) => AsyncGenerator<Update, void, unknown>;
+export interface BaseContext extends core.Context<Task> {
+    readonly service: Service;
+    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"> & {
+    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/builder.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { MessageSendParams, DataPart, FilePart, TextPart } from "@artinet/types/a2a";
+import { Context } from "./a2a.js";
+/**
+ * Restricting to command for now, but could be extended to other types of commands in the future.
+ * When we shift to CoreCommand, move this into core.
+ */
+export interface StepArgs {
+    message: MessageSendParams;
+    context: Context;
+    skip: () => Promise<void> | void;
+}
+export type BaseArgs = Record<string, unknown>;
+export type EmptyArgs = Record<string, never>;
+export type StepParams<TInboundArgs extends BaseArgs = EmptyArgs> = StepArgs & Partial<{
+    content: string;
+    args: TInboundArgs;
+}>;
+export type PartContent = DataPart["data"] | FilePart["file"] | TextPart["text"];
+export type StepOutput<TPart extends PartContent> = {
+    parts: Array<TPart> | TPart;
+};
+export type StepOutputWithForwardArgs<TPart extends PartContent, TForwardArgs extends BaseArgs = EmptyArgs> = StepOutput<TPart> & {
+    args: TForwardArgs;
+};
+export type OutputType<TPart extends PartContent, TForwardArgs extends BaseArgs = EmptyArgs> = StepOutput<TPart> | StepOutputWithForwardArgs<TPart, TForwardArgs> | Array<TPart> | TPart;
+export type Step<TPart extends PartContent = TextPart["text"], TInboundArgs extends BaseArgs = EmptyArgs, TForwardArgs extends BaseArgs = EmptyArgs, TOutput extends OutputType<TPart, TForwardArgs> = OutputType<TPart, TForwardArgs>> = (params: StepParams<TInboundArgs>) => Promise<TOutput> | TOutput;
+export type StepWithKind<TPart extends PartContent = TextPart["text"], TInboundArgs extends BaseArgs = EmptyArgs, TForwardArgs extends BaseArgs = EmptyArgs, TOutput extends OutputType<TPart, TForwardArgs> = OutputType<TPart, TForwardArgs>, TKind extends "text" | "file" | "data" = "text"> = {
+    step: Step<TPart, TInboundArgs, TForwardArgs, TOutput>;
+    kind: TKind;
+};
+export type OutArgsOf<O> = O extends StepOutputWithForwardArgs<any, infer A> ? A : EmptyArgs;
+export interface StepBuilder<TInboundArgs extends BaseArgs = EmptyArgs> {
+    /**
+     * Add a step to the builder.
+     * @param step - The step to add.
+     * @returns A new builder with the step added.
+     */
+    addStep<TPart extends PartContent = TextPart["text"], TForwardArgs extends BaseArgs = EmptyArgs, TOutput extends OutputType<TPart, TForwardArgs> = OutputType<TPart, TForwardArgs>, TKind extends "text" | "file" | "data" = "text">(step: StepWithKind<TPart, TInboundArgs, TForwardArgs, TOutput, TKind>): StepBuilder<OutArgsOf<TOutput>>;
+}

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

@@ -0,0 +1,3 @@
+export * from "./builder.js";
+export * as A2A from "./a2a.js";
+export type { Engine as AgentEngine } from "./a2a.js";

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

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

package/dist/{types/interfaces → browser/types}/client.d.ts

@@ -2,9 +2,7 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import { TaskPushNotificationConfig, TaskIdParams, Task } from "../schemas/a2a/index.js";
-import type { AgentCard, TaskQueryParams, MessageSendParams, Message } from "../schemas/a2a/index.js";
-import { UpdateEvent } from "./services/a2a/index.js";
+import { A2A } from "./a2a/index.js";
 /**
  * @interface Client
  * @description Defines the standard contract for an A2A (Agent-to-Agent) client implementation.
@@ -19,24 +17,24 @@ export interface Client {
      * The AgentCard contains essential information about the agent, such as its capabilities and endpoints.
      * @param {string} wellKnownPath The standard path (e.g., "/.well-known/a2a") to look for the AgentCard.
      * @param {string} fallbackPath An alternative path to check if the well-known path fails.
-     * @returns {Promise<AgentCard>} A promise that resolves with the AgentCard object.
+     * @returns {Promise<A2A.AgentCard>} A promise that resolves with the AgentCard object.
      * @async
      */
-    agentCard(): Promise<AgentCard>;
+    agentCard(): Promise<A2A.AgentCard>;
     /**
      * @description Refreshes the cached AgentCard information by re-fetching it from the server.
      * Useful when the agent's capabilities or configuration might have changed.
-     * @returns {Promise<AgentCard>} A promise that resolves with the updated AgentCard object.
+     * @returns {Promise<A2A.AgentCard>} A promise that resolves with the updated AgentCard object.
      * @async
      */
-    refreshAgentCard(): Promise<AgentCard>;
+    refreshAgentCard(): Promise<A2A.AgentCard>;
     /**
      * @description Sends a task request to the agent server.
-     * @param {MessageSendParams} params Parameters required to send the task, including the task definition and metadata.
-     * @returns {Promise<Task | null>} A promise that resolves with the initial Task object representing the submitted task, or null if the submission failed.
+     * @param {A2A.MessageSendParams} params Parameters required to send the task, including the task definition and metadata.
+     * @returns {Promise<A2A.Task | null>} A promise that resolves with the initial Task object representing the submitted task, or null if the submission failed.
      * @async
      */
-    sendMessage(params: MessageSendParams): Promise<Message | Task | null>;
+    sendMessage(params: A2A.MessageSendParams): Promise<A2A.Message | A2A.Task | null>;
     /**
      * @deprecated Will be removed in v6.Use sendMessage instead.
      * @description Sends a task request to the agent server.
@@ -44,7 +42,7 @@ export interface Client {
      * @returns {Promise<Task | null>} A promise that resolves with the initial Task object representing the submitted task, or null if the submission failed.
      * @async
      */
-    sendTask(params: MessageSendParams): Promise<Message | Task | null>;
+    sendTask(params: A2A.MessageSendParams): Promise<A2A.Message | A2A.Task | null>;
     /**
      * @description Sends a task request and subscribes to real-time updates (status changes, artifact updates) for that task.
      * This uses a streaming connection if available.
@@ -52,7 +50,7 @@ export interface Client {
      * @returns {AsyncIterable<UpdateEvent>} An async iterable that yields task status and artifact updates.
      * @async
      */
-    sendStreamingMessage(params: MessageSendParams): AsyncIterable<UpdateEvent>;
+    sendStreamingMessage(params: A2A.MessageSendParams): AsyncIterable<A2A.Update>;
     /**
      * @deprecated Will be removed in v6Use sendStreamingMessage instead.
      * @description Sends a task request and subscribes to real-time updates (status changes, artifact updates) for that task.
@@ -61,45 +59,45 @@ export interface Client {
      * @returns {AsyncIterable<UpdateEvent>} An async iterable that yields task status and artifact updates.
      * @async
      */
-    sendTaskSubscribe(params: MessageSendParams): AsyncIterable<UpdateEvent>;
+    sendTaskSubscribe(params: A2A.MessageSendParams): AsyncIterable<A2A.Update>;
     /**
      * @description Retrieves the current state of a specific task by its ID.
-     * @param {TaskQueryParams} params Parameters containing the task ID to query.
-     * @returns {Promise<Task | null>} A promise that resolves with the Task object, or null if the task is not found.
+     * @param {A2A.TaskQueryParams} params Parameters containing the task ID to query.
+     * @returns {Promise<A2A.Task | null>} A promise that resolves with the Task object, or null if the task is not found.
      * @async
      */
-    getTask(params: TaskQueryParams): Promise<Task | null>;
+    getTask(params: A2A.TaskQueryParams): Promise<A2A.Task | null>;
     /**
      * @description Sends a request to cancel an ongoing task.
-     * @param {TaskIdParams} params Parameters containing the ID of the task to cancel.
-     * @returns {Promise<Task | null>} A promise that resolves with the final state of the cancelled Task object, or null if cancellation failed or the task wasn't found.
+     * @param {A2A.TaskIdParams} params Parameters containing the ID of the task to cancel.
+     * @returns {Promise<A2A.Task | null>} A promise that resolves with the final state of the cancelled Task object, or null if cancellation failed or the task wasn't found.
      * @async
      */
-    cancelTask(params: TaskIdParams): Promise<Task | null>;
+    cancelTask(params: A2A.TaskIdParams): Promise<A2A.Task | null>;
     /**
      * @description Configures push notifications for a specific task. This allows the client
      * to receive updates asynchronously via a specified webhook URL.
      * Requires the agent to support the 'pushNotifications' capability.
-     * @param {TaskPushNotificationConfig} params The configuration details for the push notification, including the task ID and webhook URL.
-     * @returns {Promise<TaskPushNotificationConfig | null>} A promise that resolves with the applied configuration, or null if the configuration failed.
+     * @param {A2A.TaskPushNotificationConfig} params The configuration details for the push notification, including the task ID and webhook URL.
+     * @returns {Promise<A2A.TaskPushNotificationConfig | null>} A promise that resolves with the applied configuration, or null if the configuration failed.
      * @async
      */
-    setTaskPushNotification(params: TaskPushNotificationConfig): Promise<TaskPushNotificationConfig | null>;
+    setTaskPushNotification(params: A2A.TaskPushNotificationConfig): Promise<A2A.TaskPushNotificationConfig | null>;
     /**
      * @description Retrieves the current push notification configuration for a specific task.
-     * @param {TaskIdParams} params Parameters containing the task ID.
-     * @returns {Promise<TaskPushNotificationConfig | null>} A promise that resolves with the push notification configuration, or null if not configured or not found.
+     * @param {A2A.TaskIdParams} params Parameters containing the task ID.
+     * @returns {Promise<A2A.TaskPushNotificationConfig | null>} A promise that resolves with the push notification configuration, or null if not configured or not found.
      * @async
      */
-    getTaskPushNotification(params: TaskIdParams): Promise<TaskPushNotificationConfig | null>;
+    getTaskPushNotification(params: A2A.TaskIdParams): Promise<A2A.TaskPushNotificationConfig | null>;
     /**
      * @description Resubscribes to updates for an existing task, potentially after a connection drop or client restart.
      * This allows resuming the stream of status and artifact updates.
-     * @param {TaskQueryParams} params Parameters containing the task ID to resubscribe to.
+     * @param {A2A.TaskQueryParams} params Parameters containing the task ID to resubscribe to.
      * @returns {AsyncIterable<UpdateEvent>} An async iterable that yields task status and artifact updates.
      * @async
      */
-    resubscribeTask(params: TaskQueryParams): AsyncIterable<UpdateEvent>;
+    resubscribeTask(params: A2A.TaskQueryParams): AsyncIterable<A2A.Update>;
     /**
      * @description Checks if the agent server supports a specific capability.
      * @param {"streaming" | "pushNotifications" | "stateTransitionHistory"} capability The capability to check for.