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

package/dist/server/express/server.js

@@ -3,26 +3,24 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import express from "express";
-import { INVALID_REQUEST, PARSE_ERROR } from "../../utils/index.js";
 import { createAgent, Service, } from "../../services/index.js";
 import cors from "cors";
 import { jsonRPCMiddleware } from "./middeware.js";
 import { errorHandler } from "./errors.js";
+import { logger } from "../../config/index.js";
+import { A2AError } from "@a2a-js/sdk/server";
+import { formatJson } from "../../utils/common/utils.js";
 export function rpcParser(req, res, next) {
     express.json()(req, res, (err) => {
         if (!req.body || typeof req.body !== "object") {
-            return next(PARSE_ERROR({
-                data: { message: "Invalid request body" },
-            }));
+            return next(A2AError.parseError(`Invalid request body: ${formatJson(req.body)}`));
         }
         if (err) {
             if (err instanceof SyntaxError &&
                 "status" in err &&
                 err.status === 400 &&
                 "body" in err) {
-                return next(PARSE_ERROR({
-                    data: err.message,
-                }));
+                return next(A2AError.parseError(`Invalid request body: ${formatJson(req.body)}`));
             }
             return next(err);
         }
@@ -46,7 +44,11 @@ const ensureAgent = (agentOrParams) => {
     }
     throw new Error("invalid agent or params");
 };
-export function createAgentServer({ app = express(), basePath = "/", agentCardPath = "/.well-known/agent-card.json", agent, corsOptions, extendedAgentCard, }) {
+const registerAgent = async (agentCard) => {
+    logger.debug("registerAgent: not implemented", { agentCard });
+    return Promise.resolve(agentCard);
+};
+export function createAgentServer({ app = express(), basePath = "/", agentCardPath = "/.well-known/agent-card.json", agent, corsOptions, extendedAgentCard, register = false, port, }) {
     const agentInstance = ensureAgent(agent);
     app.use(cors(corsOptions));
     if (agentCardPath !== "/.well-known/agent-card.json") {
@@ -72,10 +74,10 @@ export function createAgentServer({ app = express(), basePath = "/", agentCardPa
     //a standard express middleware to handle json-rpc requests
     app.post(basePath, rpcParser, async (req, res, next) => {
         const { jsonrpc } = req.body;
-        if (jsonrpc === "2.0") {
-            return await jsonRPCMiddleware(agentInstance, req, res, next, extendedAgentCard);
+        if (jsonrpc !== "2.0") {
+            return next(A2AError.invalidRequest("Invalid JSON-RPC request"));
         }
-        next(INVALID_REQUEST({ data: { message: "Invalid JSON-RPC request" } }));
+        return await jsonRPCMiddleware(agentInstance, req, res, next, extendedAgentCard);
     });
     app.use(errorHandler);
     /** this is an example of using trpc as express middleware
@@ -94,5 +96,21 @@ export function createAgentServer({ app = express(), basePath = "/", agentCardPa
       );
      * we could also use trpc directly or any other transport layer
      */
-    return { app, agent: agentInstance };
+    const start = (_port) => {
+        try {
+            const listenPort = _port ?? port;
+            const server = app.listen(listenPort, () => {
+                logger.info(`Agent server started on port ${listenPort}`);
+            });
+            if (register) {
+                registerAgent(agentInstance.agentCard);
+            }
+            return server;
+        }
+        catch (error) {
+            logger.error(`Failed to start agent server`, error);
+            throw error;
+        }
+    };
+    return { app, agent: agentInstance, start };
 }

package/dist/services/a2a/execute.d.ts

@@ -3,4 +3,9 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { A2A } from "../../types/index.js";
+/**
+ * Our universal executor for {@link A2A.Engine}.
+ * @param engine - {@link A2A.Engine} to execute.
+ * @param context - {@link A2A.Context} provided to the engine.
+ */
 export declare const execute: (engine: A2A.Engine, context: A2A.Context) => Promise<void>;

package/dist/services/a2a/execute.js

@@ -2,6 +2,11 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
+/**
+ * Our universal executor for {@link A2A.Engine}.
+ * @param engine - {@link A2A.Engine} to execute.
+ * @param context - {@link A2A.Context} provided to the engine.
+ */
 export const execute = async (engine, context) => {
     try {
         if (context.publisher.onStart) {
@@ -16,7 +21,9 @@ export const execute = async (engine, context) => {
         }
     }
     catch (error) {
+        /* onError triggers completion internally */
         await context.publisher.onError(error);
+        /* rethrow the error to be handled by the caller */
         throw error;
     }
     finally {

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

@@ -6,7 +6,7 @@ import { A2A } from "../../../types/index.js";
 export declare function createBaseContext({ contextId, service, task, overrides, abortSignal, }: {
     contextId: string;
     service: A2A.Service;
-    task?: A2A.Task;
+    task: A2A.Task;
     overrides?: Partial<Omit<A2A.EventConsumer, "contextId">>;
     abortSignal?: AbortSignal;
 }): A2A.BaseContext;

package/dist/services/a2a/factory/context.js

@@ -17,8 +17,7 @@
 import { createStateMachine } from "./state-machine.js";
 import { v4 as uuidv4 } from "uuid";
 export function createBaseContext({ contextId = uuidv4(), service, task, overrides, abortSignal = new AbortController().signal, }) {
-    const isCancelled = async () => (await service.cancellations.has(task?.id ?? contextId)) ||
-        abortSignal.aborted;
+    const isCancelled = async () => (await service.cancellations.has(task.id)) || abortSignal.aborted;
     const getState = async (args) => args ? await service.tasks.get(args) : task;
     const context = {
         contextId: contextId,
@@ -34,7 +33,7 @@ export function createContext({ baseContext, taskId, messenger, extensions, refe
     const getTask = async () => baseContext.publisher.currentTask;
     const context = {
         ...baseContext,
-        taskId: baseContext.publisher.currentTask.id ?? taskId,
+        taskId,
         userMessage: messenger.message,
         messages: messenger,
         getTask,

package/dist/services/a2a/factory/handler.js

@@ -2,13 +2,13 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import { getTask, cancelTask, sendMessage, streamMessage, resubscribe, } from "../handlers/index.js";
+import { getTask, cancelTask, sendMessage, sendMessageStream, subscribeToTask, } from "../handlers/index.js";
 export function createHandler(methods) {
     return {
         getTask: methods?.getTask ?? getTask,
         cancelTask: methods?.cancelTask ?? cancelTask,
         sendMessage: methods?.sendMessage ?? sendMessage,
-        streamMessage: methods?.streamMessage ?? streamMessage,
-        resubscribe: methods?.resubscribe ?? resubscribe,
+        streamMessage: methods?.streamMessage ?? sendMessageStream,
+        resubscribe: methods?.resubscribe ?? subscribeToTask,
     };
 }

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

@@ -1,4 +1,3 @@
 export * from "./context.js";
-export * from "./builder.js";
 export * from "./state-machine.js";
 export * from "./service.js";

package/dist/services/a2a/factory/index.js

@@ -1,4 +1,3 @@
 export * from "./context.js";
-export * from "./builder.js";
 export * from "./state-machine.js";
 export * from "./service.js";

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

@@ -1,8 +1,8 @@
+import * as describe from "../../../create/agentcard-builder.js";
 import { A2A } from "../../../types/index.js";
 import { Service } from "../service.js";
-export type AgentCardParams = (Partial<A2A.AgentCard> & Required<Pick<A2A.AgentCard, "name">>) | string;
 export interface ServiceParams {
-    agentCard: AgentCardParams;
+    agentCard: describe.AgentCardParams;
     engine: A2A.Engine;
     contexts?: A2A.Contexts;
     streams?: A2A.Streams;

package/dist/services/a2a/factory/service.js

@@ -3,10 +3,10 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { createHandler } from "./handler.js";
-import { createAgentCard } from "../helpers/agentcard-builder.js";
+import * as describe from "../../../create/agentcard-builder.js";
 import { Service } from "../service.js";
 import { Contexts, Streams, Connections, Cancellations, Tasks, } from "../managers.js";
 export function createService(params) {
-    return new Service(createAgentCard(params.agentCard), params.engine, params.connections ?? new Connections(), params.cancellations ?? new Cancellations(), params.tasks ?? new Tasks(), params.contexts ?? new Contexts(), params.streams ?? new Streams(), createHandler(params.methods), params.overrides);
+    return new Service(describe.card(params.agentCard), params.engine, params.connections ?? new Connections(), params.cancellations ?? new Cancellations(), params.tasks ?? new Tasks(), params.contexts ?? new Contexts(), params.streams ?? new Streams(), createHandler(params.methods), params.overrides);
 }
 export const createAgent = createService;

package/dist/services/a2a/factory/state-machine.d.ts

@@ -6,6 +6,6 @@ import { A2A } from "../../../types/index.js";
 export declare function createStateMachine({ contextId, service, task: currentTask, overrides, }: {
     contextId: string;
     service: A2A.Service;
-    task?: A2A.Task;
+    task: A2A.Task;
     overrides?: Partial<Omit<A2A.EventConsumer, "contextId">>;
 }): A2A.EventPublisher;

package/dist/services/a2a/factory/state-machine.js

@@ -4,7 +4,8 @@
  */
 import { StateMachine } from "../state-machine.js";
 import { logger } from "../../../config/index.js";
-import { TASK_NOT_FOUND, CANCEL_UPDATE, FAILED_UPDATE } from "../../../utils/index.js";
+import * as describe from "../../../create/describe.js";
+import { TASK_NOT_FOUND } from "../../../utils/index.js";
 import assert from "assert";
 export function createStateMachine({ contextId, service, task: currentTask, overrides, }) {
     const handler = {
@@ -25,7 +26,11 @@ export function createStateMachine({ contextId, service, task: currentTask, over
             logger.info(`onCancel[ctx:${contextId}]:`, "cancellation triggered");
             logger.debug(`onCancel[ctx:${contextId}]:`, "arguments", update, task);
             await service.cancellations.set(task.id);
-            const cancellation = CANCEL_UPDATE(task.id, task.contextId, update.status?.message);
+            const cancellation = describe.update.canceled({
+                taskId: task.id,
+                contextId: task.contextId,
+                message: update.status?.message,
+            });
             await service.tasks.update((await service.contexts.get(contextId)), cancellation);
         },
         onUpdate: async (update, task) => {
@@ -43,17 +48,34 @@ export function createStateMachine({ contextId, service, task: currentTask, over
                 logger.error(`onError[ctx:${contextId}]:`, new Error("task not found"));
                 return;
             }
-            const errorUpdate = FAILED_UPDATE(task.id, contextId, undefined, error instanceof Error ? error.message : String(error));
-            await service.tasks
-                .update((await service.contexts.get(contextId)), errorUpdate)
-                .catch((error) => {
+            const errorUpdate = describe.update.failed({
+                taskId: task.id,
+                contextId,
+                message: describe.message({
+                    messageId: "failed-update",
+                    parts: [
+                        {
+                            kind: "text",
+                            text: error instanceof Error ? error.message : String(error),
+                        },
+                    ],
+                }),
+            });
+            const context = await service.contexts.get(contextId);
+            if (!context) {
+                logger.error(`onError[ctx:${contextId}]:`, new Error("context not found"));
+                return;
+            }
+            await service.tasks.update(context, errorUpdate).catch((error) => {
                 //we capture errors thrown during error handling to ensure we trigger completion gracefully
-                logger.error(`onError[ctx:${contextId}]:`, error);
+                logger.error(`onError: task update error[ctx:${contextId}]:`, error);
             });
+            // we trigger completion here to ensure the context is cleaned up
+            await context.publisher.onComplete();
         },
         onComplete: async (task) => {
             assert(task.contextId === contextId, "context mismatch");
-            logger.info(`onComplete[ctx:${contextId}]:`, { taskId: task.id });
+            logger.info(`onComplete[ctx:${contextId}]: `, { taskId: task.id });
             await service.cancellations.delete(task.id);
             await service.connections.delete(task.contextId);
             await service.contexts.delete(task.contextId);

package/dist/services/a2a/handlers/artifact.d.ts

@@ -3,8 +3,5 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { A2A } from "../../../types/index.js";
-export declare function updateByIndex(append: boolean, artifacts: A2A.Artifact[], index: number, artifactUpdate: A2A.Artifact): {
-    artifacts: A2A.Artifact[];
-    replaced: boolean;
-};
-export declare function processArtifactUpdate(append: boolean, artifacts: A2A.Artifact[], artifactUpdate: A2A.Artifact): A2A.Artifact[];
+export declare function updateArtifact(_artifact: A2A.Artifact, update: A2A.TaskArtifactUpdateEvent): A2A.Artifact;
+export declare function upsertArtifact(artifacts: A2A.Artifact[], update: A2A.TaskArtifactUpdateEvent): A2A.Artifact[];

package/dist/services/a2a/handlers/artifact.js

@@ -2,38 +2,27 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-export function updateByIndex(append, artifacts, index, artifactUpdate) {
-    if (append) {
-        const existingArtifact = artifacts[index];
-        existingArtifact.parts.push(...artifactUpdate.parts);
-        if (artifactUpdate.metadata) {
-            existingArtifact.metadata = {
-                ...(existingArtifact.metadata || {}),
-                ...artifactUpdate.metadata,
-            };
-        }
-        if (artifactUpdate.description) {
-            existingArtifact.description = artifactUpdate.description;
-        }
-        if (artifactUpdate.name) {
-            existingArtifact.name = artifactUpdate.name;
-        }
-        artifacts[index] = existingArtifact;
-    }
-    else {
-        artifacts[index] = { ...artifactUpdate };
-    }
-    return { artifacts, replaced: true };
+export function updateArtifact(_artifact, update) {
+    if (!update.append)
+        return update.artifact;
+    const artifactUpdate = update.artifact;
+    const artifact = _artifact;
+    artifact.metadata = {
+        ...(artifact.metadata || {}),
+        ...artifactUpdate.metadata,
+    };
+    artifact.description = artifactUpdate.description;
+    artifact.name = artifactUpdate.name;
+    artifact.parts.push(...artifactUpdate.parts);
+    return artifact;
 }
-export function processArtifactUpdate(append, artifacts, artifactUpdate) {
-    const existingIndex = artifacts.findIndex((a) => a.artifactId === artifactUpdate.artifactId);
-    let replaced = false;
-    let newArtifacts = artifacts;
-    if (existingIndex !== -1) {
-        ({ artifacts: newArtifacts, replaced } = updateByIndex(append, artifacts, existingIndex, artifactUpdate));
-    }
-    if (!replaced) {
-        newArtifacts.push({ ...artifactUpdate });
+export function upsertArtifact(artifacts, update) {
+    const updateId = update.artifact.artifactId;
+    const index = artifacts.findIndex((a) => a.artifactId === updateId);
+    if (index === -1) {
+        artifacts.push({ ...update.artifact });
+        return artifacts;
     }
-    return newArtifacts;
+    artifacts[index] = updateArtifact(artifacts[index], update);
+    return artifacts;
 }

package/dist/services/a2a/handlers/cancel-task.js

@@ -16,7 +16,13 @@ export const cancelTask = async ({ id: taskId }, context) => {
     if (FINAL_STATES.includes(task.status.state)) {
         throw TASK_NOT_CANCELABLE("Task is in a final state: " + task.status.state);
     }
-    service.cancellations.set(taskId);
+    /**
+     * By triggering onCancel, we're guaranteed that:
+     *  - No further updates will be processed other than errors
+     *  - The task will be cancelled
+     *  - The task will be completed
+     *  - The cancellations will be cleaned up
+     */
     const cancelledTask = {
         ...task,
         status: {
@@ -24,10 +30,6 @@ export const cancelTask = async ({ id: taskId }, context) => {
             state: A2A.TaskState.canceled,
         },
     };
-    context.publisher?.on("complete", async () => {
-        await service.cancellations.delete(taskId);
-        await service.contexts.delete(context.contextId);
-    });
     await context.publisher.onCancel(cancelledTask);
     return cancelledTask;
 };

package/dist/services/a2a/handlers/resubscribe-task.d.ts

@@ -3,9 +3,17 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { A2A } from "../../../types/index.js";
-export declare const resubscribe: A2A.RequestHandler["resubscribe"];
+export declare const subscribeToTask: A2A.RequestHandler["resubscribe"];
+export type SubscribeToTaskHandler = typeof subscribeToTask;
+/**
+ * @deprecated Use SubscribeToTaskHandler instead
+ */
+export declare const resubscribe: (input: A2A.TaskIdParams, context?: A2A.Context, options?: A2A.ServiceOptions) => AsyncGenerator<A2A.Update>;
+/**
+ * @deprecated Use SubscribeToTaskHandler instead
+ */
 export type TaskResubscribeHandler = typeof resubscribe;
 /**
- * @deprecated Use ResubscribeTaskHandler instead
+ * @deprecated Use SubscribeToTaskHandler instead
  */
 export type ResubscribeTaskMethod = TaskResubscribeHandler;

package/dist/services/a2a/handlers/resubscribe-task.js

@@ -5,22 +5,22 @@
 import { A2A } from "../../../types/index.js";
 import { FINAL_STATES, INTERNAL_ERROR, TASK_NOT_FOUND } from "../../../utils/index.js";
 const flush = (task, stream) => {
-    if (task.artifacts && task.artifacts.length > 0) {
-        for (const artifact of task.artifacts) {
-            const artifactUpdate = {
-                kind: A2A.Kind["artifact-update"],
-                taskId: task.id,
-                contextId: task.contextId,
-                artifact,
-                lastChunk: task.artifacts.length === 1,
-                metadata: task.metadata,
-            };
-            stream.updates.push(artifactUpdate);
-            task.artifacts.shift();
-        }
+    if (!task.artifacts || task.artifacts.length === 0)
+        return;
+    for (const artifact of task.artifacts) {
+        const artifactUpdate = {
+            kind: A2A.Kind["artifact-update"],
+            taskId: task.id,
+            contextId: task.contextId,
+            artifact,
+            lastChunk: task.artifacts.length === 1,
+            metadata: task.metadata,
+        };
+        stream.updates.push(artifactUpdate);
+        task.artifacts.shift();
     }
 };
-export const resubscribe = async function* ({ id: taskId }, context) {
+export const subscribeToTask = async function* ({ id: taskId }, context) {
     if (!context) {
         throw INTERNAL_ERROR({ error: { message: "Context is required" } });
     }
@@ -33,9 +33,7 @@ export const resubscribe = async function* ({ id: taskId }, context) {
             contextId: context.contextId,
             context,
         }));
-    // since we already checked if the task exists
-    // then we dont care about the upsert in onStart
-    // so we can just push the update and continue
+    // onStart no longer inserts a new task, so we can safely push the update and continue
     context.publisher.on("start", async (_, task) => {
         stream.updates.push({
             kind: "status-update",
@@ -46,7 +44,8 @@ export const resubscribe = async function* ({ id: taskId }, context) {
             metadata: task.metadata,
         });
         if (FINAL_STATES.includes(task.status.state)) {
-            flush(task, stream);
+            /* We create a new task object to avoid mutating the original task */
+            flush({ ...task }, stream);
             await stream.kill();
         }
     });
@@ -54,3 +53,7 @@ export const resubscribe = async function* ({ id: taskId }, context) {
         service: service,
     });
 };
+/**
+ * @deprecated Use SubscribeToTaskHandler instead
+ */
+export const resubscribe = subscribeToTask;

package/dist/services/a2a/handlers/send-message.js

@@ -8,15 +8,10 @@ export const sendMessage = async ({ configuration }, context) => {
     if (!context) {
         throw INTERNAL_ERROR({ error: { message: "Context is required" } });
     }
-    context.publisher.on("complete", () => {
-        context.service.contexts.delete(context.contextId);
-    });
-    context.publisher.on("error", () => {
-        context.publisher.onComplete();
-    });
     const service = context.service;
+    let task;
     if (configuration?.blocking === false) {
-        const result = await Promise.race([
+        task = await Promise.race([
             service.execute({ engine: service.engine, context }).then(async () => {
                 return await context.getTask();
             }),
@@ -26,10 +21,11 @@ export const sendMessage = async ({ configuration }, context) => {
                 });
             }),
         ]);
-        return result;
     }
-    await service.execute({ engine: service.engine, context });
-    const task = await context.getTask();
+    else {
+        await service.execute({ engine: service.engine, context });
+        task = await context.getTask();
+    }
     task.history = getLatestHistory(task, configuration?.historyLength);
     return task;
 };

package/dist/services/a2a/handlers/stream-message.d.ts

@@ -3,8 +3,16 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { A2A } from "../../../types/index.js";
-export declare const streamMessage: A2A.RequestHandler["streamMessage"];
-export type StreamMessageHandler = typeof streamMessage;
+export declare const sendMessageStream: A2A.RequestHandler["streamMessage"];
+export type SendMessageStreamHandler = typeof sendMessageStream;
+/**
+ * @deprecated Use sendMessageStream instead
+ */
+export declare const streamMessage: (message: A2A.MessageSendParams, context?: A2A.Context, options?: A2A.ServiceOptions) => AsyncGenerator<A2A.Update>;
+/**
+ * @deprecated Use SendMessageStreamHandler instead
+ */
+export type StreamMessageHandler = SendMessageStreamHandler;
 /**
  * @deprecated Use StreamMessageHandler instead
  */

package/dist/services/a2a/handlers/stream-message.js

@@ -3,7 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { INTERNAL_ERROR } from "../../../utils/index.js";
-export const streamMessage = async function* (_, context) {
+export const sendMessageStream = async function* (_, context) {
     if (!context) {
         throw INTERNAL_ERROR({ error: { message: "Context is required" } });
     }
@@ -17,3 +17,7 @@ export const streamMessage = async function* (_, context) {
     });
     yield* stream.run({ service });
 };
+/**
+ * @deprecated Use sendMessageStream instead
+ */
+export const streamMessage = sendMessageStream;

package/dist/services/a2a/handlers/update.js

@@ -2,8 +2,9 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import { getCurrentTimestamp, validateSchema } from "../../../utils/index.js";
-import { processArtifactUpdate } from "./artifact.js";
+import { getCurrentTimestamp, formatJson } from "../../../utils/common/utils.js";
+import { validateSchema } from "../../../utils/common/schema-validation.js";
+import { upsertArtifact } from "./artifact.js";
 import { A2A } from "../../../types/index.js";
 import { logger } from "../../../config/index.js";
 const isMessageInHistory = (task, message) => {
@@ -17,9 +18,13 @@ const updateHistory = (task, updateMessage) => {
 export const handleMessageUpdate = async ({ task, update, }) => {
     const validated = await validateSchema(A2A.MessageSchema, update);
     if (validated.taskId && task.id !== validated.taskId) {
-        throw new Error(`updateMessage: Invalid task id: ${validated.taskId}`, {
-            cause: validated,
-        });
+        throw new Error(`updateMessage: Invalid task id: ${validated.taskId} ${formatJson({
+            cause: {
+                validated,
+                actual: task.id,
+                task,
+            },
+        })}`);
     }
     updateHistory(task, validated);
     return task;
@@ -59,7 +64,7 @@ export const handleArtifactUpdate = async ({ task, update }) => {
     else {
         validated.taskId = task.id;
     }
-    task.artifacts = processArtifactUpdate(update.append ?? false, task.artifacts ?? [], update.artifact);
+    task.artifacts = upsertArtifact(task.artifacts ?? [], validated);
     return task;
 };
 // The onus is now on the caller to handle errors when processing updates

package/dist/services/a2a/helpers/content.d.ts

@@ -8,4 +8,8 @@ import { A2A } from "../../../types/index.js";
  * @param input - The input event.
  * @returns The content of the input event.
  */
-export declare function getContent(input: A2A.Update): string | undefined;
+export declare function extractTextContent(input: A2A.Update): string | undefined;
+/**
+ * @deprecated Use extractTextContent instead.
+ */
+export declare const getContent: typeof extractTextContent;

package/dist/services/a2a/helpers/content.js

@@ -8,7 +8,7 @@ import { getParts } from "./part.js";
  * @param input - The input event.
  * @returns The content of the input event.
  */
-export function getContent(input) {
+export function extractTextContent(input) {
     const parts = getParts(input?.parts ??
         input?.status?.message?.parts ??
         input?.status?.message?.parts ??
@@ -20,3 +20,7 @@ export function getContent(input) {
         parts.data.map((data) => JSON.stringify(data)).join("\n") ??
         undefined);
 }
+/**
+ * @deprecated Use extractTextContent instead.
+ */
+export const getContent = extractTextContent;

package/dist/services/a2a/helpers/index.d.ts

@@ -1,6 +1,6 @@
 export * from "./part.js";
 export * from "./content.js";
-export * from "./agentcard-builder.js";
-export * from "./message-builder.js";
+export { AgentCardBuilder } from "../../../create/agentcard-builder.js";
+export { MessageBuilder, MessageSendConfigurationBuilder, } from "../../../create/message-builder.js";
 export * from "./history.js";
 export * from "./references.js";

package/dist/services/a2a/helpers/index.js

@@ -1,6 +1,6 @@
 export * from "./part.js";
 export * from "./content.js";
-export * from "./agentcard-builder.js";
-export * from "./message-builder.js";
+export { AgentCardBuilder } from "../../../create/agentcard-builder.js";
+export { MessageBuilder, MessageSendConfigurationBuilder, } from "../../../create/message-builder.js";
 export * from "./history.js";
 export * from "./references.js";

package/dist/services/a2a/index.d.ts

@@ -1,4 +1,4 @@
-export * from "./factory/builder.js";
+export * from "../../create/create.js";
 export * from "./factory/service.js";
 export * from "./managers.js";
 export * from "./messenger.js";

package/dist/services/a2a/index.js

@@ -1,4 +1,4 @@
-export * from "./factory/builder.js";
+export * from "../../create/create.js";
 export * from "./factory/service.js";
 export * from "./managers.js";
 export * from "./messenger.js";