@artinet/sdk 0.5.18 → 0.6.0-preview.2

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

@@ -0,0 +1,6 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2A } from "../../../types/index.js";
+export declare function getReferences(tasks: A2A.Tasks, referenceTaskIds?: string[]): Promise<A2A.Task[]>;

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

@@ -0,0 +1,22 @@
+import { logger } from "../../../config/index.js";
+export async function getReferences(tasks, referenceTaskIds) {
+    if (!referenceTaskIds) {
+        return [];
+    }
+    try {
+        logger.debug("getReferences: getting references", { referenceTaskIds });
+        const references = await Promise.all(referenceTaskIds.map((referenceTaskId) => {
+            return tasks.get(referenceTaskId).catch((error) => {
+                logger.error("getReferences: failed to load reference", error);
+                return undefined;
+            });
+        }));
+        return references
+            .filter((reference) => reference !== undefined)
+            .map((reference) => reference);
+    }
+    catch (error) {
+        logger.error("getReferences: failed to load references", error instanceof Error ? error : new Error(error));
+        return [];
+    }
+}

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

@@ -1,6 +1,10 @@
-export * from "./factory/index.js";
-export * from "./helpers/index.js";
-export * from "./managers/index.js";
-export * from "./methods/index.js";
-export * from "./state/index.js";
+export * from "../../create/create.js";
+export * from "./factory/service.js";
+export * from "./managers.js";
+export * from "./messenger.js";
 export * from "./service.js";
+export type { Service as Agent } from "./service.js";
+export * from "./state-machine.js";
+export * from "./streams.js";
+export * from "./helpers/index.js";
+export * from "./handlers/index.js";

package/dist/services/a2a/index.js

@@ -1,6 +1,9 @@
-export * from "./factory/index.js";
-export * from "./helpers/index.js";
-export * from "./managers/index.js";
-export * from "./methods/index.js";
-export * from "./state/index.js";
+export * from "../../create/create.js";
+export * from "./factory/service.js";
+export * from "./managers.js";
+export * from "./messenger.js";
 export * from "./service.js";
+export * from "./state-machine.js";
+export * from "./streams.js";
+export * from "./helpers/index.js";
+export * from "./handlers/index.js";

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

@@ -0,0 +1,23 @@
+import { core, A2A } from "../../types/index.js";
+import { Manager } from "../core/manager.js";
+export declare class Cancellations extends Manager<void> implements A2A.Cancellations {
+    constructor(cancellations?: Map<string, void>);
+}
+export declare class Connections extends Manager<void> implements A2A.Connections {
+    constructor(connections?: Map<string, void>);
+}
+export declare class Contexts extends Manager<A2A.Context> implements A2A.Contexts {
+    constructor(contexts?: Map<string, A2A.Context>);
+    create(params: A2A.ContextParams): Promise<A2A.Context>;
+}
+export declare class Streams extends Manager<A2A.Stream> implements A2A.Streams {
+    constructor(streams?: Map<string, A2A.Stream>);
+    create({ contextId, context, updates, }: core.Optional<A2A.Stream> & {
+        context: A2A.Context;
+    }): Promise<A2A.Stream>;
+}
+export declare class Tasks extends Manager<A2A.Task> implements A2A.Tasks {
+    constructor(tasks?: Map<string, A2A.Task>);
+    update(context: A2A.Context, update: A2A.Update): Promise<A2A.Task>;
+    create(params: Partial<A2A.Task>): Promise<A2A.Task>;
+}

package/dist/services/a2a/managers.js

@@ -0,0 +1,101 @@
+import { A2A } from "../../types/index.js";
+import { Stream } from "./streams.js";
+import { createBaseContext, createContext, } from "./factory/context.js";
+import { v4 } from "uuid";
+import { getCurrentTimestamp } from "../../utils/index.js";
+import { handleUpdate } from "./handlers/update.js";
+import { Manager } from "../core/manager.js";
+import { logger } from "../../config/index.js";
+export class Cancellations extends Manager {
+    constructor(cancellations = new Map()) {
+        super(cancellations, false);
+    }
+}
+export class Connections extends Manager {
+    constructor(connections = new Map()) {
+        super(connections, false);
+    }
+}
+export class Contexts extends Manager {
+    constructor(contexts = new Map()) {
+        super(contexts, true);
+    }
+    async create(params) {
+        if (await this.has(params.contextId)) {
+            logger.warn("Contexts[create]: context already exists", {
+                contextId: params.contextId,
+            });
+            return (await this.get(params.contextId));
+        }
+        logger.info(`Contexts[create]: creating context`, {
+            contextId: params.contextId,
+        });
+        logger.debug(`Contexts[create]: params`, { params });
+        const baseContext = createBaseContext(params);
+        //todo: consider allowing ContextParams to cascade
+        const context = {
+            ...createContext({
+                baseContext: baseContext,
+                taskId: params.task.id,
+                messenger: params.messenger,
+                references: params.references,
+                extensions: params.extensions,
+            }),
+        };
+        logger.debug(`Contexts[create]: context created`, context.contextId);
+        await this.set(context.contextId, context);
+        return context;
+    }
+}
+export class Streams extends Manager {
+    constructor(streams = new Map()) {
+        super(streams, true);
+    }
+    async create({ contextId, context, updates, }) {
+        if (await this.has(contextId)) {
+            throw new Error("Stream already exists");
+        }
+        await this.set(contextId, new Stream(contextId, context, updates));
+        return (await this.get(contextId));
+    }
+}
+export class Tasks extends Manager {
+    constructor(tasks = new Map()) {
+        super(tasks, true);
+    }
+    async update(context, update) {
+        logger.info(`Tasks[update]: updating task`, { taskId: context.taskId });
+        logger.debug(`Tasks[update]: update`, { update });
+        logger.debug(`Tasks[update]: context`, { context });
+        logger.debug(`Tasks[update]: context task`, {
+            task: await context.getTask(),
+        });
+        const task = await handleUpdate({
+            context,
+            task: await context.getTask(),
+            update,
+        });
+        logger.debug(`Tasks[update]: task`, task);
+        await this.set(task.id, task);
+        return task;
+    }
+    async create(params) {
+        if (params.id && (await this.has(params.id))) {
+            return (await this.get(params.id));
+        }
+        logger.info(`Tasks[create]: creating task`, { id: params.id });
+        const task = {
+            ...params,
+            id: params.id ?? v4(),
+            contextId: params.contextId ?? v4(),
+            kind: "task",
+            status: {
+                state: A2A.TaskState.submitted,
+                timestamp: getCurrentTimestamp(),
+            },
+        };
+        logger.debug(`Tasks[create]:`, { taskId: task.id });
+        await this.set(task.id, task);
+        return task;
+    }
+}

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

@@ -0,0 +1,35 @@
+import { A2A } from "../../types/index.js";
+import { EventEmitter } from "events";
+export declare class Messenger extends EventEmitter<A2A.MessageMap> implements A2A.MessageProducer, A2A.MessageConsumer {
+    private _message;
+    private _messages;
+    private resolvers;
+    private done;
+    /**
+     * @param message - The initial message to send
+     * @note The initial message is tied to the messenger and cannot be changed
+     */
+    constructor(message: A2A.MessageSendParams);
+    /**
+     * @returns True if the channel is open
+     */
+    get isOpen(): boolean;
+    /**
+     * @returns The list of commands
+     */
+    get message(): A2A.MessageSendParams;
+    /**
+     * @returns The current message
+     */
+    get messages(): A2A.MessageSendParams[];
+    /**
+     * @returns The command channel as an async iterable
+     */
+    [Symbol.asyncIterator](): AsyncIterableIterator<A2A.MessageSendParams, A2A.MessageSendParams, A2A.MessageSendParams | undefined>;
+    valueOf(): A2A.MessageSendParams;
+    send(message: A2A.MessageSendParams): Promise<void>;
+    close(): Promise<void>;
+    next(): Promise<IteratorResult<A2A.MessageSendParams>>;
+    return(value: A2A.MessageSendParams): Promise<IteratorResult<A2A.MessageSendParams>>;
+    static create(messageParams: A2A.MessageSendParams): A2A.MessageConsumerProxy;
+}

package/dist/services/{core/managers/command.js → a2a/messenger.js}

@@ -1,21 +1,17 @@
-/**
- * Copyright 2025 The Artinet Project
- * SPDX-License-Identifier: Apache-2.0
- */
 import { EventEmitter } from "events";
-export class CommandChannel extends EventEmitter {
-    _command;
-    commands = [];
+export class Messenger extends EventEmitter {
+    _message;
+    _messages = [];
     resolvers = [];
     done = false;
     /**
-     * @param command - The initial command to send
-     * @note The initial command is tied to the channel and cannot be changed
+     * @param message - The initial message to send
+     * @note The initial message is tied to the messenger and cannot be changed
      */
-    constructor(_command) {
+    constructor(message) {
         super();
-        this._command = _command;
-        this.commands.push(_command);
+        this._message = message;
+        this._messages.push(message);
     }
     /**
      * @returns True if the channel is open
@@ -26,14 +22,14 @@ export class CommandChannel extends EventEmitter {
     /**
      * @returns The list of commands
      */
-    get commandList() {
-        return this.commands;
+    get message() {
+        return this._messages[0] ?? this._message;
     }
     /**
-     * @returns The current command
+     * @returns The current message
      */
-    get command() {
-        return this.commands[0] ?? this._command;
+    get messages() {
+        return this._messages;
     }
     /**
      * @returns The command channel as an async iterable
@@ -42,30 +38,30 @@ export class CommandChannel extends EventEmitter {
         return this;
     }
     valueOf() {
-        return this.command;
+        return this.message;
     }
-    send(command) {
+    async send(message) {
         if (this.done) {
-            throw new Error("Command channel is closed");
+            throw new Error("Messenger is closed");
         }
         const resolver = this.resolvers.shift();
         if (resolver) {
-            resolver({ value: command, done: false });
+            resolver({ value: message, done: false });
         }
         else {
-            this.commands.push(command);
+            this._messages.push(message);
         }
-        this.emit("send", command);
+        this.emit("message", message);
     }
-    close() {
+    async close() {
         this.done = true;
         this.resolvers.forEach((resolver) => resolver({ value: undefined, done: true }));
         this.resolvers = [];
         this.emit("close");
     }
     async next() {
-        if (this.commands.length)
-            return Promise.resolve({ value: this.commands.shift(), done: false });
+        if (this._messages.length)
+            return Promise.resolve({ value: this._messages.shift(), done: false });
         if (this.done)
             return Promise.resolve({ value: undefined, done: true });
         return new Promise((resolve) => {
@@ -74,15 +70,15 @@ export class CommandChannel extends EventEmitter {
     }
     return(value) {
         this.close();
-        this.commands = [];
+        this._messages = [];
         return Promise.resolve({ value, done: true });
     }
-    static create(command) {
-        const instance = new CommandChannel(command);
+    static create(messageParams) {
+        const instance = new Messenger(messageParams);
         return new Proxy(instance, {
             get(target, prop, _) {
-                if (prop in target.command) {
-                    return target.command[prop];
+                if (prop in target.message) {
+                    return target.message[prop];
                 }
                 else if (prop in target) {
                     return target[prop];