@artinet/sdk 0.6.0-preview.1 → 0.6.0-preview.2

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

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

package/dist/browser/services/a2a/helpers/message-builder.js

@@ -1,66 +0,0 @@
-/**
- * Copyright 2025 The Artinet Project
- * SPDX-License-Identifier: Apache-2.0
- */
-import { v4 as uuidv4 } from "uuid";
-export class MessageBuilder {
-    constructor(message = {}) {
-        this.message = {
-            role: "user",
-            parts: [],
-            metadata: undefined,
-            extensions: undefined,
-            referenceTaskIds: undefined,
-            messageId: uuidv4(),
-            taskId: undefined,
-            contextId: undefined,
-            kind: "message",
-        };
-        this.message.role = message.role ?? this.message.role;
-        this.message.parts = message.parts ?? this.message.parts;
-        this.message.metadata = message.metadata ?? this.message.metadata;
-        this.message.extensions = message.extensions ?? this.message.extensions;
-        this.message.referenceTaskIds =
-            message.referenceTaskIds ?? this.message.referenceTaskIds;
-        this.message.messageId = message.messageId ?? this.message.messageId;
-        this.message.taskId = message.taskId ?? this.message.taskId;
-        this.message.contextId = message.contextId ?? this.message.contextId;
-    }
-    valueOf() {
-        return this.message;
-    }
-}
-export const MESSAGE = (message = {}) => new MessageBuilder(message).message;
-export class MessageSendConfigurationBuilder {
-    constructor(configuration = {}) {
-        this.configuration = {
-            acceptedOutputModes: undefined,
-            historyLength: undefined,
-            pushNotificationConfig: undefined,
-            blocking: undefined,
-        };
-        this.configuration.acceptedOutputModes =
-            configuration?.acceptedOutputModes ??
-                this.configuration.acceptedOutputModes;
-        this.configuration.historyLength =
-            configuration?.historyLength ?? this.configuration.historyLength;
-        this.configuration.pushNotificationConfig =
-            configuration?.pushNotificationConfig ??
-                this.configuration.pushNotificationConfig;
-        this.configuration.blocking =
-            configuration?.blocking ?? this.configuration.blocking;
-    }
-    valueOf() {
-        return this.configuration;
-    }
-}
-export const createMessageSendParams = (messageSendParams) => {
-    const isString = typeof messageSendParams === "string";
-    return {
-        message: new MessageBuilder(isString
-            ? { parts: [{ text: messageSendParams, kind: "text" }] }
-            : messageSendParams.message).valueOf(),
-        configuration: new MessageSendConfigurationBuilder(isString ? undefined : messageSendParams.configuration).valueOf(),
-        metadata: isString ? undefined : messageSendParams.metadata,
-    };
-};

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

@@ -1,43 +0,0 @@
-/**
- * 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/builder.js

@@ -1,5 +0,0 @@
-/**
- * Copyright 2025 The Artinet Project
- * SPDX-License-Identifier: Apache-2.0
- */
-export {};

package/dist/services/a2a/factory/builder.d.ts

@@ -1,292 +0,0 @@
-/**
- * Copyright 2025 The Artinet Project
- * SPDX-License-Identifier: Apache-2.0
- */
-/**
- * @fileoverview A2A Agent Builder and Execution Engine Factory
- *
- * This module provides a fluent builder API for constructing A2A agents and
- * execution engines. It enables declarative definition of multi-step agent
- * workflows with type-safe step composition and automatic execution orchestration.
- *
- * @module A2ABuilder
- * @version 0.6.0-preview
- * @since 0.5.6
- * @author The Artinet Project
- */
-import { StepBuilder, Step, A2A, StepWithKind, OutputType, BaseArgs, EmptyArgs, OutArgsOf, PartContent } from "../../../types/index.js";
-import { ServiceParams } from "./service.js";
-/**
- * Type alias for text-based workflow steps.
- *
- * This type represents a step that processes or generates text content
- * within an agent workflow. Text steps are the most common type of step
- * and are used for message processing, content generation, and text-based
- * decision making.
- *
- * @template TCommand - The command type, defaults to MessageSendParams
- * @template TPart - The text part type, defaults to A2A.TextPart["text"]
- * @template TInboundArgs - Arguments received from previous step
- * @template TForwardArgs - Arguments passed to next step
- * @template TOutput - The output type of the step
- *
- * @example
- * ```typescript
- * const greetingStep: textStep = async ({ command, context, content, args }) => {
- *   const userName = command.message.metadata?.userName || 'there';
- *   return `Hello, ${userName}! How can I help you today?`;
- * };
- * ```
- *
- * @public
- * @since 0.5.6
- */
-export type textStep<TInboundArgs extends BaseArgs = EmptyArgs, TForwardArgs extends BaseArgs = EmptyArgs, TOutput extends OutputType<A2A.TextPart["text"], TForwardArgs> = OutputType<A2A.TextPart["text"], TForwardArgs>> = Step<A2A.TextPart["text"], TInboundArgs, TForwardArgs, TOutput>;
-/**
- * Type alias for file-based workflow steps.
- *
- * This type represents a step that processes or generates file content
- * within an agent workflow. File steps handle document processing,
- * file generation, and file-based data operations.
- *
- * @template TCommand - The command type, defaults to MessageSendParams
- * @template TPart - The file part type, defaults to A2A.FilePart["file"]
- * @template TInboundArgs - Arguments received from previous step
- * @template TForwardArgs - Arguments passed to next step
- * @template TOutput - The output type of the step
- *
- * @example
- * ```typescript
- * const documentStep: fileStep = async ({ command, context, args }) => {
- *   const content = generateDocument(command.message.content);
- *   return {
- *     name: 'report.pdf',
- *     mimeType: 'application/pdf',
- *     bytes: content
- *   };
- * };
- * ```
- *
- * @public
- * @since 0.5.6
- */
-export type fileStep<TInboundArgs extends BaseArgs = EmptyArgs, TForwardArgs extends BaseArgs = EmptyArgs, TOutput extends OutputType<A2A.FilePart["file"], TForwardArgs> = OutputType<A2A.FilePart["file"], TForwardArgs>> = Step<A2A.FilePart["file"], TInboundArgs, TForwardArgs, TOutput>;
-/**
- * Type alias for data-based workflow steps.
- *
- * This type represents a step that processes or generates structured data
- * within an agent workflow. Data steps handle JSON processing, API responses,
- * and structured data transformations.
- *
- * @template TCommand - The command type, defaults to MessageSendParams
- * @template TPart - The data part type, defaults to A2A.DataPart["data"]
- * @template TInboundArgs - Arguments received from previous step
- * @template TForwardArgs - Arguments passed to next step
- * @template TOutput - The output type of the step
- *
- * @example
- * ```typescript
- * const analyzeStep: dataStep = async ({ command, context, args }) => {
- *   const analysis = await analyzeMessage(command.message.content);
- *   return {
- *     sentiment: analysis.sentiment,
- *     entities: analysis.entities,
- *     confidence: analysis.confidence
- *   };
- * };
- * ```
- *
- * @public
- * @since 0.5.6
- */
-export type dataStep<TInboundArgs extends BaseArgs = EmptyArgs, TForwardArgs extends BaseArgs = EmptyArgs, TOutput extends OutputType<A2A.DataPart["data"], TForwardArgs> = OutputType<A2A.DataPart["data"], TForwardArgs>> = Step<A2A.DataPart["data"], TInboundArgs, TForwardArgs, TOutput>;
-/**
- * Fluent builder for constructing A2A agent execution engines.
- *
- * The EngineBuilder provides a type-safe, fluent API for composing multi-step
- * agent workflows. It supports method chaining to build complex agent behaviors
- * from individual processing steps, with automatic type inference and validation.
- *
- * @template TCommand - The command type, defaults to MessageSendParams
- * @template TInboundArgs - The arguments type received from previous steps
- *
- * @example
- * ```typescript
- * const agent = EngineBuilder.create()
- *   .text(async ({ command }) => {
- *     return `Processing: ${command.message.content}`;
- *   })
- *   .data(async ({ args }) => {
- *     return { processed: true, timestamp: Date.now() };
- *   })
- *   .text(async ({ args }) => {
- *     return `Completed at ${new Date(args[0].timestamp)}`;
- *   })
- *   .createAgent({ agentCard: myAgentCard });
- * ```
- *
- * @public
- * @since 0.5.6
- */
-export declare class EngineBuilder<TInboundArgs extends BaseArgs = EmptyArgs> implements StepBuilder<TInboundArgs> {
-    private steps;
-    /**
-     * Protected constructor to enforce factory method usage.
-     *
-     * @param steps - Initial steps array
-     */
-    protected constructor(steps?: Array<StepWithKind<any, any, any, any, any>>);
-    /**
-     * Creates a new EngineBuilder instance.
-     *
-     * @template TCommand - The command type for the builder
-     * @template TInboundArgs - The initial arguments type
-     * @returns A new EngineBuilder instance
-     *
-     * @example
-     * ```typescript
-     * const builder = EngineBuilder.create<MyCommand, [string, number]>();
-     * ```
-     */
-    static create<TInboundArgs extends BaseArgs = EmptyArgs>(): EngineBuilder<TInboundArgs>;
-    addStep<TPart extends PartContent = A2A.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>): EngineBuilder<OutArgsOf<TOutput>>;
-    /**
-     * Adds a text processing step to the workflow.
-     *
-     * @template TPart - The text part type
-     * @template TForwardArgs - Arguments to forward to next step
-     * @template TOutput - The output type of the step
-     * @param step - The text step implementation
-     * @returns New builder instance with updated type parameters
-     *
-     * @example
-     * ```typescript
-     * builder.text(async ({ command, args }) => {
-     *   return `Hello, ${command.message.content}!`;
-     * });
-     * ```
-     */
-    text<TForwardArgs extends BaseArgs = EmptyArgs, TOutput extends OutputType<A2A.TextPart["text"], TForwardArgs> = OutputType<A2A.TextPart["text"], TForwardArgs>>(step: textStep<TInboundArgs, TForwardArgs, TOutput> | string): EngineBuilder<OutArgsOf<TOutput>>;
-    /**
-     * Adds a file processing step to the workflow.
-     *
-     * @template TPart - The file part type
-     * @template TForwardArgs - Arguments to forward to next step
-     * @template TOutput - The output type of the step
-     * @param step - The file step implementation
-     * @returns New builder instance with updated type parameters
-     *
-     * @example
-     * ```typescript
-     * builder.file(async ({ command, args }) => {
-     *   return {
-     *     name: 'output.txt',
-     *     mimeType: 'text/plain',
-     *     bytes: Buffer.from(command.message.content)
-     *   };
-     * });
-     * ```
-     */
-    file<TForwardArgs extends BaseArgs = EmptyArgs, TOutput extends OutputType<A2A.FilePart["file"], TForwardArgs> = OutputType<A2A.FilePart["file"], TForwardArgs>>(step: fileStep<TInboundArgs, TForwardArgs, TOutput>): EngineBuilder<OutArgsOf<TOutput>>;
-    /**
-     * Adds a data processing step to the workflow.
-     *
-     * @template TPart - The data part type
-     * @template TForwardArgs - Arguments to forward to next step
-     * @template TOutput - The output type of the step
-     * @param step - The data step implementation
-     * @returns New builder instance with updated type parameters
-     *
-     * @example
-     * ```typescript
-     * builder.data(async ({ command, args }) => {
-     *   return {
-     *     analysis: analyzeText(command.message.content),
-     *     timestamp: Date.now()
-     *   };
-     * });
-     * ```
-     */
-    data<TForwardArgs extends BaseArgs = EmptyArgs, TOutput extends OutputType<A2A.DataPart["data"], TForwardArgs> = OutputType<A2A.DataPart["data"], TForwardArgs>>(step: dataStep<TInboundArgs, TForwardArgs, TOutput>): EngineBuilder<OutArgsOf<TOutput>>;
-    /**
-     * Creates a complete A2A agent using the built workflow.
-     *
-     * @param params - Agent factory parameters (excluding engine)
-     * @returns Configured A2A agent instance
-     *
-     * @example
-     * ```typescript
-     * const agent = builder.createAgent({
-     *   agentCard: {
-     *     id: 'my-agent',
-     *     name: 'Assistant Agent',
-     *     capabilities: ['text-processing']
-     *   }
-     * });
-     * ```
-     */
-    createAgent(params: Omit<ServiceParams, "engine">): import("../service.js").Service;
-    /**
-     * Creates an agent execution engine from the built workflow.
-     *
-     * @returns Agent execution engine function
-     *
-     * @example
-     * ```typescript
-     * const engine = builder.createAgentEngine();
-     * // Use engine with service execution
-     * ```
-     */
-    createAgentEngine(): A2A.Engine;
-    /**
-     * Builds the step list for the workflow.
-     *
-     * @returns Array of workflow steps
-     * @throws Error if no steps have been added
-     *
-     * @example
-     * ```typescript
-     * const steps = builder.build();
-     * ```
-     */
-    build(): StepWithKind<any, any, any, any, any>[];
-}
-/**
- * Convenience factory function for creating an agent builder with default parameters.
- *
- * @returns New EngineBuilder instance with MessageSendParams command type
- *
- * @example
- * ```typescript
- * const agent = AgentBuilder()
- *   .text(async ({ command }) => `Hello ${command.message.content}!`)
- *   .createAgent({ agentCard: myCard });
- * ```
- *
- * @public
- * @since 0.5.6
- */
-export declare const AgentBuilder: () => EngineBuilder<EmptyArgs>;
-/**
- * Creates an agent execution engine from a list of workflow steps.
- *
- * This function transforms a list of step definitions into an executable
- * agent engine that processes commands through the defined workflow,
- * yielding updates as each step completes.
- *
- * @param stepsList - Array of workflow steps to execute
- * @returns Agent execution engine function
- *
- * @example
- * ```typescript
- * const steps = [
- *   { kind: 'text', step: greetingStep },
- *   { kind: 'data', step: analysisStep }
- * ];
- * const engine = createAgentExecutor(steps);
- * ```
- *
- * @public
- * @since 0.5.6
- */
-export declare function createAgentExecutor(stepsList: StepWithKind[]): A2A.Engine;