@artinet/sdk 0.5.18 → 0.6.0-preview.2

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

@@ -2,11 +2,11 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import { A2AService } from "../service.js";
-import { ContextManager, ConnectionManager, CancellationManager, TaskManager, } from "../managers/index.js";
-import { createMethods } from "./method.js";
-import { createAgentCard } from "../helpers/agentcard-builder.js";
+import { createHandler } from "./handler.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 A2AService(createAgentCard(params.agentCard), params.engine, params.contexts ?? new ContextManager(), params.connections ?? new ConnectionManager(), params.cancellations ?? new CancellationManager(), params.tasks ?? new TaskManager(), createMethods(params.methods), params.events, params.enforceParamValidation ?? false);
+    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

@@ -0,0 +1,11 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2A } from "../../../types/index.js";
+export declare function createStateMachine({ contextId, service, task: currentTask, overrides, }: {
+    contextId: string;
+    service: A2A.Service;
+    task: A2A.Task;
+    overrides?: Partial<Omit<A2A.EventConsumer, "contextId">>;
+}): A2A.EventPublisher;

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

@@ -0,0 +1,88 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { StateMachine } from "../state-machine.js";
+import { logger } from "../../../config/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 = {
+        contextId: contextId,
+        onStart: async (context) => {
+            assert(context.contextId === contextId, "context mismatch");
+            logger.info(`onStart[ctx:${contextId}]:`, { taskId: context.taskId });
+            await service.connections.set(context.contextId);
+            const task = await service.tasks.get(context.taskId);
+            // we now expect the task to be created by the service
+            // so if it's not found we throw an error
+            if (!task) {
+                throw TASK_NOT_FOUND({ taskId: context.taskId, contextId: contextId });
+            }
+            return task;
+        },
+        onCancel: async (update, task) => {
+            logger.info(`onCancel[ctx:${contextId}]:`, "cancellation triggered");
+            logger.debug(`onCancel[ctx:${contextId}]:`, "arguments", update, task);
+            await service.cancellations.set(task.id);
+            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) => {
+            logger.info(`onUpdate[ctx:${contextId}]:`);
+            logger.debug(`onUpdate[ctx:${contextId}]:`, { taskId: task.id });
+            if (await service.cancellations.has(task.id)) {
+                logger.warn(`onUpdate[ctx:${contextId}]:`, { taskId: task.id }, "task is cancelled, no longer processing updates");
+                return task;
+            }
+            return await service.tasks.update((await service.contexts.get(contextId)), update);
+        },
+        onError: async (error, task) => {
+            logger.error(`onError[ctx:${contextId}]:`, error);
+            if (!task) {
+                logger.error(`onError[ctx:${contextId}]:`, new Error("task not found"));
+                return;
+            }
+            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: 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 });
+            await service.cancellations.delete(task.id);
+            await service.connections.delete(task.contextId);
+            await service.contexts.delete(task.contextId);
+        },
+    };
+    return new StateMachine(contextId, {
+        ...handler,
+        ...overrides,
+    }, currentTask);
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2A } from "../../../types/index.js";
+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

@@ -0,0 +1,28 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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 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;
+    }
+    artifacts[index] = updateArtifact(artifacts[index], update);
+    return artifacts;
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2A } from "../../../types/index.js";
+export declare const cancelTask: A2A.RequestHandler["cancelTask"];
+export type CancelTaskHandler = typeof cancelTask;
+/**
+ * @deprecated Use CancelTaskHandler instead
+ */
+export type CancelTaskMethod = CancelTaskHandler;

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

@@ -0,0 +1,35 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2A } from "../../../types/index.js";
+import { FINAL_STATES, TASK_NOT_FOUND, TASK_NOT_CANCELABLE, INTERNAL_ERROR, } from "../../../utils/index.js";
+export const cancelTask = async ({ id: taskId }, context) => {
+    if (!context) {
+        throw INTERNAL_ERROR({ error: { message: "Context is required" } });
+    }
+    const service = context.service;
+    const task = await service.tasks.get(taskId);
+    if (!task) {
+        throw TASK_NOT_FOUND({ taskId });
+    }
+    if (FINAL_STATES.includes(task.status.state)) {
+        throw TASK_NOT_CANCELABLE("Task is in a final state: " + task.status.state);
+    }
+    /**
+     * 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: {
+            ...task.status,
+            state: A2A.TaskState.canceled,
+        },
+    };
+    await context.publisher.onCancel(cancelledTask);
+    return cancelledTask;
+};

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

@@ -0,0 +1,11 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2A } from "../../../types/index.js";
+export declare const getTask: A2A.RequestHandler["getTask"];
+export type GetTaskHandler = typeof getTask;
+/**
+ * @deprecated Use GetTaskHandler instead
+ */
+export type GetTaskMethod = GetTaskHandler;

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

@@ -0,0 +1,13 @@
+import { TASK_NOT_FOUND, INTERNAL_ERROR } from "../../../utils/index.js";
+import { getLatestHistory } from "../helpers/index.js";
+export const getTask = async ({ id: taskId, historyLength }, context) => {
+    if (!context) {
+        throw INTERNAL_ERROR({ error: { message: "Context is required" } });
+    }
+    const task = await context.service.tasks.get(taskId);
+    if (!task) {
+        throw TASK_NOT_FOUND({ taskId });
+    }
+    task.history = getLatestHistory(task, historyLength);
+    return task;
+};

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

@@ -0,0 +1,19 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2A } from "../../../types/index.js";
+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 SubscribeToTaskHandler instead
+ */
+export type ResubscribeTaskMethod = TaskResubscribeHandler;

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

@@ -0,0 +1,59 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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)
+        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 subscribeToTask = async function* ({ id: taskId }, context) {
+    if (!context) {
+        throw INTERNAL_ERROR({ error: { message: "Context is required" } });
+    }
+    const service = context.service;
+    if (!(await service.tasks.has(taskId))) {
+        throw TASK_NOT_FOUND({ taskId });
+    }
+    const stream = (await service.streams.get(context.contextId)) ??
+        (await service.streams.create({
+            contextId: context.contextId,
+            context,
+        }));
+    // 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",
+            taskId: task.id,
+            contextId: task.contextId,
+            status: task.status,
+            final: false,
+            metadata: task.metadata,
+        });
+        if (FINAL_STATES.includes(task.status.state)) {
+            /* We create a new task object to avoid mutating the original task */
+            flush({ ...task }, stream);
+            await stream.kill();
+        }
+    });
+    yield* stream.run({
+        service: service,
+    });
+};
+/**
+ * @deprecated Use SubscribeToTaskHandler instead
+ */
+export const resubscribe = subscribeToTask;

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

@@ -0,0 +1,11 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2A } from "../../../types/index.js";
+export declare const sendMessage: A2A.RequestHandler["sendMessage"];
+export type SendMessageHandler = typeof sendMessage;
+/**
+ * @deprecated Use SendMessageHandler instead
+ */
+export type SendMessageMethod = SendMessageHandler;

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

@@ -0,0 +1,31 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { getLatestHistory } from "../helpers/index.js";
+import { INTERNAL_ERROR } from "../../../utils/index.js";
+export const sendMessage = async ({ configuration }, context) => {
+    if (!context) {
+        throw INTERNAL_ERROR({ error: { message: "Context is required" } });
+    }
+    const service = context.service;
+    let task;
+    if (configuration?.blocking === false) {
+        task = await Promise.race([
+            service.execute({ engine: service.engine, context }).then(async () => {
+                return await context.getTask();
+            }),
+            new Promise((resolve) => {
+                context.publisher.on("start", (_, task) => {
+                    resolve(task);
+                });
+            }),
+        ]);
+    }
+    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

@@ -0,0 +1,19 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2A } from "../../../types/index.js";
+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
+ */
+export type StreamMessageMethod = StreamMessageHandler;

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

@@ -0,0 +1,23 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { INTERNAL_ERROR } from "../../../utils/index.js";
+export const sendMessageStream = async function* (_, context) {
+    if (!context) {
+        throw INTERNAL_ERROR({ error: { message: "Context is required" } });
+    }
+    const service = context.service;
+    if (await service.streams.has(context.contextId)) {
+        throw INTERNAL_ERROR({ error: { message: "Stream already exists" } });
+    }
+    const stream = await service.streams.create({
+        contextId: context.contextId,
+        context,
+    });
+    yield* stream.run({ service });
+};
+/**
+ * @deprecated Use sendMessageStream instead
+ */
+export const streamMessage = sendMessageStream;

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

@@ -0,0 +1,17 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2A } from "../../../types/index.js";
+export interface UpdateParams<Update extends A2A.Update = A2A.Update> {
+    context: A2A.Context;
+    task: A2A.Task;
+    update: Update;
+}
+type Updater<Update extends A2A.Update> = (props: UpdateParams<Update>) => Promise<A2A.Task>;
+export declare const handleMessageUpdate: Updater<A2A.Message>;
+export declare const handleTaskUpdate: Updater<A2A.Task>;
+export declare const handleStatusUpdate: Updater<A2A.TaskStatusUpdateEvent>;
+export declare const handleArtifactUpdate: Updater<A2A.TaskArtifactUpdateEvent>;
+export declare const handleUpdate: Updater<A2A.Update>;
+export {};

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

@@ -0,0 +1,119 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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) => {
+    return task.history?.find((msg) => msg.messageId === message.messageId);
+};
+const updateHistory = (task, updateMessage) => {
+    if (!isMessageInHistory(task, updateMessage)) {
+        task.history = [...(task.history ?? []), 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} ${formatJson({
+            cause: {
+                validated,
+                actual: task.id,
+                task,
+            },
+        })}`);
+    }
+    updateHistory(task, validated);
+    return task;
+};
+export const handleTaskUpdate = async ({ context, task, update, }) => {
+    const validated = await validateSchema(A2A.TaskSchema, update);
+    if (task.id !== validated.id) {
+        throw new Error(`updateTask: Invalid task id: ${validated.id}`, {
+            cause: validated,
+        });
+    }
+    task = { ...task, ...validated };
+    if (context.userMessage) {
+        updateHistory(task, context.userMessage);
+    }
+    return task;
+};
+export const handleStatusUpdate = async ({ task, update, }) => {
+    const validated = await validateSchema(A2A.TaskStatusUpdateEventSchema, update);
+    if (validated.taskId && task.id !== validated.taskId) {
+        throw new Error(`updateTaskStatusUpdate: Invalid task id: ${validated.taskId}`, { cause: validated });
+    }
+    task.status = validated.status;
+    task.status.timestamp = getCurrentTimestamp();
+    if (validated.status.message) {
+        updateHistory(task, validated.status.message);
+    }
+    return task;
+};
+export const handleArtifactUpdate = async ({ task, update }) => {
+    const validated = await validateSchema(A2A.TaskArtifactUpdateEventSchema, update);
+    if (validated.taskId && task.id !== validated.taskId) {
+        throw new Error(`updateTaskArtifactUpdate: Invalid task id: ${validated.taskId}`, {
+            cause: validated,
+        });
+    }
+    else {
+        validated.taskId = task.id;
+    }
+    task.artifacts = upsertArtifact(task.artifacts ?? [], validated);
+    return task;
+};
+// The onus is now on the caller to handle errors when processing updates
+// and to decide whether the updated task should be saved or not
+export const handleUpdate = async ({ context, task, update, }) => {
+    if (!update || !update.kind) {
+        throw new Error("updateState: Invalid update", { cause: update });
+    }
+    logger.debug(`handleUpdate:`, {
+        contextId: context?.contextId,
+        taskId: task?.id,
+    });
+    task = await validateSchema(A2A.TaskSchema, task);
+    if (!context || !context.contextId) {
+        throw new Error("updateState: Invalid context", { cause: context });
+    }
+    switch (update.kind) {
+        case A2A.Kind.message: {
+            return handleMessageUpdate({
+                context,
+                task,
+                update,
+            });
+        }
+        case A2A.Kind.task: {
+            return handleTaskUpdate({
+                context,
+                task,
+                update,
+            });
+        }
+        case A2A.Kind["status-update"]: {
+            return handleStatusUpdate({
+                context,
+                task,
+                update,
+            });
+        }
+        case A2A.Kind["artifact-update"]: {
+            return handleArtifactUpdate({
+                context,
+                task,
+                update,
+            });
+        }
+        default: {
+            throw new Error(`updateState: Invalid update kind: {"kind": "unknown"}`, {
+                cause: update,
+            });
+        }
+    }
+};

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

@@ -2,10 +2,14 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import { UpdateEvent } from "../../../types/index.js";
+import { A2A } from "../../../types/index.js";
 /**
  * Extracts the content of an agent response.
  * @param input - The input event.
  * @returns The content of the input event.
  */
-export declare function getContent(input: UpdateEvent): 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

@@ -1,10 +1,14 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
 import { getParts } from "./part.js";
 /**
  * Extracts the content of an agent response.
  * @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 ??
@@ -16,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/history.d.ts

@@ -1,2 +1,6 @@
-import { Message, Task } from "../../../types/index.js";
-export declare function getLatestHistory(task: Task, length?: number): Message[];
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2A } from "../../../types/index.js";
+export declare function getLatestHistory(task: A2A.Task, length?: number): A2A.Message[];

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

@@ -1,3 +1,7 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
 export function getLatestHistory(task, length) {
     return length ? task.history?.slice(-length) ?? [] : task.history ?? [];
 }

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

@@ -1,6 +1,6 @@
 export * from "./part.js";
 export * from "./content.js";
-export * from "./message-builder.js";
-export * from "./agentcard-builder.js";
+export { AgentCardBuilder } from "../../../create/agentcard-builder.js";
+export { MessageBuilder, MessageSendConfigurationBuilder, } from "../../../create/message-builder.js";
 export * from "./history.js";
-export * from "../../../utils/common/schema-validation.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 "./message-builder.js";
-export * from "./agentcard-builder.js";
+export { AgentCardBuilder } from "../../../create/agentcard-builder.js";
+export { MessageBuilder, MessageSendConfigurationBuilder, } from "../../../create/message-builder.js";
 export * from "./history.js";
-export * from "../../../utils/common/schema-validation.js";
+export * from "./references.js";

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

@@ -2,7 +2,7 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import { Part, TextPart, FilePart, DataPart, Message } from "../../../types/schemas/a2a/index.js";
+import { A2A } from "../../../types/index.js";
 /**
  * Extracts and aggregates the text, file, and data contents from an array of Part objects.
  *
@@ -16,10 +16,10 @@ import { Part, TextPart, FilePart, DataPart, Message } from "../../../types/sche
  * This utility is used to normalize and access the payloads of message parts
  * in a structured way for downstream processing.
  */
-export declare const getParts: (parts: Part[]) => {
-    text: TextPart["text"];
-    file: FilePart["file"][];
-    data: DataPart["data"][];
+export declare const getParts: (parts: A2A.Part[]) => {
+    text: A2A.TextPart["text"];
+    file: A2A.FilePart["file"][];
+    data: A2A.DataPart["data"][];
 };
 /**
  * Extracts and aggregates the text, file, and data payloads from a Message's parts array.
@@ -41,8 +41,8 @@ export declare const getParts: (parts: Part[]) => {
  * console.log(payload.file); // [<file1>, <file2>]
  * console.log(payload.data); // [<data1>, <data2>]
  */
-export declare const getPayload: (message: Message) => {
-    text: TextPart["text"];
-    file: FilePart["file"][];
-    data: DataPart["data"][];
+export declare const getPayload: (message: A2A.Message) => {
+    text: A2A.TextPart["text"];
+    file: A2A.FilePart["file"][];
+    data: A2A.DataPart["data"][];
 };