a2a-mesh-adapters 1.0.0

package/LICENSE

@@ -0,0 +1,171 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+For the purposes of this definition, "control" means (i) the power, direct or
+indirect, to cause the direction or management of such entity, whether by
+contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and configuration
+files.
+
+"Object" form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object code,
+generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made
+available under the License, as indicated by a copyright notice that is included
+in or attached to the work.
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that
+is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of this License, Derivative Works
+shall not include works that remain separable from, or merely link (or bind by
+name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version
+of the Work and any modifications or additions to that Work or Derivative Works
+thereof, that is intentionally submitted to Licensor for inclusion in the Work
+by the copyright owner or by an individual or Legal Entity authorized to submit
+on behalf of the copyright owner. For the purposes of this definition,
+"submitted" means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems, and
+issue tracking systems that are managed by, or on behalf of, the Licensor for
+the purpose of discussing and improving the Work, but excluding communication
+that is conspicuously marked or otherwise designated in writing by the copyright
+owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+2. Grant of Copyright License.
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the Work and such
+Derivative Works in Source or Object form.
+
+3. Grant of Patent License.
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable (except as stated in this section) patent license to make, have
+made, use, offer to sell, sell, import, and otherwise transfer the Work, where
+such license applies only to those patent claims licensable by such Contributor
+that are necessarily infringed by their Contribution(s) alone or by combination
+of their Contribution(s) with the Work to which such Contribution(s) was
+submitted. If You institute patent litigation against any entity alleging that
+the Work or a Contribution incorporated within the Work constitutes direct or
+contributory patent infringement, then any patent licenses granted to You under
+this License for that Work shall terminate as of the date such litigation is
+filed.
+
+4. Redistribution.
+
+You may reproduce and distribute copies of the Work or Derivative Works thereof
+in any medium, with or without modifications, and in Source or Object form,
+provided that You meet the following conditions:
+
+(a) You must give any other recipients of the Work or Derivative Works a copy of
+this License; and
+
+(b) You must cause any modified files to carry prominent notices stating that
+You changed the files; and
+
+(c) You must retain, in the Source form of any Derivative Works that You
+distribute, all copyright, patent, trademark, and attribution notices from the
+Source form of the Work, excluding those notices that do not pertain to any part
+of the Derivative Works; and
+
+(d) If the Work includes a "NOTICE" text file as part of its distribution, then
+any Derivative Works that You distribute must include a readable copy of the
+attribution notices contained within such NOTICE file, excluding those notices
+that do not pertain to any part of the Derivative Works, in at least one of the
+following places: within a NOTICE text file distributed as part of the
+Derivative Works; within the Source form or documentation, if provided along
+with the Derivative Works; or, within a display generated by the Derivative
+Works, if and wherever such third-party notices normally appear. The contents of
+the NOTICE file are for informational purposes only and do not modify the
+License. You may add Your own attribution notices within Derivative Works that
+You distribute, alongside or as an addendum to the NOTICE text from the Work,
+provided that such additional attribution notices cannot be construed as
+modifying the License.
+
+You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction, or
+distribution of Your modifications, or for any such Derivative Works as a whole,
+provided Your use, reproduction, and distribution of the Work otherwise complies
+with the conditions stated in this License.
+
+5. Submission of Contributions.
+
+Unless You explicitly state otherwise, any Contribution intentionally submitted
+for inclusion in the Work by You to the Licensor shall be under the terms and
+conditions of this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify the terms of
+any separate license agreement you may have executed with Licensor regarding
+such Contributions.
+
+6. Trademarks.
+
+This License does not grant permission to use the trade names, trademarks,
+service marks, or product names of the Licensor, except as required for
+reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty.
+
+Unless required by applicable law or agreed to in writing, Licensor provides the
+Work (and each Contributor provides its Contributions) on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
+including, without limitation, any warranties or conditions of TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
+solely responsible for determining the appropriateness of using or
+redistributing the Work and assume any risks associated with Your exercise of
+permissions under this License.
+
+8. Limitation of Liability.
+
+In no event and under no legal theory, whether in tort (including negligence),
+contract, or otherwise, unless required by applicable law (such as deliberate
+and grossly negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special, incidental,
+or consequential damages of any character arising as a result of this License or
+out of the use or inability to use the Work, including but not limited to
+damages for loss of goodwill, work stoppage, computer failure or malfunction, or
+any and all other commercial damages or losses, even if such Contributor has
+been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability.
+
+While redistributing the Work or Derivative Works thereof, You may choose to
+offer, and charge a fee for, acceptance of support, warranty, indemnity, or
+other liability obligations and/or rights consistent with this License. However,
+in accepting such obligations, You may act only on Your own behalf and on Your
+sole responsibility, not on behalf of any other Contributor, and only if You
+agree to indemnify, defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason of your
+accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS

package/README.md

@@ -0,0 +1,20 @@
+# a2a-mesh-adapters
+
+Framework adapters for running A2A agents on top of popular provider and orchestration SDKs.
+
+## Supported adapters
+
+- OpenAI
+- Anthropic
+- LangChain
+- Google ADK
+- CrewAI
+- LlamaIndex
+
+## Install
+
+```bash
+npm install a2a-mesh-adapters
+```
+
+Install only the peer SDKs you need for your chosen adapters.

package/dist/index.cjs

@@ -0,0 +1,386 @@
+'use strict';
+
+const a2aMesh = require('a2a-mesh');
+
+class BaseAdapter extends a2aMesh.A2AServer {
+  constructor(card, options = {}) {
+    super(a2aMesh.normalizeAgentCard(card), options);
+  }
+}
+
+class OpenAIAdapter extends BaseAdapter {
+  client;
+  model;
+  systemPrompt;
+  constructor(card, client, model = "gpt-4o", systemPrompt) {
+    super(a2aMesh.normalizeAgentCard(card));
+    this.client = client;
+    this.model = model;
+    this.systemPrompt = systemPrompt;
+  }
+  async handleTask(task, message) {
+    a2aMesh.logger.info(`OpenAI processing task ${task.id}`);
+    const openAiMessages = [];
+    if (this.systemPrompt) {
+      openAiMessages.push({ role: "system", content: this.systemPrompt });
+    }
+    if (task.history) {
+      for (const histMsg of task.history) {
+        if (histMsg.messageId === message.messageId) continue;
+        const text = this.extractText(histMsg.parts);
+        if (text) {
+          openAiMessages.push({
+            role: histMsg.role === "agent" ? "assistant" : "user",
+            content: text
+          });
+        }
+      }
+    }
+    const currentText = this.extractText(message.parts);
+    if (!currentText) {
+      throw new Error("OpenAI Adapter requires text input");
+    }
+    openAiMessages.push({
+      role: message.role === "agent" ? "assistant" : "user",
+      content: currentText
+    });
+    const response = await this.client.chat.completions.create({
+      model: this.model,
+      messages: openAiMessages
+    });
+    const outputContent = response.choices[0]?.message?.content;
+    if (!outputContent) {
+      throw new Error("OpenAI returned empty response");
+    }
+    const partsOut = [{ type: "text", text: outputContent }];
+    const artifact = {
+      artifactId: `oai-art-${Date.now()}`,
+      name: "OpenAI Response",
+      description: "Result generated by OpenAI Chat API",
+      parts: partsOut,
+      index: 0,
+      lastChunk: true
+    };
+    return [artifact];
+  }
+  extractText(parts) {
+    return parts.filter((p) => p.type === "text").map((p) => p.text).join("\n");
+  }
+}
+
+class LangChainAdapter extends BaseAdapter {
+  runnable;
+  constructor(card, runnable) {
+    super(a2aMesh.normalizeAgentCard(card));
+    this.runnable = runnable;
+  }
+  async handleTask(task, message) {
+    a2aMesh.logger.info(`LangChain processing task ${task.id}`);
+    const messages = [];
+    for (const histMsg of task.history) {
+      if (histMsg.messageId === message.messageId) {
+        continue;
+      }
+      const text = this.extractText(histMsg.parts);
+      if (text) {
+        messages.push({
+          role: histMsg.role === "agent" ? "assistant" : "user",
+          content: text
+        });
+      }
+    }
+    const currentText = this.extractText(message.parts);
+    if (!currentText) {
+      throw new Error("LangChain Adapter requires text input");
+    }
+    messages.push({ role: message.role === "agent" ? "assistant" : "user", content: currentText });
+    const result = await this.runnable.invoke({ messages });
+    const outputString = typeof result === "string" ? result : result?.content ? result.content : result?.messages && Array.isArray(result.messages) && result.messages.length > 0 ? result.messages[result.messages.length - 1]?.content ?? JSON.stringify(result) : JSON.stringify(result);
+    const partsOut = [{ type: "text", text: outputString }];
+    const artifact = {
+      artifactId: `lc-art-${Date.now()}`,
+      name: "LangChain Output",
+      description: "Result generated by LangChain agent",
+      parts: partsOut,
+      index: 0,
+      lastChunk: true
+    };
+    return [artifact];
+  }
+  extractText(parts) {
+    return parts.filter((p) => p.type === "text").map((p) => p.text).join("\n");
+  }
+}
+
+function extractText$3(parts) {
+  return parts.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+}
+class AnthropicAdapter extends BaseAdapter {
+  constructor(card, client, model = "claude-opus-4-6", systemPrompt, maxTokens = 4096) {
+    super(a2aMesh.normalizeAgentCard(card));
+    this.client = client;
+    this.model = model;
+    this.systemPrompt = systemPrompt;
+    this.maxTokens = maxTokens;
+  }
+  async handleTask(task, message) {
+    a2aMesh.logger.info("Anthropic processing task", {
+      taskId: task.id,
+      ...task.contextId ? { contextId: task.contextId } : {}
+    });
+    const messages = task.history.filter((entry) => entry.messageId !== message.messageId).map((entry) => ({
+      role: entry.role === "agent" ? "assistant" : "user",
+      content: extractText$3(entry.parts)
+    })).filter((entry) => entry.content.length > 0);
+    const currentText = extractText$3(message.parts);
+    if (!currentText) {
+      throw new Error("Anthropic Adapter requires text input");
+    }
+    messages.push({
+      role: message.role === "agent" ? "assistant" : "user",
+      content: currentText
+    });
+    const streamRequested = task.metadata?.stream === true;
+    if (streamRequested) {
+      const stream = await this.client.messages.create({
+        model: this.model,
+        max_tokens: this.maxTokens,
+        system: this.systemPrompt,
+        messages,
+        stream: true
+      });
+      let streamedText = "";
+      for await (const event of stream) {
+        if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
+          streamedText += event.delta.text;
+        }
+      }
+      const artifact2 = {
+        artifactId: `anthropic-${Date.now()}`,
+        name: "Anthropic Stream Response",
+        description: "Result generated by Anthropic Claude stream",
+        parts: [{ type: "text", text: streamedText }],
+        index: 0,
+        lastChunk: true,
+        metadata: {
+          provider: "anthropic",
+          model: this.model,
+          streamed: true
+        }
+      };
+      return [artifact2];
+    }
+    const response = await this.client.messages.create({
+      model: this.model,
+      max_tokens: this.maxTokens,
+      system: this.systemPrompt,
+      messages
+    });
+    const outputText = response.content.filter((block) => block.type === "text").map((block) => block.text).join("\n");
+    const toolUses = response.content.filter((block) => block.type === "tool_use").map((block) => ({
+      id: block.id,
+      name: block.name,
+      input: block.input
+    }));
+    const artifact = {
+      artifactId: `anthropic-${Date.now()}`,
+      name: "Anthropic Response",
+      description: "Result generated by Anthropic Claude",
+      parts: [{ type: "text", text: outputText || JSON.stringify(toolUses, null, 2) }],
+      index: 0,
+      lastChunk: true,
+      metadata: {
+        provider: "anthropic",
+        model: this.model,
+        inputTokens: response.usage.input_tokens,
+        outputTokens: response.usage.output_tokens,
+        toolUses
+      }
+    };
+    return [artifact];
+  }
+}
+
+function extractText$2(parts) {
+  return parts.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+}
+class GoogleADKAdapter extends BaseAdapter {
+  constructor(card, adkEndpoint, apiKey) {
+    super(a2aMesh.normalizeAgentCard(card));
+    this.adkEndpoint = adkEndpoint;
+    this.apiKey = apiKey;
+  }
+  async handleTask(task, message) {
+    a2aMesh.logger.info("Google ADK processing task", {
+      taskId: task.id,
+      ...task.contextId ? { contextId: task.contextId } : {}
+    });
+    const history = task.history.map((entry) => ({
+      role: entry.role === "agent" ? "model" : "user",
+      content: extractText$2(entry.parts)
+    }));
+    const response = await fetch(this.adkEndpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.apiKey ? { "x-goog-api-key": this.apiKey } : {}
+      },
+      body: JSON.stringify({
+        taskId: task.id,
+        contextId: task.contextId,
+        message: extractText$2(message.parts),
+        history
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`Google ADK request failed with status ${response.status}`);
+    }
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.includes("text/event-stream")) {
+      const text = await response.text();
+      const chunks = text.split("\n").filter((line) => line.startsWith("data: ")).map((line) => line.slice("data: ".length)).join("\n");
+      const artifact2 = {
+        artifactId: `google-adk-${Date.now()}`,
+        name: "Google ADK Stream Response",
+        parts: [{ type: "text", text: chunks }],
+        index: 0,
+        lastChunk: true,
+        metadata: {
+          provider: "google-adk",
+          streamed: true
+        }
+      };
+      return [artifact2];
+    }
+    const json = await response.json();
+    const artifact = {
+      artifactId: `google-adk-${Date.now()}`,
+      name: "Google ADK Response",
+      parts: [{ type: "text", text: json.output ?? json.result ?? "" }],
+      index: 0,
+      lastChunk: true,
+      metadata: {
+        provider: "google-adk",
+        ...json.metadata ?? {}
+      }
+    };
+    return [artifact];
+  }
+}
+
+function extractText$1(parts) {
+  return parts.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+}
+class LlamaIndexAdapter extends BaseAdapter {
+  constructor(card, engine) {
+    super(a2aMesh.normalizeAgentCard(card));
+    this.engine = engine;
+  }
+  async handleTask(task, message) {
+    a2aMesh.logger.info("LlamaIndex processing task", {
+      taskId: task.id,
+      ...task.contextId ? { contextId: task.contextId } : {}
+    });
+    const input = extractText$1(message.parts);
+    if (!input) {
+      throw new Error("LlamaIndex Adapter requires text input");
+    }
+    if (this.isChatEngine(this.engine)) {
+      const chatHistory = task.history.filter((entry) => entry.messageId !== message.messageId).map((entry) => ({
+        role: entry.role === "agent" ? "assistant" : "user",
+        content: extractText$1(entry.parts)
+      }));
+      const response2 = await this.engine.chat({
+        message: input,
+        chatHistory,
+        stream: task.metadata?.stream === true
+      });
+      return [this.toArtifact(response2, "LlamaIndex Chat Response")];
+    }
+    const response = await this.engine.query({ query: input });
+    return [this.toArtifact(response, "LlamaIndex Query Response")];
+  }
+  isChatEngine(engine) {
+    return "chat" in engine;
+  }
+  toArtifact(response, name) {
+    if (this.isAsyncIterable(response)) {
+      throw new Error("Streaming LlamaIndex responses are not supported in handleTask");
+    }
+    const sourceNodes = typeof response === "string" ? [] : response.sourceNodes ?? [];
+    const text = typeof response === "string" ? response : response.response ?? response.message ?? JSON.stringify(response, null, 2);
+    return {
+      artifactId: `llamaindex-${Date.now()}`,
+      name,
+      parts: [{ type: "text", text }],
+      index: 0,
+      lastChunk: true,
+      metadata: {
+        provider: "llamaindex",
+        sourceNodes: sourceNodes.map((node) => ({
+          score: node.score,
+          metadata: node.node?.metadata ?? {}
+        }))
+      },
+      extensions: sourceNodes.length > 0 ? ["urn:a2a:extensions:llamaindex/source-nodes"] : []
+    };
+  }
+  isAsyncIterable(value) {
+    return typeof value === "object" && value !== null && Symbol.asyncIterator in value;
+  }
+}
+
+function extractText(parts) {
+  return parts.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+}
+class CrewAIAdapter extends BaseAdapter {
+  constructor(card, bridgeUrl) {
+    super(a2aMesh.normalizeAgentCard(card));
+    this.bridgeUrl = bridgeUrl;
+  }
+  async handleTask(task, message) {
+    a2aMesh.logger.info("CrewAI bridge processing task", {
+      taskId: task.id,
+      ...task.contextId ? { contextId: task.contextId } : {}
+    });
+    const response = await fetch(this.bridgeUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        taskId: task.id,
+        contextId: task.contextId,
+        message: extractText(message.parts),
+        history: task.history.map((entry) => ({
+          role: entry.role,
+          content: extractText(entry.parts)
+        }))
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`CrewAI bridge failed with status ${response.status}`);
+    }
+    const json = await response.json();
+    const artifact = {
+      artifactId: `crewai-${Date.now()}`,
+      name: "CrewAI Response",
+      parts: [{ type: "text", text: json.output ?? "" }],
+      index: 0,
+      lastChunk: true,
+      metadata: {
+        provider: "crewai",
+        ...json.metadata ?? {}
+      }
+    };
+    return [artifact];
+  }
+}
+
+exports.AnthropicAdapter = AnthropicAdapter;
+exports.BaseAdapter = BaseAdapter;
+exports.CrewAIAdapter = CrewAIAdapter;
+exports.GoogleADKAdapter = GoogleADKAdapter;
+exports.LangChainAdapter = LangChainAdapter;
+exports.LlamaIndexAdapter = LlamaIndexAdapter;
+exports.OpenAIAdapter = OpenAIAdapter;