@artinet/sdk 0.5.18 → 0.6.0-preview.2

package/dist/create/message-builder.js

@@ -0,0 +1,110 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2A } from "../types/index.js";
+import { v4 as uuidv4 } from "uuid";
+export class Message {
+    _message;
+    constructor(params = {}) {
+        const messageId = params.messageId ?? uuidv4();
+        // TODO: Consider whether default role should be "user" when used in messageSendParams context.
+        // Currently defaults to "agent" which may be incorrect for MessageSendParams.
+        this._message = {
+            ...params,
+            role: params.role ?? "agent",
+            parts: params.parts ?? [],
+            messageId,
+            kind: A2A.Kind.message,
+        };
+    }
+    get message() {
+        return this._message;
+    }
+    static create(params = {}) {
+        return new Message(typeof params === "string"
+            ? { parts: [{ text: params, kind: "text" }] }
+            : params).message;
+    }
+}
+export const isMessageParams = (params) => {
+    return (typeof params === "string" ||
+        (typeof params === "object" && params !== null && "parts" in params));
+};
+/**
+ * Convenience factory function for creating a message builder with default parameters.
+ *
+ * @returns New {@link A2A.Message} with default parameters
+ * @defaults {
+ *   role: "agent",
+ *   parts: [],
+ *   messageId: uuidv4(),
+ *   kind: "message",
+ * }
+ * @example
+ * ```typescript
+ * const message = message();
+ * ```
+ *
+ * @public
+ * @since 0.6.0
+ */
+export const message = Message.create;
+/**
+ * @deprecated Use {@link message} instead.
+ * @since 0.6.0
+ */
+export const MessageBuilder = Message;
+export class MessageSendConfiguration {
+    _configuration;
+    constructor(params = {}) {
+        this._configuration = !params
+            ? {}
+            : {
+                ...params,
+            };
+    }
+    get configuration() {
+        return this._configuration;
+    }
+}
+/**
+ * @deprecated Use {@link messageSendParams} instead.
+ * @since 0.6.0
+ */
+export const MessageSendConfigurationBuilder = MessageSendConfiguration;
+/**
+ * Convenience factory function for creating a message send params with default parameters.
+ *
+ * @returns New {@link A2A.MessageSendParams} with default parameters
+ * @defaults {
+ *   message: {
+ *     role: "agent",
+ *     parts: [],
+ *     messageId: uuidv4(),
+ *     kind: "message",
+ *   },
+ *   configuration: undefined,
+ *   metadata: undefined,
+ * }
+ * @example
+ * ```typescript
+ * const params = messageSendParams("hello there");
+ * ```
+ *
+ * @public
+ * @since 0.6.0
+ */
+export function messageSendParams(params) {
+    const _isMessageParams = isMessageParams(params);
+    return {
+        message: message(_isMessageParams ? params : params.message),
+        configuration: new MessageSendConfiguration(_isMessageParams ? undefined : params.configuration).configuration,
+        metadata: _isMessageParams ? undefined : params.metadata,
+    };
+}
+/**
+ * @deprecated Use {@link messageSendParams} instead.
+ * @since 0.6.0
+ */
+export const createMessageSendParams = messageSendParams;

package/dist/create/part-builder.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2A } from "../types/index.js";
+export declare class TextPart {
+    private readonly _part;
+    constructor(params: string);
+    get part(): A2A.TextPart;
+    static create(params: string): A2A.TextPart;
+}
+export type FileParams = (Partial<A2A.File> & {
+    bytes: string;
+}) | (Partial<A2A.File> & {
+    uri: string;
+});
+export type FilePartParams = string | FileParams;
+export declare class FilePart {
+    private readonly _part;
+    constructor(params: FileParams);
+    get part(): A2A.FilePart;
+    static create(params: FilePartParams): A2A.FilePart;
+}
+export declare const filePart: typeof FilePart.create;
+export declare class DataPart {
+    private readonly _part;
+    constructor(params: Record<string, unknown>);
+    get part(): A2A.DataPart;
+    static create(params: Record<string, unknown>): A2A.DataPart;
+}
+/**
+ * Namespace for {@link A2A.Part} creation utilities.
+ *
+ * @example
+ * ```typescript
+ * const t = part.text("Hello");
+ * const f = part.file("https://example.com/file.pdf");
+ * const d = part.data({ key: "value" });
+ * ```
+ *
+ * @public
+ * @since 0.6.0
+ */
+export declare const part: {
+    /**
+     * Create a text part.
+     * @see {@link A2A.TextPart}
+     */
+    text: typeof TextPart.create;
+    /**
+     * Create a file part.
+     * @see {@link A2A.FilePart}
+     */
+    file: typeof FilePart.create;
+    /**
+     * Create a data part.
+     * @see {@link A2A.DataPart}
+     */
+    data: typeof DataPart.create;
+};

package/dist/create/part-builder.js

@@ -0,0 +1,84 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2A } from "../types/index.js";
+export class TextPart {
+    _part;
+    constructor(params) {
+        this._part = {
+            text: params,
+            kind: A2A.Kind.text,
+        };
+    }
+    get part() {
+        return this._part;
+    }
+    static create(params) {
+        return new TextPart(params).part;
+    }
+}
+export class FilePart {
+    _part;
+    constructor(params) {
+        this._part = {
+            kind: A2A.Kind.file,
+            file: params,
+        };
+    }
+    get part() {
+        return this._part;
+    }
+    static create(params) {
+        if (typeof params === "string") {
+            return new FilePart({ uri: params }).part;
+        }
+        return new FilePart(params).part;
+    }
+}
+export const filePart = FilePart.create;
+export class DataPart {
+    _part;
+    constructor(params) {
+        this._part = {
+            data: params,
+            kind: A2A.Kind.data,
+        };
+    }
+    get part() {
+        return this._part;
+    }
+    static create(params) {
+        return new DataPart(params).part;
+    }
+}
+/**
+ * Namespace for {@link A2A.Part} creation utilities.
+ *
+ * @example
+ * ```typescript
+ * const t = part.text("Hello");
+ * const f = part.file("https://example.com/file.pdf");
+ * const d = part.data({ key: "value" });
+ * ```
+ *
+ * @public
+ * @since 0.6.0
+ */
+export const part = {
+    /**
+     * Create a text part.
+     * @see {@link A2A.TextPart}
+     */
+    text: TextPart.create,
+    /**
+     * Create a file part.
+     * @see {@link A2A.FilePart}
+     */
+    file: FilePart.create,
+    /**
+     * Create a data part.
+     * @see {@link A2A.DataPart}
+     */
+    data: DataPart.create,
+};

package/dist/create/status-builder.d.ts

@@ -0,0 +1,26 @@
+import { A2A } from "../types/index.js";
+/**
+ * @deprecated Use {@link update.status} instead
+ * @since 0.6.0
+ */
+export declare const STATUS_UPDATE: (taskId: string, contextId: string, status: A2A.TaskState, message?: A2A.Message, timestamp?: string, final?: boolean) => A2A.TaskStatusUpdateEvent;
+/**
+ * @deprecated Use {@link update.working} instead
+ * @since 0.6.0
+ */
+export declare const WORKING_UPDATE: (taskId: string, contextId: string, message?: A2A.Message, timestamp?: string) => A2A.TaskStatusUpdateEvent;
+/**
+ * @deprecated Use {@link update.canceled} instead
+ * @since 0.6.0
+ */
+export declare const CANCEL_UPDATE: (taskId: string, contextId: string, message?: A2A.Message, timestamp?: string) => A2A.TaskStatusUpdateEvent;
+/**
+ * @deprecated Use {@link update.submitted} instead
+ * @since 0.6.0
+ */
+export declare const SUBMITTED_UPDATE: (taskId: string, contextId: string, message?: A2A.Message, timestamp?: string) => A2A.TaskStatusUpdateEvent;
+/**
+ * @deprecated Use {@link update.failed} instead
+ * @since 0.6.0
+ */
+export declare const FAILED_UPDATE_EVENT: (taskId: string, contextId: string, message?: A2A.Message, timestamp?: string) => A2A.TaskStatusUpdateEvent;

package/dist/create/status-builder.js

@@ -0,0 +1,46 @@
+import { update_compat, update } from "./task-builder.js";
+/**
+ * @deprecated Use {@link update.status} instead
+ * @since 0.6.0
+ */
+export const STATUS_UPDATE = (taskId, contextId, status, message, timestamp, final) => update_compat(taskId, contextId, status, message, timestamp, final);
+/**
+ * @deprecated Use {@link update.working} instead
+ * @since 0.6.0
+ */
+export const WORKING_UPDATE = (taskId, contextId, message, timestamp) => update.working({
+    taskId,
+    contextId,
+    message,
+    timestamp,
+});
+/**
+ * @deprecated Use {@link update.canceled} instead
+ * @since 0.6.0
+ */
+export const CANCEL_UPDATE = (taskId, contextId, message, timestamp) => update.canceled({
+    taskId,
+    contextId,
+    message,
+    timestamp,
+});
+/**
+ * @deprecated Use {@link update.submitted} instead
+ * @since 0.6.0
+ */
+export const SUBMITTED_UPDATE = (taskId, contextId, message, timestamp) => update.submitted({
+    taskId,
+    contextId,
+    message,
+    timestamp,
+});
+/**
+ * @deprecated Use {@link update.failed} instead
+ * @since 0.6.0
+ */
+export const FAILED_UPDATE_EVENT = (taskId, contextId, message, timestamp) => update.failed({
+    taskId,
+    contextId,
+    message,
+    timestamp,
+});

package/dist/create/task-builder.d.ts

@@ -0,0 +1,251 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2A } from "../types/index.js";
+import { type MessageParams } from "./message-builder.js";
+import { Kindless } from "./base.js";
+export type BaseArtifactParams = Partial<Kindless<A2A.Artifact>>;
+export type ArtifactParams = BaseArtifactParams | string;
+export declare const isArtifactParams: (params: any) => params is ArtifactParams;
+export declare class Artifact {
+    private readonly _artifact;
+    constructor(artifact_params?: Partial<A2A.Artifact>);
+    get artifact(): A2A.Artifact;
+    static create(params?: ArtifactParams): A2A.Artifact;
+}
+export declare const artifact: typeof Artifact.create;
+export type StatusParams = Partial<Kindless<A2A.TaskStatus>> | A2A.TaskState | MessageParams;
+export declare const isStatusParams: (params: any) => params is StatusParams;
+export declare class TaskStatus {
+    private readonly _status;
+    constructor(params?: Partial<A2A.TaskStatus>);
+    get status(): A2A.TaskStatus;
+    static create(params?: StatusParams): A2A.TaskStatus;
+}
+/**
+ * Convenience factory function for creating a task status with default parameters.
+ *
+ * @returns New {@link A2A.TaskStatus} with default parameters
+ * @defaults {
+ *   state: "working",
+ *   timestamp: getCurrentTimestamp(),
+ * }
+ *
+ * @example
+ * ```typescript
+ * const status = status("working");
+ * ```
+ *
+ * @public
+ * @since 0.6.0
+ */
+export declare const status: typeof TaskStatus.create;
+export type TaskParams = Partial<Kindless<A2A.Task>> | StatusParams;
+export declare class Task {
+    private readonly _task;
+    constructor(params?: Partial<Kindless<A2A.Task>>);
+    get task(): A2A.Task;
+    static create(params?: TaskParams): A2A.Task;
+}
+/**
+ * Convenience factory function for creating a task with default parameters.
+ *
+ * @returns New {@link A2A.Task} with default parameters
+ * @defaults:
+ * - `id`: uuidv4()
+ * - `contextId`: id
+ * - `status`: { state: "working" }
+ * @example
+ * ```typescript
+ * const task = task({ status: { state: "working" } });
+ * ```
+ *
+ * @public
+ * @since 0.6.0
+ */
+export declare const task: typeof Task.create;
+export type StatusUpdateParams = (Partial<Kindless<A2A.TaskStatusUpdateEvent>> & {
+    status: StatusParams;
+}) | StatusParams;
+export declare class TaskStatusUpdateEvent {
+    private readonly _event;
+    constructor(params: Partial<Kindless<A2A.TaskStatusUpdateEvent>> & Required<Pick<Kindless<A2A.TaskStatusUpdateEvent>, "status">>);
+    get event(): A2A.TaskStatusUpdateEvent;
+    static create(params: StatusUpdateParams): A2A.TaskStatusUpdateEvent;
+}
+export type ArtifactUpdateParams = (Partial<Kindless<A2A.TaskArtifactUpdateEvent>> & {
+    artifact: ArtifactParams;
+}) | ArtifactParams;
+export declare class TaskArtifactUpdateEvent {
+    private readonly _event;
+    constructor(params: Partial<Kindless<A2A.TaskArtifactUpdateEvent>> & Required<Pick<Kindless<A2A.TaskArtifactUpdateEvent>, "artifact">>);
+    get event(): A2A.TaskArtifactUpdateEvent;
+    static create(params: ArtifactUpdateParams): A2A.TaskArtifactUpdateEvent;
+}
+type StrictUpdateParams = Partial<Kindless<A2A.TaskStatusUpdateEvent>> & Required<Pick<Kindless<A2A.TaskStatusUpdateEvent>, "taskId" | "contextId" | "status">>;
+export type BuildStatusParams = Omit<StrictUpdateParams, "status"> & Omit<A2A.TaskStatus, "state">;
+declare function _working(params: BuildStatusParams): A2A.TaskStatusUpdateEvent;
+declare function _canceled(params: BuildStatusParams): A2A.TaskStatusUpdateEvent;
+declare function _submitted(params: BuildStatusParams): A2A.TaskStatusUpdateEvent;
+declare function _failed(params: BuildStatusParams): A2A.TaskStatusUpdateEvent;
+declare function _completed(params: BuildStatusParams): A2A.TaskStatusUpdateEvent;
+declare function _inputRequired(params: BuildStatusParams): A2A.TaskStatusUpdateEvent;
+declare function _rejected(params: BuildStatusParams): A2A.TaskStatusUpdateEvent;
+declare function _authRequired(params: BuildStatusParams): A2A.TaskStatusUpdateEvent;
+declare function _unknown(params: BuildStatusParams): A2A.TaskStatusUpdateEvent;
+/**
+ * Convenience factory function for creating a task status and artifact update events with default parameters.
+ *
+ * @returns New {@link A2A.TaskStatusUpdateEvent} and {@link A2A.TaskArtifactUpdateEvent} with default parameters
+ *
+ * @example
+ * ```typescript
+ * const artifactEvent = update.artifact({
+ *   artifact: "result"
+ * });
+ * const statusEvent = update.status({
+ *   status: "working"
+ * });
+ * ```
+ *
+ * @public
+ * @since 0.6.0
+ */
+export declare const update: {
+    /**
+     * Convenience factory function for creating a task artifact update event.
+     * @returns New {@link A2A.TaskArtifactUpdateEvent}
+     * @example
+     * ```typescript
+     * const event = update.artifact({
+     *   artifact: "result"
+     * });
+     * ```
+     */
+    artifact: typeof TaskArtifactUpdateEvent.create;
+    /**
+     * Convenience factory function for creating a task status update event.
+     * @returns New {@link A2A.TaskStatusUpdateEvent}
+     * @example
+     * ```typescript
+     * const event = update.status({
+     *   message: "Working on the task"
+     * });
+     * ```
+     */
+    status: typeof TaskStatusUpdateEvent.create;
+    /**
+     * Convenience factory function for creating a task status update event with the working state.
+     * @returns New {@link A2A.TaskStatusUpdateEvent} with the {@link A2A.TaskState.working} state
+     * @example
+     * ```typescript
+     * const event = update.working({
+     *   message: "Working on the task"
+     * });
+     * ```
+     */
+    working: typeof _working;
+    /**
+     * Convenience factory function for creating a task status update event with the canceled state.
+     * @returns New {@link A2A.TaskStatusUpdateEvent} with the {@link A2A.TaskState.canceled} state
+     * @example
+     * ```typescript
+     * const event = update.canceled({
+     *   message: "Task canceled"
+     * });
+     * ```
+     */
+    canceled: typeof _canceled;
+    /**
+     * Convenience factory function for creating a task status update event with the submitted state.
+     * @returns New {@link A2A.TaskStatusUpdateEvent} with the {@link A2A.TaskState.submitted} state
+     * @example
+     * ```typescript
+     * const event = update.submitted({
+     *   message: "Task submitted"
+     * });
+     * ```
+     */
+    submitted: typeof _submitted;
+    /**
+     * Convenience factory function for creating a task status update event with the failed state.
+     * @returns New {@link A2A.TaskStatusUpdateEvent} with the {@link A2A.TaskState.failed} state
+     * @example
+     * ```typescript
+     * const event = update.failed({
+     *   message: "Task failed"
+     * });
+     * ```
+     */
+    failed: typeof _failed;
+    /**
+     * Convenience factory function for creating a task status update event with the completed state.
+     * @returns New {@link A2A.TaskStatusUpdateEvent} with the {@link A2A.TaskState.completed} state
+     * @example
+     * ```typescript
+     * const event = update.completed({
+     *   message: "Task completed"
+     * });
+     * ```
+     */
+    completed: typeof _completed;
+    /**
+     * Convenience factory function for creating a task status update event with the input required state.
+     * @returns New {@link A2A.TaskStatusUpdateEvent} with the {@link A2A.TaskState["input-required"]} state
+     * @example
+     * ```typescript
+     * const event = update.inputRequired({
+     *   message: "Task input required"
+     * });
+     * ```
+     */
+    inputRequired: typeof _inputRequired;
+    /**
+     * Convenience factory function for creating a task status update event with the rejected state.
+     * @returns New {@link A2A.TaskStatusUpdateEvent} with the {@link A2A.TaskState.rejected} state
+     * @example
+     * ```typescript
+     * const event = update.rejected({
+     *   message: "Task rejected"
+     * });
+     * ```
+     */
+    rejected: typeof _rejected;
+    /**
+     * Convenience factory function for creating a task status update event with the auth required state.
+     * @returns New {@link A2A.TaskStatusUpdateEvent} with the {@link A2A.TaskState["auth-required"]} state
+     * @example
+     * ```typescript
+     * const event = update.authRequired({
+     *   message: {
+     *   role: "agent"
+     *   parts: [
+     *     {
+     *       text: "Task auth required"
+     *     }
+     *   ]
+     *   kind: "message"
+     * });
+     * ```
+     */
+    authRequired: typeof _authRequired;
+    /**
+     * Convenience factory function for creating a task status update event with the unknown state.
+     * @returns New {@link A2A.TaskStatusUpdateEvent} with the {@link A2A.TaskState.unknown} state
+     * @example
+     * ```typescript
+     * const event = update.unknown({
+     *   message: "Task unknown"
+     * });
+     * ```
+     */
+    unknown: typeof _unknown;
+};
+/**
+ * @description A temporary compatibility function for updating a task status, purely for migration purposes.
+ * @deprecated Use {@link update.status} instead
+ * @since 0.6.0
+ */
+export declare const update_compat: (taskId: string, contextId: string, state: A2A.TaskState, message?: A2A.Message, timestamp?: string, final?: boolean) => A2A.TaskStatusUpdateEvent;
+export {};