@microsoft/teams.a2a 2.0.0-preview.10

package/dist/client/agent-client.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentClient = exports.AgentCardNotFoundError = void 0;
+const teams_common_1 = require("@microsoft/teams.common");
+const schema_1 = require("../common/schema");
+const uuid_1 = require("../common/uuid");
+/**
+ * Error class for JSON-RPC errors, matching the old-client-impl behavior.
+ */
+class RpcError extends Error {
+    code;
+    data;
+    constructor(code, message, data) {
+        super(message);
+        this.name = 'RpcError';
+        this.code = code;
+        this.data = data;
+    }
+}
+class AgentCardNotFoundError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'AgentCardNotFoundError';
+    }
+}
+exports.AgentCardNotFoundError = AgentCardNotFoundError;
+/**
+ * A2AAgentClient can be constructed with either a baseUrl (to fetch the agent card) or a direct AgentCard object.
+ * Optionally, a custom fetch implementation can be provided.
+ */
+class AgentClient {
+    _agentCard;
+    _baseUrl;
+    get baseUrl() {
+        return this._baseUrl;
+    }
+    _a2aUrl;
+    get a2aUrl() {
+        return this._a2aUrl;
+    }
+    _fetchImpl;
+    _logger;
+    constructor(options) {
+        this._baseUrl = options.baseUrl;
+        this._agentCard = options.agentCard ?? null;
+        this._fetchImpl = options.fetchImpl ?? fetch;
+        this._a2aUrl = this._agentCard?.url ?? null;
+        this._logger = options.logger?.child('A2AAgentClient') ?? new teams_common_1.ConsoleLogger('A2AAgentClient');
+    }
+    /**
+     * Returns the agent card, fetching it if necessary.
+     */
+    async agentCard() {
+        if (this._agentCard) {
+            return this._agentCard;
+        }
+        // Fetch from /.well-known/agent.json at the same origin as baseUrl
+        const base = new URL(this._baseUrl).origin;
+        const cardUrl = `${base}/.well-known/agent.json`;
+        this._logger.debug(`Fetching agent card from ${cardUrl}`);
+        try {
+            const response = await this._fetchImpl(cardUrl, { method: 'GET', headers: { Accept: 'application/json' } });
+            if (!response.ok) {
+                this._logger.error(`Failed to fetch agent card: ${response.status} ${response.statusText}`);
+                throw new AgentCardNotFoundError(`Failed to fetch agent card: ${response.status} ${response.statusText}`);
+            }
+            // TODO: validate using something like zod?
+            const card = (await response.json());
+            this._logger.debug(`Agent card fetched successfully from ${cardUrl}`, card);
+            this._agentCard = card;
+            this._a2aUrl = card.url;
+            return card;
+        }
+        catch (error) {
+            this._logger.error(`Failed to fetch agent card: ${error}`);
+            throw new AgentCardNotFoundError(`Failed to fetch agent card: ${error}`);
+        }
+    }
+    /**
+     * Sends a task request to the agent (non-streaming).
+     * @param params The parameters for the tasks/send method.
+     * @returns A promise resolving to the Task object or null.
+     */
+    async sendTask(params) {
+        const httpResponse = await this._makeHttpRequest('tasks/send', params);
+        return this._handleJsonResponse(httpResponse, 'tasks/send');
+    }
+    /**
+     * Internal helper to make JSON-RPC HTTP requests.
+     */
+    async _makeHttpRequest(method, params, acceptHeader = 'application/json') {
+        if (!this._a2aUrl) {
+            throw new Error('Agent URL is not set. Please call agentCard() to fetch the agent card.');
+        }
+        const requestId = (0, uuid_1.generateRequestId)();
+        const requestBody = {
+            jsonrpc: '2.0',
+            id: requestId,
+            method,
+            params,
+        };
+        try {
+            this._logger.debug(`Making JSON-RPC request to ${this._a2aUrl}:`, requestBody);
+            const response = await this._fetchImpl(this._a2aUrl, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Accept: acceptHeader,
+                },
+                body: JSON.stringify(requestBody),
+            });
+            return response;
+        }
+        catch (networkError) {
+            this._logger.error('Network error while making JSON-RPC request:', networkError);
+            throw new RpcError(schema_1.ErrorCodeInternalError, `Network error: ${networkError instanceof Error ? networkError.message : String(networkError)}`, networkError);
+        }
+    }
+    /**
+     * Handles standard JSON-RPC responses (non-streaming).
+     */
+    async _handleJsonResponse(response, expectedMethod) {
+        // Return type is now the 'result' property of Res
+        let responseBody = null;
+        try {
+            if (!response.ok) {
+                this._logger.error(`HTTP error ${response.status}: ${response.statusText}`);
+                // Attempt to read body even for non-ok responses for potential JSON errors
+                responseBody = await response.text();
+                let errorData = null;
+                try {
+                    // Try parsing as JSON RPC Error response
+                    const parsedError = JSON.parse(responseBody);
+                    if (parsedError.error) {
+                        errorData = parsedError.error;
+                        throw new RpcError(errorData.code, errorData.message, errorData.data);
+                    }
+                }
+                catch (parseError) {
+                    // Ignore parsing error, fall through to generic HTTP error
+                }
+                // If not a JSON RPC error, throw generic HTTP error
+                throw new Error(`HTTP error ${response.status}: ${response.statusText}${responseBody ? ` - ${responseBody}` : ''}`);
+            }
+            // Read and parse the successful JSON response
+            responseBody = await response.text();
+            // Parse as the specific JSONRPCResponse type Res
+            const jsonResponse = JSON.parse(responseBody);
+            // Basic validation of the JSON-RPC response structure
+            if (typeof jsonResponse !== 'object' ||
+                jsonResponse === null ||
+                jsonResponse.jsonrpc !== '2.0') {
+                throw new RpcError(schema_1.ErrorCodeInternalError, 'Invalid JSON-RPC response structure received from server.');
+            }
+            // Check for application-level errors within the JSON-RPC response
+            if (jsonResponse.error) {
+                throw new RpcError(jsonResponse.error.code, jsonResponse.error.message, jsonResponse.error.data);
+            }
+            // Optional: Validate response ID matches request ID if needed (requires passing request ID down)
+            // Extract and return only the result payload
+            return jsonResponse.result;
+        }
+        catch (error) {
+            this._logger.error(`Error processing RPC response for method ${expectedMethod || 'unknown'}:`, error, responseBody ? `\nResponse Body: ${responseBody}` : '');
+            // Re-throw RpcError instances directly, wrap others
+            if (error instanceof RpcError) {
+                throw error;
+            }
+            else {
+                throw new RpcError(schema_1.ErrorCodeInternalError, // Use literal value for ErrorCodeInternalError
+                `Failed to process response: ${error instanceof Error ? error.message : String(error)}`, error);
+            }
+        }
+    }
+}
+exports.AgentClient = AgentClient;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/client/agent-manager.d.ts

@@ -0,0 +1,57 @@
+import { A2AAgentClientOptions } from './agent-client';
+import { IAgentTaskStoreFactory } from './agent-task-store';
+import type { AgentCard, Task, TaskSendParams } from '../common/schema';
+import type { TaskAndHistory } from '../server/types/a2a-types';
+export type AgentCardWithDetails = {
+    key: string;
+    url: string;
+    card: AgentCard;
+};
+export type AgentManagerOptions = Pick<A2AAgentClientOptions, 'fetchImpl' | 'logger'> & {
+    /**
+     * Optional map of agent keys to their details.
+     */
+    agentCards?: Map<string, AgentCardWithDetails>;
+    /**
+     * Optional task store factory.
+     */
+    taskStoreFactory?: IAgentTaskStoreFactory;
+};
+export declare class AgentManager {
+    private _clients;
+    private _defaultOptions;
+    private _logger;
+    private _taskStoreFactory;
+    constructor(options?: AgentManagerOptions);
+    /**
+     * Register a new agent with the manager.
+     * @param key The unique key for the agent
+     * @param baseUrl The base URL of the agent
+     * @param agentCard Optional agent card. If not provided, it will be fetched when needed
+     * @returns The client instance for this agent
+     */
+    use(key: string, baseUrl: string, agentCard?: AgentCard): AgentManager;
+    /**
+     * Send a task to an agent.
+     * @param key The key of the agent
+     * @param params The parameters for the task
+     * @returns The task after it has been sent and received from the agent
+     */
+    sendTask(key: string, params: TaskSendParams): Promise<Task | null>;
+    /**
+     * Get the agent card for a given agent key, fetching it if necessary.
+     * @param key The key of the agent
+     * @param throwIfNotFound If true, throw an error if the agent card is not found
+     * @returns The agent card
+     */
+    getAgentCard(key: string, throwIfNotFound?: boolean): Promise<AgentCard | null>;
+    /**
+     * Get all registered agent cards.
+     * @param throwIfNotFound If true, throw an error if the agent card is not found. defaults to false.
+     * @returns Array of AgentCardWithUrl
+     */
+    getAgentCards(throwIfNotFound?: boolean): Promise<(AgentCardWithDetails | null)[]>;
+    getLatestTask(key: string): Promise<TaskAndHistory | null>;
+    private getOrCreateClient;
+    private saveTask;
+}

package/dist/client/agent-manager.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentManager = void 0;
+const teams_common_1 = require("@microsoft/teams.common");
+const agent_client_1 = require("./agent-client");
+const agent_task_store_1 = require("./agent-task-store");
+class AgentManager {
+    _clients = new Map();
+    _defaultOptions;
+    _logger;
+    _taskStoreFactory;
+    constructor(options = {}) {
+        const { agentCards, taskStoreFactory, ...sharedOptions } = options;
+        this._logger = sharedOptions.logger?.child('A2AAgentManager') ?? new teams_common_1.ConsoleLogger('A2AAgentManager');
+        this._defaultOptions = sharedOptions;
+        this._taskStoreFactory = taskStoreFactory ?? new agent_task_store_1.InMemoryTaskStoreFactory();
+        if (agentCards) {
+            for (const [key, { url, card }] of agentCards) {
+                this.use(key, url, card);
+            }
+        }
+    }
+    /**
+     * Register a new agent with the manager.
+     * @param key The unique key for the agent
+     * @param baseUrl The base URL of the agent
+     * @param agentCard Optional agent card. If not provided, it will be fetched when needed
+     * @returns The client instance for this agent
+     */
+    use(key, baseUrl, agentCard) {
+        this.getOrCreateClient(key, baseUrl, true, { agentCard });
+        return this;
+    }
+    /**
+     * Send a task to an agent.
+     * @param key The key of the agent
+     * @param params The parameters for the task
+     * @returns The task after it has been sent and received from the agent
+     */
+    async sendTask(key, params) {
+        const { client } = this.getOrCreateClient(key);
+        // Save before sending
+        if (params.id) {
+            await this.saveTask(key, { task: { ...params, status: { state: 'submitted', timestamp: new Date().toISOString(), message: params.message }, artifacts: [], metadata: params.metadata }, history: [params.message] });
+        }
+        const result = await client.sendTask(params);
+        // Save after sending (with updated task)
+        if (result) {
+            await this.saveTask(key, { task: result, history: [params.message] });
+        }
+        else {
+            this._logger.warn(`A null result was returned from agent ${key}`);
+        }
+        return result;
+    }
+    /**
+     * Get the agent card for a given agent key, fetching it if necessary.
+     * @param key The key of the agent
+     * @param throwIfNotFound If true, throw an error if the agent card is not found
+     * @returns The agent card
+     */
+    async getAgentCard(key, throwIfNotFound = false) {
+        const { client } = this.getOrCreateClient(key);
+        try {
+            const card = await client.agentCard();
+            return card;
+        }
+        catch (error) {
+            if (error instanceof agent_client_1.AgentCardNotFoundError) {
+                if (throwIfNotFound) {
+                    this._logger.warn(`Agent card not found for key ${key}`);
+                    throw error;
+                }
+                return null;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Get all registered agent cards.
+     * @param throwIfNotFound If true, throw an error if the agent card is not found. defaults to false.
+     * @returns Array of AgentCardWithUrl
+     */
+    async getAgentCards(throwIfNotFound = false) {
+        const result = [];
+        for (const [key, { url, client }] of this._clients.entries()) {
+            try {
+                const card = await client.agentCard();
+                result.push({ key, url, card });
+            }
+            catch (error) {
+                if (error instanceof agent_client_1.AgentCardNotFoundError) {
+                    if (throwIfNotFound) {
+                        this._logger.warn(`Agent card not found for key ${key}`);
+                        throw error;
+                    }
+                    result.push(null);
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        return result;
+    }
+    async getLatestTask(key) {
+        const store = this._taskStoreFactory.getStore(key);
+        const last = await store.lastTasks(1);
+        return last.length > 0 ? last[0] : null;
+    }
+    getOrCreateClient(key, baseUrl, override, options) {
+        let entry = this._clients.get(key);
+        if (!entry || override) {
+            if (entry) {
+                this._logger.warn(`Overriding existing client for key ${key}`);
+            }
+            if (!baseUrl) {
+                throw new Error(`Base URL must be provided when registering a new agent with key ${key}`);
+            }
+            const client = new agent_client_1.AgentClient({
+                baseUrl,
+                ...this._defaultOptions,
+                ...options,
+            });
+            entry = { url: baseUrl, client };
+            this._clients.set(key, entry);
+        }
+        return entry;
+    }
+    async saveTask(key, data) {
+        const store = this._taskStoreFactory.getStore(key);
+        await store.save(data);
+    }
+}
+exports.AgentManager = AgentManager;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/client/agent-task-store.d.ts

@@ -0,0 +1,25 @@
+import { IListStorage } from '@microsoft/teams.common';
+import { ITaskStore, TaskAndHistory } from '../server/types/a2a-types';
+export interface IAgentTaskStore extends ITaskStore {
+    lastTasks(n: number): Promise<TaskAndHistory[]>;
+}
+export interface IAgentTaskStoreFactory {
+    getStore(agentKey: string): IAgentTaskStore;
+}
+/**
+ * Implmenets a task store for a given agent using a list storage.
+ */
+export declare class AgentTaskStore implements IAgentTaskStore {
+    private store;
+    constructor(store: IListStorage<TaskAndHistory>);
+    save(data: TaskAndHistory): Promise<void>;
+    load(taskId: string): Promise<TaskAndHistory | null>;
+    lastTasks(n: number): Promise<TaskAndHistory[]>;
+}
+/**
+ * In-memory task store factory.
+ */
+export declare class InMemoryTaskStoreFactory implements IAgentTaskStoreFactory {
+    private stores;
+    getStore(agentKey: string): IAgentTaskStore;
+}

package/dist/client/agent-task-store.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryTaskStoreFactory = exports.AgentTaskStore = void 0;
+const teams_common_1 = require("@microsoft/teams.common");
+/**
+ * Implmenets a task store for a given agent using a list storage.
+ */
+class AgentTaskStore {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    async save(data) {
+        const all = await this.store.values();
+        const idx = all.findIndex(t => t.task.id === data.task.id);
+        if (idx !== -1) {
+            await this.store.set(idx, data);
+        }
+        else {
+            await this.store.push(data);
+        }
+    }
+    async load(taskId) {
+        const all = await this.store.values();
+        const found = all.find(t => t.task.id === taskId);
+        return found ?? null;
+    }
+    async lastTasks(n) {
+        const all = await this.store.values();
+        return all.slice(-n);
+    }
+}
+exports.AgentTaskStore = AgentTaskStore;
+/**
+ * In-memory task store factory.
+ */
+class InMemoryTaskStoreFactory {
+    stores = new Map();
+    getStore(agentKey) {
+        if (!this.stores.has(agentKey)) {
+            this.stores.set(agentKey, new AgentTaskStore(new teams_common_1.ListLocalStorage()));
+        }
+        return this.stores.get(agentKey);
+    }
+}
+exports.InMemoryTaskStoreFactory = InMemoryTaskStoreFactory;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWdlbnQtdGFzay1zdG9yZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jbGllbnQvYWdlbnQtdGFzay1zdG9yZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSwwREFBeUU7QUFZekU7O0dBRUc7QUFDSCxNQUFhLGNBQWM7SUFDSDtJQUFwQixZQUFvQixLQUFtQztRQUFuQyxVQUFLLEdBQUwsS0FBSyxDQUE4QjtJQUFJLENBQUM7SUFFNUQsS0FBSyxDQUFDLElBQUksQ0FBQyxJQUFvQjtRQUMzQixNQUFNLEdBQUcsR0FBRyxNQUFNLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxFQUFFLENBQUM7UUFDdEMsTUFBTSxHQUFHLEdBQUcsR0FBRyxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsRUFBRSxLQUFLLElBQUksQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLENBQUM7UUFDM0QsSUFBSSxHQUFHLEtBQUssQ0FBQyxDQUFDLEVBQUUsQ0FBQztZQUNiLE1BQU0sSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsR0FBRyxFQUFFLElBQUksQ0FBQyxDQUFDO1FBQ3BDLENBQUM7YUFBTSxDQUFDO1lBQ0osTUFBTSxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUNoQyxDQUFDO0lBQ0wsQ0FBQztJQUVELEtBQUssQ0FBQyxJQUFJLENBQUMsTUFBYztRQUNyQixNQUFNLEdBQUcsR0FBRyxNQUFNLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxFQUFFLENBQUM7UUFDdEMsTUFBTSxLQUFLLEdBQUcsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsRUFBRSxLQUFLLE1BQU0sQ0FBQyxDQUFDO1FBQ2xELE9BQU8sS0FBSyxJQUFJLElBQUksQ0FBQztJQUN6QixDQUFDO0lBRUQsS0FBSyxDQUFDLFNBQVMsQ0FBQyxDQUFTO1FBQ3JCLE1BQU0sR0FBRyxHQUFHLE1BQU0sSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLEVBQUUsQ0FBQztRQUN0QyxPQUFPLEdBQUcsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUN6QixDQUFDO0NBQ0o7QUF2QkQsd0NBdUJDO0FBRUQ7O0dBRUc7QUFDSCxNQUFhLHdCQUF3QjtJQUN6QixNQUFNLEdBQUcsSUFBSSxHQUFHLEVBQTJCLENBQUM7SUFFcEQsUUFBUSxDQUFDLFFBQWdCO1FBQ3JCLElBQUksQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUFDO1lBQzdCLElBQUksQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLFFBQVEsRUFBRSxJQUFJLGNBQWMsQ0FBQyxJQUFJLCtCQUFnQixFQUFrQixDQUFDLENBQUMsQ0FBQztRQUMxRixDQUFDO1FBQ0QsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUUsQ0FBQztJQUN0QyxDQUFDO0NBQ0o7QUFURCw0REFTQyJ9