[Feat] A2a Gateway - allow using bedrock agentcore, langgraph agents with A2a Gateway

docs/my-website/docs/providers/langgraph.md

@@ -0,0 +1,240 @@
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+# LangGraph
+
+Call LangGraph agents through LiteLLM using the OpenAI chat completions format.
+
+| Property | Details |
+|----------|---------|
+| Description | LangGraph is a framework for building stateful, multi-actor applications with LLMs. LiteLLM supports calling LangGraph agents via their streaming and non-streaming endpoints. |
+| Provider Route on LiteLLM | `langgraph/{agent_id}` |
+| Provider Doc | [LangGraph Platform ↗](https://langchain-ai.github.io/langgraph/cloud/quick_start/) |
+
+**Prerequisites:** You need a running LangGraph server. See [Setting Up a Local LangGraph Server](#setting-up-a-local-langgraph-server) below.
+
+## Quick Start
+
+### Model Format
+
+```shell showLineNumbers title="Model Format"
+langgraph/{agent_id}
+```
+
+**Example:**
+- `langgraph/agent` - calls the default agent
+
+### LiteLLM Python SDK
+
+```python showLineNumbers title="Basic LangGraph Completion"
+import litellm
+
+response = litellm.completion(
+    model="langgraph/agent",
+    messages=[
+        {"role": "user", "content": "What is 25 * 4?"}
+    ],
+    api_base="http://localhost:2024",
+)
+
+print(response.choices[0].message.content)
+```
+
+```python showLineNumbers title="Streaming LangGraph Response"
+import litellm
+
+response = litellm.completion(
+    model="langgraph/agent",
+    messages=[
+        {"role": "user", "content": "What is the weather in Tokyo?"}
+    ],
+    api_base="http://localhost:2024",
+    stream=True,
+)
+
+for chunk in response:
+    if chunk.choices[0].delta.content:
+        print(chunk.choices[0].delta.content, end="")
+```
+
+### LiteLLM Proxy
+
+#### 1. Configure your model in config.yaml
+
+<Tabs>
+<TabItem value="config-yaml" label="config.yaml">
+
+```yaml showLineNumbers title="LiteLLM Proxy Configuration"
+model_list:
+  - model_name: langgraph-agent
+    litellm_params:
+      model: langgraph/agent
+      api_base: http://localhost:2024
+```
+
+</TabItem>
+</Tabs>
+
+#### 2. Start the LiteLLM Proxy
+
+```bash showLineNumbers title="Start LiteLLM Proxy"
+litellm --config config.yaml
+```
+
+#### 3. Make requests to your LangGraph agent
+
+<Tabs>
+<TabItem value="curl" label="Curl">
+
+```bash showLineNumbers title="Basic Request"
+curl http://localhost:4000/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer $LITELLM_API_KEY" \
+  -d '{
+    "model": "langgraph-agent",
+    "messages": [
+      {"role": "user", "content": "What is 25 * 4?"}
+    ]
+  }'
+```
+
+```bash showLineNumbers title="Streaming Request"
+curl http://localhost:4000/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer $LITELLM_API_KEY" \
+  -d '{
+    "model": "langgraph-agent",
+    "messages": [
+      {"role": "user", "content": "What is the weather in Tokyo?"}
+    ],
+    "stream": true
+  }'
+```
+
+</TabItem>
+
+<TabItem value="openai-sdk" label="OpenAI Python SDK">
+
+```python showLineNumbers title="Using OpenAI SDK with LiteLLM Proxy"
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="http://localhost:4000",
+    api_key="your-litellm-api-key"
+)
+
+response = client.chat.completions.create(
+    model="langgraph-agent",
+    messages=[
+        {"role": "user", "content": "What is 25 * 4?"}
+    ]
+)
+
+print(response.choices[0].message.content)
+```
+
+```python showLineNumbers title="Streaming with OpenAI SDK"
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="http://localhost:4000",
+    api_key="your-litellm-api-key"
+)
+
+stream = client.chat.completions.create(
+    model="langgraph-agent",
+    messages=[
+        {"role": "user", "content": "What is the weather in Tokyo?"}
+    ],
+    stream=True
+)
+
+for chunk in stream:
+    if chunk.choices[0].delta.content is not None:
+        print(chunk.choices[0].delta.content, end="")
+```
+
+</TabItem>
+</Tabs>
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `LANGGRAPH_API_BASE` | Base URL of your LangGraph server (default: `http://localhost:2024`) |
+| `LANGGRAPH_API_KEY` | Optional API key for authentication |
+
+## Supported Parameters
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `model` | string | The agent ID in format `langgraph/{agent_id}` |
+| `messages` | array | Chat messages in OpenAI format |
+| `stream` | boolean | Enable streaming responses |
+| `api_base` | string | LangGraph server URL |
+| `api_key` | string | Optional API key |
+
+
+## Setting Up a Local LangGraph Server
+
+Before using LiteLLM with LangGraph, you need a running LangGraph server.
+
+### Prerequisites
+
+- Python 3.11+
+- An LLM API key (OpenAI or Google Gemini)
+
+### 1. Install the LangGraph CLI
+
+```bash
+pip install "langgraph-cli[inmem]"
+```
+
+### 2. Create a new LangGraph project
+
+```bash
+langgraph new my-agent --template new-langgraph-project-python
+cd my-agent
+```
+
+### 3. Install dependencies
+
+```bash
+pip install -e .
+```
+
+### 4. Set your API key
+
+```bash
+echo "OPENAI_API_KEY=your_key_here" > .env
+```
+
+### 5. Start the server
+
+```bash
+langgraph dev
+```
+
+The server will start at `http://localhost:2024`.
+
+### Verify the server is running
+
+```bash
+curl -s --request POST \
+  --url "http://localhost:2024/runs/wait" \
+  --header 'Content-Type: application/json' \
+  --data '{
+    "assistant_id": "agent",
+    "input": {
+      "messages": [{"role": "human", "content": "Hello!"}]
+    }
+  }'
+```
+
+
+
+## Further Reading
+
+- [LangGraph Platform Documentation](https://langchain-ai.github.io/langgraph/cloud/quick_start/)
+- [LangGraph GitHub](https://github.com/langchain-ai/langgraph)
+

docs/my-website/sidebars.js

@@ -706,6 +706,7 @@ const sidebars = {
         "providers/infinity",
         "providers/jina_ai",
         "providers/lambda_ai",
+        "providers/langgraph",
         "providers/lemonade",
         "providers/llamafile",
         "providers/lm_studio",

litellm/a2a_protocol/litellm_completion_bridge/README.md

@@ -0,0 +1,74 @@
+# A2A to LiteLLM Completion Bridge
+
+Routes A2A protocol requests through `litellm.acompletion`, enabling any LiteLLM-supported provider to be invoked via A2A.
+
+## Flow
+
+```
+A2A Request → Transform → litellm.acompletion → Transform → A2A Response
+```
+
+## SDK Usage
+
+Use the existing `asend_message` and `asend_message_streaming` functions with `litellm_params`:
+
+```python
+from litellm.a2a_protocol import asend_message, asend_message_streaming
+from a2a.types import SendMessageRequest, SendStreamingMessageRequest, MessageSendParams
+from uuid import uuid4
+
+# Non-streaming
+request = SendMessageRequest(
+    id=str(uuid4()),
+    params=MessageSendParams(
+        message={"role": "user", "parts": [{"kind": "text", "text": "Hello!"}], "messageId": uuid4().hex}
+    )
+)
+response = await asend_message(
+    request=request,
+    api_base="http://localhost:2024",
+    litellm_params={"custom_llm_provider": "langgraph", "model": "agent"},
+)
+
+# Streaming
+stream_request = SendStreamingMessageRequest(
+    id=str(uuid4()),
+    params=MessageSendParams(
+        message={"role": "user", "parts": [{"kind": "text", "text": "Hello!"}], "messageId": uuid4().hex}
+    )
+)
+async for chunk in asend_message_streaming(
+    request=stream_request,
+    api_base="http://localhost:2024",
+    litellm_params={"custom_llm_provider": "langgraph", "model": "agent"},
+):
+    print(chunk)
+```
+
+## Proxy Usage
+
+Configure an agent with `custom_llm_provider` in `litellm_params`:
+
+```yaml
+agents:
+  - agent_name: my-langgraph-agent
+    agent_card_params:
+      name: "LangGraph Agent"
+      url: "http://localhost:2024"  # Used as api_base
+    litellm_params:
+      custom_llm_provider: langgraph
+      model: agent
+```
+
+When an A2A request hits `/a2a/{agent_id}/message/send`, the bridge:
+
+1. Detects `custom_llm_provider` in agent's `litellm_params`
+2. Transforms A2A message → OpenAI messages
+3. Calls `litellm.acompletion(model="langgraph/agent", api_base="http://localhost:2024")`
+4. Transforms response → A2A format
+
+## Classes
+
+- `A2ACompletionBridgeTransformation` - Static methods for message format conversion
+- `A2ACompletionBridgeHandler` - Static methods for handling requests (streaming/non-streaming)
+

litellm/a2a_protocol/litellm_completion_bridge/__init__.py

@@ -0,0 +1,23 @@
+"""
+A2A to LiteLLM Completion Bridge.
+
+This module provides transformation between A2A protocol messages and
+LiteLLM completion API, enabling any LiteLLM-supported provider to be
+invoked via the A2A protocol.
+"""
+
+from litellm.a2a_protocol.litellm_completion_bridge.handler import (
+    A2ACompletionBridgeHandler,
+    handle_a2a_completion,
+    handle_a2a_completion_streaming,
+)
+from litellm.a2a_protocol.litellm_completion_bridge.transformation import (
+    A2ACompletionBridgeTransformation,
+)
+
+__all__ = [
+    "A2ACompletionBridgeTransformation",
+    "A2ACompletionBridgeHandler",
+    "handle_a2a_completion",
+    "handle_a2a_completion_streaming",
+]