@microsoft/teams.a2a 2.0.0-preview.3

package/README.md

@@ -0,0 +1,180 @@
+# Teams: a2a
+
+<p>
+    <a href="https://www.npmjs.com/package/@microsoft/teams.a2a" target="_blank">
+        <img src="https://img.shields.io/npm/v/@microsoft/teams.a2a" />
+    </a>
+    <a href="https://www.npmjs.com/package/@microsoft/teams.a2a?activeTab=code" target="_blank">
+        <img src="https://img.shields.io/bundlephobia/min/@microsoft/teams.a2a" />
+    </a>
+    <a href="https://www.npmjs.com/package/@microsoft/teams.a2a?activeTab=dependencies" target="_blank">
+        <img src="https://img.shields.io/librariesio/release/npm/@microsoft/teams.a2a" />
+    </a>
+    <a href="https://www.npmjs.com/package/@microsoft/teams.a2a" target="_blank">
+        <img src="https://img.shields.io/npm/dw/@microsoft/teams.a2a" />
+    </a>
+    <a href="https://microsoft.github.io/teams.ts" target="_blank">
+        <img src="https://img.shields.io/badge/📖 docs-open-blue" />
+    </a>
+</p>
+
+This is a plugin that enables your Teams agent to be used as an A2A agent.
+
+> [!NOTE]
+> The A2A protocol is still early in development and hence this package is fairly experimental.
+
+-   [What is A2A?](https://google.github.io/A2A)
+
+## Server
+
+Teams AI Library allows your applications to easily be accessible via Teams. However, using this plugin, you can also enable your agent to be used as an A2A agent so that it can be used by other A2A clients.
+
+### Configuration
+
+Configuring the App to use the A2APlugin simply requires the `AgentCard`.
+
+```ts
+import { schema, A2APlugin } from "@microsoft/teams.a2a";
+import { App } from "@microsoft/teams.apps";
+
+declare const myAgentCard: AgentCard;
+
+const app = new App({
+    plugins: [
+        new A2APlugin({
+            agentCard: myAgentCard,
+        }),
+    ],
+});
+```
+
+With this simple configuration, the A2APlugin will listen for A2A requests on the `/a2a` path and return the agent card when requested.
+
+### Agent Card
+
+The plugin automatically exposes the agent card at the path `/.well-known/agent.json`.
+
+```mermaid
+sequenceDiagram
+    participant A2A Client
+    participant App
+    participant A2APlugin
+    A2A Client->>App: /.well-known/agent.json
+    App->>A2APlugin: Call A2APlugin
+    A2APlugin->>A2A Client: Return agent card
+```
+
+### A2A Requests
+
+```mermaid
+sequenceDiagram
+    participant A2A Client
+    participant App
+    participant A2APlugin
+    participant YourEventHandler
+    A2A Client->>App: /task/send
+    App->>A2APlugin: Call A2APlugin
+    A2APlugin->>YourEventHandler: Call your event handler a2a:message
+    YourEventHandler->>A2APlugin: Call respond
+    A2APlugin->>A2A Client: Return response
+```
+
+Handling A2A requests is similar to handling app-requests. Simply add an event handler for the `a2a:message` event. You may `accumulateArtifacts` to iteratively accumulate artifacts for the task, or simply `respond` with the final result.
+
+> [!NOTE]
+> You must have only a single handler that calls `respond`. And you **must** call `respond` as the last step in your handler. This is because the `respond` function resolves the open request to the caller.
+
+```ts
+app.event(
+    "a2a:message",
+    async ({ taskContext, respond, accumulateArtifacts }) => {
+        // The taskContext contains details about the task request
+        const result = await myEventHandler(taskContext, accumulateArtifacts);
+        await respond(result);
+    }
+);
+```
+
+## Client
+
+The A2A client is able to call different A2A servers. You are able to use the `AgentManager` to call different A2A Servers.
+
+```ts
+import { AgentManager } from "@microsoft/teams.a2a";
+
+const agentManager = new AgentManager();
+
+agentManager.use("my-agent", "https://my-agent.com/a2a");
+await agentManager.sendTask("my-agent", {
+    id: continueTaskId || generateRequestId().toString(),
+    message: {
+      role: 'user',
+      parts: [{ type: 'text' as const, text: message }],
+    },
+    {},
+});
+```
+
+If you are using the `A2APlugin` described above, you can use the `clientManger` property in that plugin object to get an instance of the `AgentManager` and use it to send tasks proactively to different A2A servers.
+
+### Chat Prompt
+
+A2A is most effective when used with an LLM. The `A2AClientPlugin` can be used to add a plugin to your chat prompt that will allow you to automatically include A2A agents as a possible source of interaction. The interaction can be outlined as below:
+
+```mermaid
+sequenceDiagram
+    participant User
+    participant ChatPrompt
+    participant A2AClientPlugin
+    participant AgentManager
+    participant AgentClient
+    participant LLM
+    participant TargetAgent
+
+    alt config
+        User->>ChatPrompt: "use" with A2A server details
+        ChatPrompt->>A2AClientPlugin: configure usable a2a server
+        A2AClientPlugin->>AgentManager: register new potential client
+    end
+    alt send
+        User->>ChatPrompt: Send initial message
+        ChatPrompt->>A2AClientPlugin: configure system prompt
+        A2AClientPlugin->>AgentManager: get agent cards
+        AgentManager->>AgentClient: for each get agent card
+        AgentClient-->>AgentManager: agent card
+        AgentManager-->>A2AClientPlugin: all agent cards
+        A2AClientPlugin-->>ChatPrompt: updated system prompt
+        ChatPrompt->>A2AClientPlugin: configure tool-calls (onBuildFunctions)
+        A2AClientPlugin-->>ChatPrompt: Configured tool calls
+        ChatPrompt->>LLM: send-message
+        LLM-->>ChatPrompt: Call A2A TargetAgent
+        ChatPrompt->>A2AClientPlugin: Handler for calling A2A TargetAgent
+        A2AClientPlugin->>AgentManager: Call TargetAgent with message
+        AgentManager->>AgentClient: Call TargetAgent with message
+        TargetAgent-->>AgentClient: Return task (e.g., completed, input-required)
+        AgentClient->>AgentManager: Result task
+        AgentManager->>A2AClientPlugin: Result task
+        A2AClientPlugin->>ChatPrompt: Result task
+        ChatPrompt-->>User: Respond with final result or follow-up
+    end
+```
+
+Usage:
+
+```ts
+import { A2APlugin } from "@microsoft/teams.a2a";
+import { ChatPrompt } from "@microsoft/teams.ai";
+
+const plugin = new A2APlugin();
+
+const chatPrompt = new ChatPrompt({
+    plugins: [plugin],
+}).usePlugin("a2a", {
+    key: "my-agent",
+    url: "https://my-agent.com/a2a",
+});
+
+const result = await chatPrompt.sendMessage("Hello, world!");
+
+console.log(result);
+```

package/dist/chat-prompt/plugin.d.ts

@@ -0,0 +1,24 @@
+import { Function as ChatFunction, ChatPromptPlugin } from '@microsoft/teams.ai';
+import { AgentManager } from '../client/agent-manager';
+import * as schema from '../common/schema';
+import { A2APluginOptions, A2APluginUseParams, BuildFunctionMetadata, BuildPrompt, BuildTaskSendParams } from './types';
+export declare class A2AClientPlugin implements ChatPromptPlugin<'a2a', A2APluginUseParams> {
+    readonly name = "a2a";
+    protected _manager: AgentManager;
+    protected buildFunctionMetadata?: BuildFunctionMetadata;
+    protected buildPrompt?: BuildPrompt;
+    protected buildTaskSendParams?: BuildTaskSendParams;
+    protected _agentConfig: Map<string, Partial<A2APluginUseParams>>;
+    constructor(options?: A2APluginOptions);
+    onUsePlugin(args: A2APluginUseParams): void;
+    onBuildFunctions(functions: ChatFunction[]): Promise<ChatFunction[]>;
+    /**
+     * Modify the system prompt before it is sent to the model.
+     * If the user supplies a buildPrompt function, it is used. Otherwise, a default is built.
+     */
+    onBuildPrompt(systemPrompt: string | undefined): Promise<string | undefined>;
+    private _defaultFunctionMetadata;
+    private _defaultBuildPrompt;
+    private _defaultBuildTaskSendParams;
+}
+export declare const buildTaskSendParams: (message: string, metadata?: Record<string, any>, continueTaskId?: string | null) => schema.TaskSendParams;

package/dist/chat-prompt/plugin.js

@@ -0,0 +1,153 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTaskSendParams = exports.A2AClientPlugin = void 0;
+const camelcase_1 = __importDefault(require("camelcase"));
+const agent_manager_1 = require("../client/agent-manager");
+const uuid_1 = require("../common/uuid");
+class A2AClientPlugin {
+    name = 'a2a';
+    _manager;
+    buildFunctionMetadata;
+    buildPrompt;
+    buildTaskSendParams;
+    _agentConfig = new Map();
+    constructor(options = {}) {
+        this._manager = options.manager instanceof agent_manager_1.AgentManager ? options.manager : new agent_manager_1.AgentManager(options.manager);
+        this.buildFunctionMetadata = options.buildFunctionMetadata;
+        this.buildPrompt = options.buildPrompt;
+        this.buildTaskSendParams = options.buildTaskSendParams;
+    }
+    onUsePlugin(args) {
+        this._manager.use(args.key, args.url, args.agentCard);
+        // Store per-agent config (excluding agentCard and url)
+        const { key, url, agentCard, ...rest } = args;
+        this._agentConfig.set(key, rest);
+    }
+    async onBuildFunctions(functions) {
+        const cards = await this._manager.getAgentCards();
+        const allFunctions = [];
+        for (const cardWithMeta of cards) {
+            if (!cardWithMeta) {
+                continue;
+            }
+            const { key, card } = cardWithMeta;
+            const agentConfig = this._agentConfig.get(key) || {};
+            const buildFunctionMetadata = agentConfig.buildFunctionMetadata ||
+                this.buildFunctionMetadata ||
+                this._defaultFunctionMetadata;
+            const buildTaskSendParams = agentConfig.buildTaskSendParams ||
+                this.buildTaskSendParams ||
+                this._defaultBuildTaskSendParams;
+            const { name, description } = buildFunctionMetadata(card);
+            allFunctions.push({
+                name,
+                description,
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        message: {
+                            type: 'string',
+                            description: 'Message to send to the agent',
+                        },
+                        continueTaskId: {
+                            type: 'string',
+                            description: 'If provided, continue an existing task with this ID (string). Otherwise send null or NONE to indicate a new task.',
+                        },
+                    },
+                    required: ['message'],
+                },
+                handler: async (args) => {
+                    const agentMessage = args.message;
+                    if (!agentMessage) {
+                        throw new Error(`An input message is required to call Agent ${name}!`);
+                    }
+                    const continueTaskId = args.continueTaskId != null
+                        ? args.continueTaskId.toLowerCase() === 'none'
+                            ? null
+                            : args.continueTaskId || null
+                        : null;
+                    const sendParams = buildTaskSendParams(card, agentMessage, continueTaskId);
+                    const result = await this._manager.sendTask(key, sendParams);
+                    return result;
+                },
+            });
+        }
+        return functions.concat(allFunctions);
+    }
+    /**
+     * Modify the system prompt before it is sent to the model.
+     * If the user supplies a buildPrompt function, it is used. Otherwise, a default is built.
+     */
+    async onBuildPrompt(systemPrompt) {
+        const cardsWithMeta = await this._manager.getAgentCards();
+        // Lookup latest tasks for all agents first
+        const agentsWithLatestTask = [];
+        for (const cardWithMeta of cardsWithMeta) {
+            if (!cardWithMeta) {
+                continue;
+            }
+            const { key, card } = cardWithMeta;
+            const latestTask = await this._manager.getLatestTask(key);
+            agentsWithLatestTask.push({ card, latestTask });
+        }
+        // If the user supplied a buildPrompt, use it
+        if (this.buildPrompt) {
+            return this.buildPrompt(systemPrompt, agentsWithLatestTask);
+        }
+        const prompt = (systemPrompt || '') +
+            '\n' +
+            this._defaultBuildPrompt(agentsWithLatestTask);
+        return prompt;
+    }
+    _defaultFunctionMetadata(card) {
+        const name = `message${(0, camelcase_1.default)(card.name, { pascalCase: true })}`;
+        const description = card.description || `Interact with agent at ${card.url}`;
+        return { name, description };
+    }
+    _defaultBuildPrompt(agentDetails) {
+        let details = 'Here are details about available agents that you can message. Determine the best phrasing to use when you are attempting to message them.';
+        for (const { card, latestTask } of agentDetails) {
+            details += '<Agent Details>\n';
+            details += `<Name>\n${card.name || card.url}\n</Name>\n`;
+            if (card.description) {
+                details += `<Description>\n${card.description}\n</Description>\n`;
+            }
+            for (const skill of card.skills || []) {
+                details += `<SKILL name=${skill.name} description=${skill.description} />\n`;
+                if (skill.examples) {
+                    details += `<EXAMPLES>\n${skill.examples.join('\n')}\n</EXAMPLES>\n`;
+                }
+                details += '</SKILL>\n';
+            }
+            if (latestTask) {
+                const lastMessage = latestTask.history && latestTask.history.length > 0
+                    ? latestTask.history[latestTask.history.length - 1].parts
+                        .map((p) => p.type === 'text' ? p.text : '[non-text]')
+                        .join(' ')
+                    : '';
+                details += `<PREVIOUS_TASK_DETAILS taskId=${latestTask.task.id} state=${latestTask.task.status.state} lastMessage=${lastMessage}\n</PREVIOUS_TASK_DETAILS>`;
+            }
+            details += '</Agent Details>\n';
+        }
+        return details;
+    }
+    _defaultBuildTaskSendParams(_card, message, continueTaskId, metadata) {
+        return (0, exports.buildTaskSendParams)(message, metadata, continueTaskId);
+    }
+}
+exports.A2AClientPlugin = A2AClientPlugin;
+const buildTaskSendParams = (message, metadata, continueTaskId) => {
+    return {
+        id: continueTaskId || (0, uuid_1.generateRequestId)().toString(),
+        message: {
+            role: 'user',
+            parts: [{ type: 'text', text: message }],
+        },
+        metadata,
+    };
+};
+exports.buildTaskSendParams = buildTaskSendParams;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/chat-prompt/types.d.ts

@@ -0,0 +1,60 @@
+import { AgentManager, AgentManagerOptions } from '../client/agent-manager';
+import * as schema from '../common/schema';
+import { TaskAndHistory } from '../server/types/a2a-types';
+/**
+ * Parameters for registering an agent with the A2A plugin.
+ * usage: new ChatPrompt(..., [new A2APlugin(...)]).use(A2APluginParams)
+ */
+export type A2APluginUseParams = {
+    /**
+     * Unique key for this agent (used for config and lookup)
+     */
+    key: string;
+    /**
+     * The agent's base URL
+     */
+    url: string;
+    /**
+     * Optional agent card for the agent
+     */
+    agentCard?: schema.AgentCard;
+    /**
+     * Optional function to customize function metadata for this agent
+     */
+    buildFunctionMetadata?: BuildFunctionMetadata;
+    /**
+     * Optional function to customize TaskSendParams for this agent
+     */
+    buildTaskSendParams?: BuildTaskSendParams;
+};
+export type AgentPromptParams = {
+    card: schema.AgentCard;
+    latestTask?: TaskAndHistory | null;
+};
+export type BuildFunctionMetadata = (card: schema.AgentCard) => {
+    name: string;
+    description: string;
+};
+export type BuildTaskSendParams = (card: schema.AgentCard, input: string, continueTaskId?: string | null, metadata?: Record<string, any>) => schema.TaskSendParams;
+export type BuildPrompt = (incomingSystemPrompt: string | undefined, agentDetails: AgentPromptParams[]) => string | undefined;
+/**
+ * Options for constructing an A2APlugin.
+ */
+export type A2APluginOptions = {
+    /**
+     * Optional A2AAgentManager instance to use for agent management.
+     */
+    manager?: AgentManager | AgentManagerOptions;
+    /**
+     * Optional function to customize the function name and description for each agent card.
+     */
+    buildFunctionMetadata?: BuildFunctionMetadata;
+    /**
+     * Optional function to customize the prompt given all agent cards.
+     */
+    buildPrompt?: BuildPrompt;
+    /**
+     * Optional function to customize TaskSendParams given the input and context.
+     */
+    buildTaskSendParams?: BuildTaskSendParams;
+};

package/dist/chat-prompt/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2hhdC1wcm9tcHQvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

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

@@ -0,0 +1,58 @@
+import { ILogger } from '@microsoft/teams.common';
+import { type AgentCard, type Task, type TaskSendParams } from '../common/schema';
+/**
+ * Options for constructing an A2AAgentClient.
+ */
+export type A2AAgentClientOptions = {
+    /**
+     * The base URL of the A2A agent endpoint. The client will fetch the agent card from this URL if agentCard is not provided.
+     */
+    baseUrl: string;
+    /**
+     * The agent card object. If provided, the client will use this directly and will not fetch it from the network.
+     */
+    agentCard?: AgentCard;
+    /**
+     * Optional custom fetch implementation (e.g., for Node.js environments without global fetch). Defaults to global fetch.
+     */
+    fetchImpl?: typeof fetch;
+    /**
+     *
+     */
+    logger?: ILogger;
+};
+export declare class AgentCardNotFoundError extends Error {
+    constructor(message: string);
+}
+/**
+ * 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.
+ */
+export declare class AgentClient {
+    private _agentCard;
+    private _baseUrl;
+    get baseUrl(): string;
+    private _a2aUrl;
+    get a2aUrl(): string | null;
+    private _fetchImpl;
+    private _logger;
+    constructor(options: A2AAgentClientOptions);
+    /**
+     * Returns the agent card, fetching it if necessary.
+     */
+    agentCard(): Promise<AgentCard>;
+    /**
+     * 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.
+     */
+    sendTask(params: TaskSendParams): Promise<Task | null>;
+    /**
+     * Internal helper to make JSON-RPC HTTP requests.
+     */
+    private _makeHttpRequest;
+    /**
+     * Handles standard JSON-RPC responses (non-streaming).
+     */
+    private _handleJsonResponse;
+}