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

package/dist/browser/utils/common/constants.js

@@ -3,33 +3,6 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { A2A } from "../../types/index.js";
-import { getCurrentTimestamp } from "./utils.js";
-//todo: protocol specific so move to a2a folder
-export const STATUS_UPDATE = (taskId, contextId, status, message, timestamp = getCurrentTimestamp(), final = false) => {
-    return {
-        taskId: taskId,
-        contextId: contextId,
-        kind: "status-update",
-        status: {
-            state: status,
-            message: message,
-            timestamp: timestamp,
-        },
-        final: final,
-    };
-};
-export const WORKING_UPDATE = (taskId, contextId, message, timestamp) => {
-    return STATUS_UPDATE(taskId, contextId, A2A.TaskState.working, message, timestamp);
-};
-export const CANCEL_UPDATE = (taskId, contextId, message, timestamp) => {
-    return STATUS_UPDATE(taskId, contextId, A2A.TaskState.canceled, message, timestamp, true);
-};
-export const SUBMITTED_UPDATE = (taskId, contextId, message, timestamp) => {
-    return STATUS_UPDATE(taskId, contextId, A2A.TaskState.submitted, message, timestamp);
-};
-export const FAILED_UPDATE_EVENT = (taskId, contextId, message, timestamp) => {
-    return STATUS_UPDATE(taskId, contextId, A2A.TaskState.failed, message, timestamp, true);
-};
 export const FINAL_STATES = [
     A2A.TaskState.completed,
     A2A.TaskState.failed,

package/dist/browser/utils/common/errors.d.ts

@@ -3,22 +3,78 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { A2A, MCP } from "../../types/index.js";
-export declare class SystemError<T extends MCP.JSONRPCError> extends Error {
+/**
+ * @deprecated Use errors from the `@a2a-js/sdk` package instead
+ * @since 0.6.0
+ */
+export declare class SystemError<T extends MCP.JSONRPCErrorResponse> extends Error {
     message: string;
     code: T["error"]["code"];
     data: T["error"]["data"];
     constructor(message: string, code: T["error"]["code"], data: T["error"]["data"]);
 }
+/**
+ * @deprecated Use errors from the `@a2a-js/sdk` package instead
+ * @since 0.6.0
+ */
 export declare const PARSE_ERROR: <T extends A2A.JSONParseError>(data: T["error"]["data"]) => SystemError<T>;
+/**
+ * @deprecated Use errors from the `@a2a-js/sdk` package instead
+ * @since 0.6.0
+ */
 export declare const INVALID_REQUEST: <T extends A2A.InvalidRequestError>(data: T["error"]["data"]) => SystemError<T>;
+/**
+ * @deprecated Use errors from the `@a2a-js/sdk` package instead
+ * @since 0.6.0
+ */
 export declare const METHOD_NOT_FOUND: <T extends A2A.MethodNotFoundError>(data: T["error"]["data"]) => SystemError<T>;
+/**
+ * @deprecated Use errors from the `@a2a-js/sdk` package instead
+ * @since 0.6.0
+ */
 export declare const INVALID_PARAMS: <T extends A2A.InvalidParamsError>(data: T["error"]["data"]) => SystemError<T>;
+/**
+ * @deprecated Use errors from the `@a2a-js/sdk` package instead
+ * @since 0.6.0
+ */
 export declare const INTERNAL_ERROR: <T extends A2A.InternalError>(data: T["error"]["data"]) => SystemError<T>;
+/**
+ * @deprecated Use errors from the `@a2a-js/sdk` package instead
+ * @since 0.6.0
+ */
 export declare const TASK_NOT_FOUND: <T extends A2A.TaskNotFoundError>(data: T["error"]["data"]) => SystemError<T>;
+/**
+ * @deprecated Use errors from the `@a2a-js/sdk` package instead
+ * @since 0.6.0
+ */
 export declare const TASK_NOT_CANCELABLE: <T extends A2A.TaskNotCancelableError>(data: T["error"]["data"]) => SystemError<T>;
+/**
+ * @deprecated Use errors from the `@a2a-js/sdk` package instead
+ * @since 0.6.0
+ */
 export declare const PUSH_NOTIFICATION_NOT_SUPPORTED: <T extends A2A.A2AError>(data: T["error"]["data"]) => SystemError<T>;
+/**
+ * @deprecated Use errors from the `@a2a-js/sdk` package instead
+ * @since 0.6.0
+ */
 export declare const AUTHENTICATED_EXTENDED_CARD_NOT_CONFIGURED: <T extends A2A.AuthenticatedExtendedCardNotConfiguredError>(data: T["error"]["data"]) => SystemError<T>;
+/**
+ * @deprecated Use errors from the `@a2a-js/sdk` package instead
+ * @since 0.6.0
+ */
 export declare const UNSUPPORTED_OPERATION: <T extends A2A.A2AError>(data: T["error"]["data"]) => SystemError<T>;
+/**
+ * @deprecated Use errors from the `@a2a-js/sdk` package instead
+ * @since 0.6.0
+ */
 export declare const CONTENT_TYPE_NOT_SUPPORTED: <T extends A2A.ContentTypeNotSupportedError>(data: T["error"]["data"]) => SystemError<T>;
+/**
+ * @deprecated Use errors from the `@a2a-js/sdk` package instead
+ * @since 0.6.0
+ */
 export declare const INVALID_AGENT_RESPONSE: <T extends A2A.InvalidAgentResponseError>(data: T["error"]["data"]) => SystemError<T>;
+/**
+ * @deprecated Use {@link describe.update.failed} instead
+ * @since 0.6.0
+ */
 export declare const FAILED_UPDATE: (taskId: string, contextId: string, messageId: string | undefined, errMessage: string) => A2A.TaskStatusUpdateEvent;

package/dist/browser/utils/common/errors.js

@@ -3,40 +3,93 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { A2A } from "../../types/index.js";
+import * as describe from "../../create/describe.js";
+import { formatJson } from "./utils.js";
+/**
+ * @deprecated Use errors from the `@a2a-js/sdk` package instead
+ * @since 0.6.0
+ */
 export class SystemError extends Error {
     constructor(message, code, data) {
-        super(message);
+        super(message + " " + formatJson({ cause: data }));
         // this.name = "RpcError";
         this.message = message;
         this.code = code;
         this.data = data;
     }
 }
-// Factory methods for common errors
+/**
+ * @deprecated Use errors from the `@a2a-js/sdk` package instead
+ * @since 0.6.0
+ */
 export const PARSE_ERROR = (data) => new SystemError("Invalid JSON payload", A2A.ErrorCodeParseError, data);
+/**
+ * @deprecated Use errors from the `@a2a-js/sdk` package instead
+ * @since 0.6.0
+ */
 export const INVALID_REQUEST = (data) => new SystemError("Request payload validation error", A2A.ErrorCodeInvalidRequest, data);
+/**
+ * @deprecated Use errors from the `@a2a-js/sdk` package instead
+ * @since 0.6.0
+ */
 export const METHOD_NOT_FOUND = (data) => new SystemError("Method not found", A2A.ErrorCodeMethodNotFound, data);
+/**
+ * @deprecated Use errors from the `@a2a-js/sdk` package instead
+ * @since 0.6.0
+ */
 export const INVALID_PARAMS = (data) => new SystemError("Invalid parameters", A2A.ErrorCodeInvalidParams, data);
+/**
+ * @deprecated Use errors from the `@a2a-js/sdk` package instead
+ * @since 0.6.0
+ */
 export const INTERNAL_ERROR = (data) => new SystemError("Internal error", A2A.ErrorCodeInternalError, data);
+/**
+ * @deprecated Use errors from the `@a2a-js/sdk` package instead
+ * @since 0.6.0
+ */
 export const TASK_NOT_FOUND = (data) => new SystemError("Task not found", A2A.ErrorCodeTaskNotFound, data);
+/**
+ * @deprecated Use errors from the `@a2a-js/sdk` package instead
+ * @since 0.6.0
+ */
 export const TASK_NOT_CANCELABLE = (data) => new SystemError("Task cannot be canceled", A2A.ErrorCodeTaskNotCancelable, data);
+/**
+ * @deprecated Use errors from the `@a2a-js/sdk` package instead
+ * @since 0.6.0
+ */
 export const PUSH_NOTIFICATION_NOT_SUPPORTED = (data) => new SystemError("Push Notifications is not supported", A2A.ErrorCodePushNotificationNotSupported, data);
+/**
+ * @deprecated Use errors from the `@a2a-js/sdk` package instead
+ * @since 0.6.0
+ */
 export const AUTHENTICATED_EXTENDED_CARD_NOT_CONFIGURED = (data) => new SystemError("Authenticated Extended Card is not configured", A2A.ErrorCodeAuthenticatedExtendedCardNotConfigured, data);
+/**
+ * @deprecated Use errors from the `@a2a-js/sdk` package instead
+ * @since 0.6.0
+ */
 export const UNSUPPORTED_OPERATION = (data) => new SystemError("This operation is not supported", A2A.ErrorCodeUnsupportedOperation, data);
+/**
+ * @deprecated Use errors from the `@a2a-js/sdk` package instead
+ * @since 0.6.0
+ */
 export const CONTENT_TYPE_NOT_SUPPORTED = (data) => new SystemError("Content type not supported", A2A.ErrorCodeContentTypeNotSupported, data);
+/**
+ * @deprecated Use errors from the `@a2a-js/sdk` package instead
+ * @since 0.6.0
+ */
 export const INVALID_AGENT_RESPONSE = (data) => new SystemError("Invalid agent response", A2A.ErrorCodeInvalidAgentResponse, data);
-export const FAILED_UPDATE = (taskId, contextId, messageId = "failed-update", errMessage) => ({
-    taskId,
-    contextId,
-    kind: "status-update",
-    final: true,
-    status: {
-        state: A2A.TaskState.failed,
-        message: {
+/**
+ * @deprecated Use {@link describe.update.failed} instead
+ * @since 0.6.0
+ */
+export const FAILED_UPDATE = (taskId, contextId, messageId = "failed-update", errMessage) => {
+    return describe.update.failed({
+        taskId,
+        contextId,
+        final: true,
+        message: describe.message({
             messageId,
-            role: "agent",
             parts: [{ kind: "text", text: errMessage }],
-            kind: "message",
-        },
-    },
-});
+        }),
+    });
+};

package/dist/client/a2a-client.js

@@ -6,7 +6,7 @@ import { executeJsonRpcRequest, executeGetRequest, } from "../transport/rpc/rpc-
 import { executeStreamEvents } from "../transport/streaming/event-stream.js";
 import { INTERNAL_ERROR } from "../utils/common/errors.js";
 import { logger } from "../config/index.js";
-import { createMessageSendParams } from "../services/a2a/helpers/message-builder.js";
+import * as describe from "../create/describe.js";
 /**
  * A2AClient is the main client class for interacting with Agent2Agent (A2A) protocol-compliant services.
  * It provides methods for sending tasks, retrieving statuses, canceling operations, and handling streaming responses.
@@ -108,10 +108,10 @@ export class A2AClient {
      */
     async sendMessage(params) {
         return await executeJsonRpcRequest(this.agentUrl, "message/send", typeof params === "string"
-            ? createMessageSendParams(params)
+            ? describe.messageSendParams(params)
             : typeof params === "object" && "message" in params
                 ? params
-                : createMessageSendParams({ message: params }), this.customHeaders);
+                : describe.messageSendParams({ message: params }), this.customHeaders);
     }
     /**
      * @deprecated Use sendMessage instead.
@@ -128,7 +128,7 @@ export class A2AClient {
      * @returns An AsyncIterable that yields TaskStatusUpdateEvent/TaskArtifactUpdateEvent/Task/Message payloads.
      */
     sendStreamingMessage(params) {
-        return executeStreamEvents(this.agentUrl, "message/stream", createMessageSendParams(params), this.customHeaders);
+        return executeStreamEvents(this.agentUrl, "message/stream", describe.messageSendParams(params), this.customHeaders);
     }
     /**
      * @deprecated Use sendStreamingMessage instead.

package/dist/config/default.d.ts

@@ -9,7 +9,7 @@
  *
  * @example
  * ```typescript
- * import { applyDefaults } from '@artinet/core';
+ * import { applyDefaults } from '@artinet/armada';
  *
  * // Enable console logging with defaults
  * applyDefaults();

package/dist/config/default.js

@@ -9,7 +9,7 @@
  *
  * @example
  * ```typescript
- * import { applyDefaults } from '@artinet/core';
+ * import { applyDefaults } from '@artinet/armada';
  *
  * // Enable console logging with defaults
  * applyDefaults();

package/dist/config/index.d.ts

@@ -15,7 +15,7 @@
  *
  * @example
  * ```typescript
- * import { configure, getLogger, getTracer } from '@artinet/core';
+ * import { configure, getLogger, getTracer } from '@artinet/armada';
  * import pino from 'pino';
  *
  * // Configure at app startup

package/dist/config/index.js

@@ -15,7 +15,7 @@
  *
  * @example
  * ```typescript
- * import { configure, getLogger, getTracer } from '@artinet/core';
+ * import { configure, getLogger, getTracer } from '@artinet/armada';
  * import pino from 'pino';
  *
  * // Configure at app startup

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

@@ -0,0 +1,77 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2A } from "../types/index.js";
+import { ArtifactUpdateParams, StatusUpdateParams, TaskParams } from "./task-builder.js";
+import { MessageParams } from "./message-builder.js";
+export interface BaseArguments {
+    message: A2A.MessageSendParams;
+    context: A2A.Context;
+    skip: () => Promise<void> | void;
+}
+export type BaseArgs = Record<string, unknown>;
+export type EmptyArgs = Record<string, never>;
+export type empty = EmptyArgs;
+export type bargs = BaseArgs;
+export type InputArguments<CarriedArguments extends BaseArgs = EmptyArgs> = BaseArguments & Partial<{
+    content: string;
+    args: CarriedArguments;
+}>;
+export type AcceptedKinds = "text" | "file" | "data" | "message" | "artifact-update" | "status-update" | "task";
+/**
+ * State will be inherited from the context, so we don't allow the user to pass those arguments back to us.
+ */
+export type Stateless<T> = T extends object ? Omit<T, "taskId" | "contextId"> : T;
+export type data = A2A.DataPart["data"];
+export type file = A2A.FilePart["file"];
+export type text = A2A.TextPart["text"];
+export type sMessage = Stateless<MessageParams>;
+export type sArtifact = Stateless<ArtifactUpdateParams>;
+export type sUpdate = Stateless<StatusUpdateParams>;
+export type sTask = Stateless<TaskParams>;
+export type AcceptedParts = data | file | text;
+export type AcceptedArrayValues = AcceptedParts | sUpdate | sArtifact;
+export type AcceptedReturnValues = AcceptedParts | sMessage | sArtifact | sUpdate | sTask;
+export type ReturnValue<Ret extends AcceptedReturnValues> = {
+    reply: Ret extends AcceptedArrayValues ? Array<Ret> | Ret : Ret;
+};
+export type ReturnAndCarry<Ret extends AcceptedReturnValues, Carried extends BaseArgs = EmptyArgs> = ReturnValue<Ret> & {
+    args: Carried;
+};
+export type Reply<Ret extends AcceptedReturnValues, Carried extends BaseArgs = EmptyArgs> = ReturnValue<Ret> | ReturnAndCarry<Ret, Carried> | Ret | (Ret extends AcceptedArrayValues ? Array<Ret> : never);
+export type rep<R extends AcceptedReturnValues, C extends BaseArgs> = Reply<R, C>;
+export type Invocable<Ret extends AcceptedReturnValues = A2A.TextPart["text"], Input extends BaseArgs = EmptyArgs, Carried extends BaseArgs = EmptyArgs, Response extends Reply<Ret, Carried> = Reply<Ret, Carried>> = (params: InputArguments<Input>) => Promise<Response> | Response;
+export type Step<Ret extends AcceptedReturnValues, Input extends BaseArgs = EmptyArgs, Carry extends BaseArgs = EmptyArgs> = Invocable<Ret, Input, Carry, Reply<Ret, Carry>>;
+export type Transform<Ret extends AcceptedReturnValues> = (payload: Ret | Array<Ret>, context: A2A.Context) => AsyncGenerator<A2A.Update, void, unknown>;
+export type Resolved<Ret extends AcceptedReturnValues = A2A.TextPart["text"], Input extends BaseArgs = EmptyArgs, Carried extends BaseArgs = EmptyArgs, Response extends Reply<Ret, Carried> = Reply<Ret, Carried>, Kind extends AcceptedKinds = "text"> = {
+    id: string;
+    step: Invocable<Ret, Input, Carried, Response>;
+    kind: Kind;
+    handler: Transform<Ret>;
+};
+export type inferCarry<Carried> = Carried extends ReturnAndCarry<any, infer Carry> ? Carry : EmptyArgs;
+export type inC<Carried> = Carried extends ReturnAndCarry<any, infer Carry> ? Carry : EmptyArgs;
+export interface AgentBuilder<Input extends BaseArgs = EmptyArgs> {
+    /**
+     * Add a step to the builder.
+     * @param step - The step to add.
+     * @returns A new builder with the step added.
+     */
+    addStep<Ret extends AcceptedReturnValues = A2A.TextPart["text"], Carried extends BaseArgs = EmptyArgs, Response extends Reply<Ret, Carried> = Reply<Ret, Carried>, Kind extends AcceptedKinds = "text">(step: Resolved<Ret, Input, Carried, Response, Kind>): AgentBuilder<inC<Response>>;
+}
+/**
+ * Carry Only Returns
+ * @internal
+ * Potential Upgrade:
+ * Currently enforce that args cant be passed back without a reply,
+ * but may allow carry only returns in the future.
+ *
+ * ```typescript
+ * type CarryOnly<Carried extends BaseArgs> = {
+ *   args: Carried;
+ * } & {
+ *   reply: never;
+ * };
+ * ```
+ */

package/dist/create/agent-builder.js

@@ -0,0 +1,20 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};
+/**
+ * Carry Only Returns
+ * @internal
+ * Potential Upgrade:
+ * Currently enforce that args cant be passed back without a reply,
+ * but may allow carry only returns in the future.
+ *
+ * ```typescript
+ * type CarryOnly<Carried extends BaseArgs> = {
+ *   args: Carried;
+ * } & {
+ *   reply: never;
+ * };
+ * ```
+ */

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

@@ -0,0 +1,47 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2A } from "../types/index.js";
+export type AgentCardParams = (Partial<A2A.AgentCard> & Required<Pick<A2A.AgentCard, "name">>) | string;
+export declare const isAgentCardParams: (params: any) => params is AgentCardParams;
+export declare class AgentCard {
+    private readonly _agentCard;
+    constructor(params: Partial<A2A.AgentCard> & Required<Pick<A2A.AgentCard, "name">>);
+    get agentCard(): A2A.AgentCard;
+    static create(params: AgentCardParams): A2A.AgentCard;
+}
+/**
+ * @deprecated Use {@link card} instead
+ * @since 0.6.0
+ */
+export declare const AgentCardBuilder: typeof AgentCard;
+/**
+ * Convenience factory function for creating an {@link A2A.AgentCard} with default parameters.
+ *
+ * @returns New {@link A2A.AgentCard} with default parameters
+ * @defaults {
+ *   description: "An agent that can use the A2A protocol.",
+ *   url: "https://localhost:3000/a2a",
+ *   version: "0.0.0",
+ *   capabilities: {},
+ *   defaultInputModes: [],
+ *   defaultOutputModes: [],
+ *   skills: [],
+ *   preferredTransport: "JSONRPC",
+ * }
+ *
+ * @example
+ * ```typescript
+ * const agentCard = card("My Agent");
+ * ```
+ *
+ * @public
+ * @since 0.6.0
+ */
+export declare const card: typeof AgentCard.create;
+/**
+ * @deprecated Use {@link card} instead
+ * @since 0.6.0
+ */
+export declare const createAgentCard: typeof AgentCard.create;

package/dist/create/agentcard-builder.js

@@ -0,0 +1,66 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export const isAgentCardParams = (params) => {
+    return (typeof params === "string" ||
+        (typeof params === "object" && params !== null && "name" in params));
+};
+export class AgentCard {
+    _agentCard;
+    constructor(params) {
+        this._agentCard = {
+            protocolVersion: "0.3.0",
+            description: "An agent that can use the A2A protocol.",
+            url: "https://localhost:3000/a2a",
+            version: "0.0.0",
+            capabilities: {},
+            defaultInputModes: [],
+            defaultOutputModes: [],
+            skills: [],
+            preferredTransport: "JSONRPC",
+            ...params,
+        };
+    }
+    get agentCard() {
+        return this._agentCard;
+    }
+    static create(params) {
+        return new AgentCard(typeof params === "string" ? { name: params } : params)
+            .agentCard;
+    }
+}
+/**
+ * @deprecated Use {@link card} instead
+ * @since 0.6.0
+ */
+export const AgentCardBuilder = AgentCard;
+/**
+ * Convenience factory function for creating an {@link A2A.AgentCard} with default parameters.
+ *
+ * @returns New {@link A2A.AgentCard} with default parameters
+ * @defaults {
+ *   description: "An agent that can use the A2A protocol.",
+ *   url: "https://localhost:3000/a2a",
+ *   version: "0.0.0",
+ *   capabilities: {},
+ *   defaultInputModes: [],
+ *   defaultOutputModes: [],
+ *   skills: [],
+ *   preferredTransport: "JSONRPC",
+ * }
+ *
+ * @example
+ * ```typescript
+ * const agentCard = card("My Agent");
+ * ```
+ *
+ * @public
+ * @since 0.6.0
+ */
+export const card = AgentCard.create;
+/**
+ * @deprecated Use {@link card} instead
+ * @since 0.6.0
+ */
+export const createAgentCard = AgentCard.create;

package/dist/create/base.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Utility type that omits the `kind` property from an object type.
+ */
+export type Kindless<T extends object> = Omit<T, "kind">;

package/dist/create/base.js

@@ -0,0 +1 @@
+export {};