feat(ui): add Interactions API endpoint to playground with SSE streaming

[Sameerlite]

Summary

• Adds /v1beta/interactions as a selectable endpoint in the UI playground (EndpointType.INTERACTIONS)
• New interactions_api.tsx module: sends stream: true, reads SSE response body, and streams content.delta text tokens to the chat UI in real time
• Chat-compatible models are surfaced in the model selector for this endpoint

Test plan

• Select /v1beta/interactions in the playground endpoint dropdown
• Pick a Gemini model (e.g. gemini-2.5-flash) and send a message — response should stream in token by token
• TestTransformRequest::test_stream_param_included_in_request_body — verifies the stream flag is correctly passed through the transformation layer

---

Note

Medium Risk
Adds a new playground endpoint and custom SSE parsing path, plus adjusts streaming event transformation ordering; bugs here could cause missing/duplicated tokens or broken streaming UX, but changes are localized to the playground and Interactions streaming adapter.

Overview
Adds /v1beta/interactions as a first-class Playground endpoint, wiring EndpointType.INTERACTIONS through model selection, input placeholders, and request dispatch.

Introduces makeInteractionsRequest() to POST Interactions requests with stream: true and incrementally parse SSE data: events, updating the chat UI from content.start/content.delta tokens while capturing the response model.

Hardens the Responses→Interactions streaming adapter to handle ContentPartAddedEvent and out-of-order starts: ensures delta.type='text' is always present, avoids dropping the first token by queueing a content.start, and drains queued events in both sync/async iterators; expands tests to cover these ordering/token-preservation cases and verifies the stream flag is forwarded in Gemini request bodies.

^{Reviewed by Cursor Bugbot for commit 6cdf840. Bugbot is set up for automated code reviews on this repo. Configure here.}

[codecov]

Codecov Report

❌ Patch coverage is 81.25000% with 3 lines in your changes missing coverage. Please review.

Files with missing lines	Patch %	Lines
...llm_responses_transformation/streaming_iterator.py	81.25%	3 Missing ⚠️

📢 Thoughts on this report? Let us know!

[greptile-apps]

Greptile Summary

This PR adds /v1beta/interactions as a first-class playground endpoint, wiring EndpointType.INTERACTIONS through model selection, input placeholders, and request dispatch in the UI, and introduces a custom SSE streaming client (interactions_api.tsx) that reads content.delta/content.start events to stream tokens to the chat UI in real time.

• streaming_iterator.py: Adds ContentPartAddedEvent handling and a _pending_events queue so that when OutputTextDeltaEvent arrives before any start events, interaction.start is emitted immediately while content.start (carrying the first token) is queued and drained on the next iteration — preserving the first token rather than silently dropping it.
• interactions_api.tsx: New SSE client POSTs with stream: true, parses data: lines, and updates the chat UI from both the native Gemini event shape and the LiteLLM bridge shape; captures the response model from interaction.start/interaction.complete for display.
• Tests: Seven new unit tests cover ContentPartAddedEvent paths, first-token preservation, _pending_events drain ordering, and the stream flag forwarding in transform_request; all use mocks with no real network calls.

Confidence Score: 5/5

Changes are localized to the playground UI and the Interactions streaming adapter; the core request path is untouched and the new code is well-tested.

The streaming iterator logic is carefully implemented with a pending-events queue that correctly handles out-of-order start events in both sync and async paths. The seven new unit tests cover key edge cases including first-token preservation and fallback event ordering. No regressions to existing streaming paths are introduced.

No files require special attention.

Important Files Changed

Filename	Overview
litellm/interactions/litellm_responses_transformation/streaming_iterator.py	Adds ContentPartAddedEvent handling and a _pending_events queue to preserve the first text token; event ordering and drain logic are correct in both sync and async paths.
tests/test_litellm/interactions/test_gemini_interactions_transformation.py	Adds TestStreamingIterator (7 unit tests covering ContentPartAddedEvent, first-token preservation, and pending-events drain) and TestTransformRequest (stream flag forwarding); all tests are pure mocks with no real network calls.
ui/litellm-dashboard/src/components/playground/llm_calls/interactions_api.tsx	New SSE streaming client for /v1beta/interactions; correctly handles both native Gemini and bridge event shapes; stale comment on line 111 says content.start needs no UI action but the branch above it does update the UI for first-token events.
ui/litellm-dashboard/src/components/playground/chat_ui/ChatUI.tsx	Wires EndpointType.INTERACTIONS into model validation, request dispatch, model-selector filter, and input placeholder; changes are self-contained and follow the same pattern as RESPONSES/ANTHROPIC_MESSAGES.
ui/litellm-dashboard/src/components/playground/chat_ui/chatConstants.ts	Adds /v1beta/interactions to the endpoint dropdown; trivial one-line change.
ui/litellm-dashboard/src/components/playground/chat_ui/mode_endpoint_mapping.tsx	Adds INTERACTIONS to the EndpointType enum, consistent with the existing pattern for A2A_AGENTS, MCP, and REALTIME which also have no ModelMode mapping.

_{Reviews (9): Last reviewed commit: "chore(ui): remove unused InteractionOutp..." | Re-trigger Greptile}

[Sameerlite]

@greptile re review

[CLAassistant]

Thank you for your submission! We really appreciate it. Like many open source projects, we ask that you all sign our Contributor License Agreement before we can accept your contribution.
2 out of 3 committers have signed the CLA.

✅ Sameerlite
✅ mateo-berri
❌ cursoragent
_{You have signed the CLA already but the status is still pending? Let us recheck it.}

[mateo-berri]

@greptileai

[mateo-berri]

@greptileai

[mateo-berri]

@greptileai

[greptile-apps]

First text token silently dropped in OutputTextDeltaEvent double-fallback

When neither ResponseCreatedEvent nor ContentPartAddedEvent has arrived yet and OutputTextDeltaEvent is the very first event, delta_text is accumulated into collected_text and then interaction.start is returned — the text is never emitted. The next call hits the sent_content_start fallback and emits content.start with a different delta_text, so the very first streamed token is permanently absent from the SSE stream (though it does appear in the final interaction.complete.outputs). The _pending_interaction_complete pattern already in __next__/__anext__ shows how to buffer a deferred event; the same approach could save the unconsumed delta_text and re-emit it on the next iteration rather than swallowing it.

[mateo-berri]

This fallback path is unreachable in practice. OutputTextDeltaEvent cannot be the first event observed by _transform_responses_chunk_to_interactions_chunk because both upstream sources guarantee ResponseCreatedEvent first:

1. OpenAI Responses API (native) — the documented streaming contract is response.created → response.in_progress → response.output_item.added → response.content_part.added → response.output_text.delta. The platform never emits a text delta before response.created.

2. Non-OpenAI providers bridged via litellm.responses() — LiteLLMCompletionStreamingIterator.__next__/__anext__ (litellm/responses/litellm_completion_transformation/streaming_iterator.py:996, 871) calls return_default_initial_events() at the top of every iteration before pulling a chat-completion chunk. That helper unconditionally emits ResponseCreatedEvent on the first call (lines 741-743) and ResponseInProgressEvent on the second, so the first chunk that downstream code ever sees is ResponseCreatedEvent — which sets sent_interaction_start=True here. OutputTextDeltaEvent only fires after _emit_output_item_added_for_message has also queued the ContentPartAddedEvent.

In both paths, by the time an OutputTextDeltaEvent reaches this transform, sent_interaction_start is already True, so the lines 84–94 branch is never taken. The interaction.start fallback exists purely as defensive code for a malformed-stream scenario the wrapping iterators won't produce.

Additionally, collected_text accumulates every delta and is emitted in full on interaction.complete.outputs[0].text (lines 174-176), so even in the hypothetical case the fallback fires, the complete output is still delivered to the client at stream end. The unit tests for the realistic event orderings (test_response_part_added_emits_content_start, test_first_text_delta_not_dropped_when_part_added_seen, test_content_delta_includes_type_field) cover the paths actually exercised in production.

[mateo-berri]

@greptileai

[mateo-berri]

@greptileai

[mateo-berri]

@greptileai

[cursor]

Cursor Bugbot has reviewed your changes using high mode and found 1 potential issue.

Bugbot Autofix prepared a fix for the issue found in the latest run.

• ✅ Fixed: Exported interfaces are unused outside their defining file
  • Removed the unused exported InteractionOutput and InteractionResponse interfaces from interactions_api.tsx since they were not imported anywhere and the streaming function does not reference them.

Preview (6cdf840bf8)

diff --git a/litellm/interactions/litellm_responses_transformation/streaming_iterator.py b/litellm/interactions/litellm_responses_transformation/streaming_iterator.py
--- a/litellm/interactions/litellm_responses_transformation/streaming_iterator.py
+++ b/litellm/interactions/litellm_responses_transformation/streaming_iterator.py
@@ -2,7 +2,7 @@
 Streaming iterator for transforming Responses API stream to Interactions API stream.
 """
 
-from typing import Any, AsyncIterator, Dict, Iterator, Optional, cast
+from typing import Any, AsyncIterator, Dict, Iterator, List, Optional, cast
 
 from litellm.responses.streaming_iterator import (
     BaseResponsesAPIStreamingIterator,
@@ -15,6 +15,7 @@
     InteractionsAPIStreamingResponse,
 )
 from litellm.types.llms.openai import (
+    ContentPartAddedEvent,
     OutputTextDeltaEvent,
     ResponseCompletedEvent,
     ResponseCreatedEvent,
@@ -51,6 +52,7 @@
         self.collected_text = ""
         self.sent_interaction_start = False
         self.sent_content_start = False
+        self._pending_events: List[InteractionsAPIStreamingResponse] = []
 
     def _transform_responses_chunk_to_interactions_chunk(
         self,
@@ -80,9 +82,19 @@
             )
             self.collected_text += delta_text
 
-            # Send interaction.start if not sent
+            # Fallback: emit interaction.start, and queue content.start carrying this
+            # delta so the first token is preserved in the stream.
             if not self.sent_interaction_start:
                 self.sent_interaction_start = True
+                self.sent_content_start = True
+                self._pending_events.append(
+                    InteractionsAPIStreamingResponse(
+                        event_type="content.start",
+                        id=getattr(responses_chunk, "item_id", None),
+                        object="content",
+                        delta={"type": "text", "text": delta_text},
+                    )
+                )
                 return InteractionsAPIStreamingResponse(
                     event_type="interaction.start",
                     id=getattr(responses_chunk, "item_id", None)
@@ -92,24 +104,47 @@
                     model=self.model,
                 )
 
-            # Send content.start if not sent
+            # Fallback: emit content.start if ContentPartAddedEvent never arrived
             if not self.sent_content_start:
                 self.sent_content_start = True
                 return InteractionsAPIStreamingResponse(
                     event_type="content.start",
                     id=getattr(responses_chunk, "item_id", None),
                     object="content",
-                    delta={"type": "text", "text": ""},
+                    delta={"type": "text", "text": delta_text},
                 )
 
-            # Send content.delta
+            # Normal path: emit content.delta with type field
             return InteractionsAPIStreamingResponse(
                 event_type="content.delta",
                 id=getattr(responses_chunk, "item_id", None),
                 object="content",
-                delta={"text": delta_text},
+                delta={"type": "text", "text": delta_text},
             )
 
+        # Handle ContentPartAddedEvent -> content.start (arrives before text deltas)
+        if isinstance(responses_chunk, ContentPartAddedEvent):
+            # Fallback: emit interaction.start if ResponseCreatedEvent never arrived
+            if not self.sent_interaction_start:
+                self.sent_interaction_start = True
+                return InteractionsAPIStreamingResponse(
+                    event_type="interaction.start",
+                    id=getattr(responses_chunk, "item_id", None)
+                    or f"interaction_{id(self)}",
+                    object="interaction",
+                    status="in_progress",
+                    model=self.model,
+                )
+            if not self.sent_content_start:
+                self.sent_content_start = True
+                return InteractionsAPIStreamingResponse(
+                    event_type="content.start",
+                    id=getattr(responses_chunk, "item_id", None),
+                    object="content",
+                    delta={"type": "text", "text": ""},
+                )
+            return None
+
         # Handle ResponseCreatedEvent or ResponseInProgressEvent -> interaction.start
         if isinstance(responses_chunk, (ResponseCreatedEvent, ResponseInProgressEvent)):
             if not self.sent_interaction_start:
@@ -172,6 +207,10 @@
             delattr(self, "_pending_interaction_complete")
             return pending
 
+        # Drain events queued from a prior chunk (e.g. content.start emitted alongside
+        # the interaction.start fallback for the first OutputTextDeltaEvent).
+        if self._pending_events:
+            return self._pending_events.pop(0)
         # Use a loop instead of recursion to avoid stack overflow
         sync_iterator = cast(
             SyncResponsesAPIStreamingIterator, self.responses_stream_iterator
@@ -237,6 +276,10 @@
             delattr(self, "_pending_interaction_complete")
             return pending
 
+        # Drain events queued from a prior chunk (e.g. content.start emitted alongside
+        # the interaction.start fallback for the first OutputTextDeltaEvent).
+        if self._pending_events:
+            return self._pending_events.pop(0)
         # Use a loop instead of recursion to avoid stack overflow
         async_iterator = cast(
             ResponsesAPIStreamingIterator, self.responses_stream_iterator

diff --git a/tests/test_litellm/interactions/test_gemini_interactions_transformation.py b/tests/test_litellm/interactions/test_gemini_interactions_transformation.py
--- a/tests/test_litellm/interactions/test_gemini_interactions_transformation.py
+++ b/tests/test_litellm/interactions/test_gemini_interactions_transformation.py
@@ -9,15 +9,24 @@
 
 import os
 import sys
-from unittest.mock import patch
+from unittest.mock import MagicMock, patch
 
 import pytest
 
 sys.path.insert(0, os.path.abspath("../../.."))
 
+from litellm.interactions.litellm_responses_transformation.streaming_iterator import (
+    LiteLLMResponsesInteractionsStreamingIterator,
+)
 from litellm.llms.gemini.interactions.transformation import (
     GoogleAIStudioInteractionsConfig,
 )
+from litellm.types.llms.openai import (
+    ContentPartAddedEvent,
+    OutputTextDeltaEvent,
+    ResponseCompletedEvent,
+    ResponseCreatedEvent,
+)
 from litellm.types.router import GenericLiteLLMParams
 
 _PATCH_GET_API_KEY = "litellm.llms.gemini.common_utils.GeminiModelInfo.get_api_key"
@@ -113,6 +122,186 @@
                 )
 
 
+class TestStreamingIterator:
+    def _make_iterator(self) -> LiteLLMResponsesInteractionsStreamingIterator:
+        return LiteLLMResponsesInteractionsStreamingIterator(
+            model="gpt-5.4",
+            litellm_custom_stream_wrapper=MagicMock(),
+            request_input="hi",
+            optional_params={},
+        )
+
+    def _make_text_delta(
+        self, text: str, item_id: str = "item_1"
+    ) -> OutputTextDeltaEvent:
+        event = MagicMock(spec=OutputTextDeltaEvent)
+        event.delta = text
+        event.item_id = item_id
+        return event
+
+    def _make_part_added(self, item_id: str = "item_1") -> ContentPartAddedEvent:
+        event = MagicMock(spec=ContentPartAddedEvent)
+        event.item_id = item_id
+        return event
+
+    def _make_response_created(self) -> ResponseCreatedEvent:
+        event = MagicMock(spec=ResponseCreatedEvent)
+        event.response = MagicMock(id="resp_123")
+        return event
+
+    def test_content_delta_includes_type_field(self):
+        """content.delta events must carry delta.type='text' so the UI can display them."""
+        it = self._make_iterator()
+        it.sent_interaction_start = True
+        it.sent_content_start = True
+
+        chunk = it._transform_responses_chunk_to_interactions_chunk(
+            self._make_text_delta("Hello")
+        )
+
+        assert chunk is not None
+        assert chunk.event_type == "content.delta"
+        assert chunk.delta == {"type": "text", "text": "Hello"}
+
+    def test_response_part_added_emits_content_start(self):
+        """ContentPartAddedEvent (arrives before text deltas) should emit content.start
+        so the first OutputTextDeltaEvent immediately emits content.delta without dropping text.
+        """
+        it = self._make_iterator()
+        it.sent_interaction_start = True
+
+        chunk = it._transform_responses_chunk_to_interactions_chunk(
+            self._make_part_added()
+        )
+
+        assert chunk is not None
+        assert chunk.event_type == "content.start"
+        assert it.sent_content_start is True
+
+    def test_first_text_delta_not_dropped_when_part_added_seen(self):
+        """After ContentPartAddedEvent, the first text delta must yield content.delta
+        (not content.start), preserving the token text."""
+        it = self._make_iterator()
+        it.sent_interaction_start = True
+        it._transform_responses_chunk_to_interactions_chunk(self._make_part_added())
+
+        chunk = it._transform_responses_chunk_to_interactions_chunk(
+            self._make_text_delta("Hello")
+        )
+
+        assert chunk is not None
+        assert chunk.event_type == "content.delta"
+        assert chunk.delta is not None
+        assert chunk.delta.get("text") == "Hello"
+
+    def test_part_added_emits_interaction_start_fallback_when_not_sent(self):
+        """If ContentPartAddedEvent arrives before any ResponseCreatedEvent,
+        the iterator must emit interaction.start before content.start to honor
+        the documented event ordering contract."""
+        it = self._make_iterator()
+
+        chunk = it._transform_responses_chunk_to_interactions_chunk(
+            self._make_part_added(item_id="item_42")
+        )
+
+        assert chunk is not None
+        assert chunk.event_type == "interaction.start"
+        assert chunk.id == "item_42"
+        assert chunk.status == "in_progress"
+        assert chunk.model == "gpt-5.4"
+        assert it.sent_interaction_start is True
+        assert it.sent_content_start is False
+
+    def test_part_added_returns_none_when_already_started(self):
+        """A second ContentPartAddedEvent (after content.start was already emitted)
+        should be a no-op so we don't re-emit content.start."""
+        it = self._make_iterator()
+        it.sent_interaction_start = True
+        it.sent_content_start = True
+
+        chunk = it._transform_responses_chunk_to_interactions_chunk(
+            self._make_part_added()
+        )
+
+        assert chunk is None
+
+    def test_part_added_without_item_id_falls_back_to_self_id(self):
+        """When ContentPartAddedEvent has no item_id and we emit the interaction.start
+        fallback, the id must default to an interaction_<id(self)> string."""
+        it = self._make_iterator()
+        event = MagicMock(spec=ContentPartAddedEvent)
+        event.item_id = None
+
+        chunk = it._transform_responses_chunk_to_interactions_chunk(event)
+
+        assert chunk is not None
+        assert chunk.event_type == "interaction.start"
+        assert chunk.id == f"interaction_{id(it)}"
+
+    def test_first_text_delta_not_dropped_when_no_prior_start_events(self):
+        """When OutputTextDeltaEvent arrives before any ResponseCreatedEvent or
+        ContentPartAddedEvent, the iterator must emit interaction.start *and*
+        immediately follow with a content.start that carries this delta's text,
+        so the first token is never silently dropped from the stream."""
+        events = [
+            self._make_text_delta("Hello"),
+            self._make_text_delta(" World"),
+        ]
+        wrapper = MagicMock()
+        wrapper.__iter__ = lambda self: iter(events)
+        wrapper.__next__ = lambda self, _it=iter(events): next(_it)
+        it = LiteLLMResponsesInteractionsStreamingIterator(
+            model="gpt-5.4",
+            litellm_custom_stream_wrapper=wrapper,
+            request_input="hi",
+            optional_params={},
+        )
+
+        first = it._transform_responses_chunk_to_interactions_chunk(events[0])
+        assert first is not None
+        assert first.event_type == "interaction.start"
+        assert it.sent_interaction_start is True
+        assert it.sent_content_start is True
+        assert len(it._pending_events) == 1
+        pending = it._pending_events[0]
+        assert pending.event_type == "content.start"
+        assert pending.delta == {"type": "text", "text": "Hello"}
+
+        second = it._transform_responses_chunk_to_interactions_chunk(events[1])
+        assert second is not None
+        assert second.event_type == "content.delta"
+        assert second.delta == {"type": "text", "text": " World"}
+
+
+class TestTransformRequest:
+    def test_stream_param_included_in_request_body(self, config):
+        """When stream=True is in optional_params, the request body must include it
+        so the proxy forwards the SSE streaming flag to Google's backend."""
+        body = config.transform_request(
+            model="gemini-2.5-flash",
+            agent=None,
+            input="Hello",
+            optional_params={"stream": True},
+            litellm_params=GenericLiteLLMParams(api_key="test-key"),
+            headers={},
+        )
+
+        assert body.get("stream") is True
+        assert body.get("input") == "Hello"
+
+    def test_stream_false_not_included_when_absent(self, config):
+        body = config.transform_request(
+            model="gemini-2.5-flash",
+            agent=None,
+            input="Hello",
+            optional_params={},
+            litellm_params=GenericLiteLLMParams(api_key="test-key"),
+            headers={},
+        )
+
+        assert "stream" not in body
+
+
 class TestInteractionOperationUrls:
     """Test that get/delete/cancel interaction URLs exclude API key."""
 

diff --git a/ui/litellm-dashboard/src/components/playground/chat_ui/ChatUI.tsx b/ui/litellm-dashboard/src/components/playground/chat_ui/ChatUI.tsx
--- a/ui/litellm-dashboard/src/components/playground/chat_ui/ChatUI.tsx
+++ b/ui/litellm-dashboard/src/components/playground/chat_ui/ChatUI.tsx
@@ -49,6 +49,7 @@
 import { makeOpenAIImageEditsRequest } from "../llm_calls/image_edits";
 import { makeOpenAIImageGenerationRequest } from "../llm_calls/image_generation";
 import { makeOpenAIResponsesRequest } from "../llm_calls/responses_api";
+import { makeInteractionsRequest } from "../llm_calls/interactions_api";
 import A2AMetrics from "./A2AMetrics";
 import AdditionalModelSettings from "./AdditionalModelSettings";
 import AudioRenderer from "./AudioRenderer";
@@ -649,6 +650,7 @@
       EndpointType.ANTHROPIC_MESSAGES,
       EndpointType.EMBEDDINGS,
       EndpointType.TRANSCRIPTION,
+      EndpointType.INTERACTIONS,
     ];
 
     if (modelRequiredEndpoints.includes(endpointType as EndpointType) && !selectedModel) {
@@ -914,6 +916,16 @@
               customProxyBaseUrl || undefined,
             );
           }
+        } else if (endpointType === EndpointType.INTERACTIONS) {
+          await makeInteractionsRequest(
+            inputMessage,
+            (text, model) => updateTextUI("assistant", text, model),
+            selectedModel,
+            effectiveApiKey,
+            selectedTags,
+            signal,
+            customProxyBaseUrl || undefined,
+          );
         }
       }
 
@@ -1241,10 +1253,11 @@
                                 return true;
                               }
                               const optionEndpoint = getEndpointType(option.mode);
-                              // Show chat models for responses/anthropic_messages endpoints as they are compatible
+                              // Show chat models for responses/anthropic_messages/interactions endpoints as they are compatible
                               if (
                                 endpointType === EndpointType.RESPONSES ||
-                                endpointType === EndpointType.ANTHROPIC_MESSAGES
+                                endpointType === EndpointType.ANTHROPIC_MESSAGES ||
+                                endpointType === EndpointType.INTERACTIONS
                               ) {
                                 return optionEndpoint === endpointType || optionEndpoint === EndpointType.CHAT;
                               }
@@ -2089,7 +2102,8 @@
                         endpointType === EndpointType.CHAT ||
                         endpointType === EndpointType.EMBEDDINGS ||
                         endpointType === EndpointType.RESPONSES ||
-                        endpointType === EndpointType.ANTHROPIC_MESSAGES
+                        endpointType === EndpointType.ANTHROPIC_MESSAGES ||
+                        endpointType === EndpointType.INTERACTIONS
                           ? "Type your message... (Shift+Enter for new line)"
                           : endpointType === EndpointType.A2A_AGENTS
                             ? "Send a message to the A2A agent..."

diff --git a/ui/litellm-dashboard/src/components/playground/chat_ui/chatConstants.ts b/ui/litellm-dashboard/src/components/playground/chat_ui/chatConstants.ts
--- a/ui/litellm-dashboard/src/components/playground/chat_ui/chatConstants.ts
+++ b/ui/litellm-dashboard/src/components/playground/chat_ui/chatConstants.ts
@@ -45,4 +45,5 @@
   { value: EndpointType.A2A_AGENTS, label: "/v1/a2a/message/send" },
   { value: EndpointType.MCP, label: "/mcp-rest/tools/call" },
   { value: EndpointType.REALTIME, label: "/v1/realtime" },
+  { value: EndpointType.INTERACTIONS, label: "/v1beta/interactions" },
 ];

diff --git a/ui/litellm-dashboard/src/components/playground/chat_ui/mode_endpoint_mapping.tsx b/ui/litellm-dashboard/src/components/playground/chat_ui/mode_endpoint_mapping.tsx
--- a/ui/litellm-dashboard/src/components/playground/chat_ui/mode_endpoint_mapping.tsx
+++ b/ui/litellm-dashboard/src/components/playground/chat_ui/mode_endpoint_mapping.tsx
@@ -28,6 +28,7 @@
   A2A_AGENTS = "a2a_agents",
   MCP = "mcp",
   REALTIME = "realtime",
+  INTERACTIONS = "interactions",
 }
 
 // Create a mapping between the model mode and the corresponding endpoint type

diff --git a/ui/litellm-dashboard/src/components/playground/llm_calls/interactions_api.tsx b/ui/litellm-dashboard/src/components/playground/llm_calls/interactions_api.tsx
new file mode 100644
--- /dev/null
+++ b/ui/litellm-dashboard/src/components/playground/llm_calls/interactions_api.tsx
@@ -1,0 +1,124 @@
+import NotificationManager from "@/components/molecules/notifications_manager";
+import { getGlobalLitellmHeaderName, getProxyBaseUrl } from "@/components/networking";
+
+export async function makeInteractionsRequest(
+  input: string,
+  updateUI: (text: string, model?: string) => void,
+  selectedModel: string,
+  accessToken: string,
+  tags?: string[],
+  signal?: AbortSignal,
+  customBaseUrl?: string,
+  previousInteractionId?: string,
+): Promise<void> {
+  if (!accessToken) {
+    throw new Error("Virtual Key is required");
+  }
+
+  const isLocal = process.env.NODE_ENV === "development";
+  if (isLocal !== true) {
+    console.log = function () {};
+  }
+
+  const proxyBaseUrl = customBaseUrl || getProxyBaseUrl();
+  const normalizedBaseUrl = proxyBaseUrl.endsWith("/") ? proxyBaseUrl.slice(0, -1) : proxyBaseUrl;
+  const requestUrl = `${normalizedBaseUrl}/v1beta/interactions`;
+
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    [getGlobalLitellmHeaderName()]: `Bearer ${accessToken}`,
+  };
+  if (tags && tags.length > 0) {
+    headers["x-litellm-tags"] = tags.join(",");
+  }
+
+  const body: Record<string, unknown> = {
+    model: selectedModel,
+    input,
+    stream: true,
+  };
+  if (previousInteractionId) {
+    body.previous_interaction_id = previousInteractionId;
+  }
+
+  try {
+    const response = await fetch(requestUrl, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+      signal,
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(errorText || `Request failed with status ${response.status}`);
+    }
+
+    if (!response.body) {
+      throw new Error("No response body received");
+    }
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let responseModel: string | undefined;
+    let buffer = "";
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+
+      // SSE lines are separated by double newlines; split on single newlines and
+      // look for "data: " prefixed lines.
+      const lines = buffer.split("\n");
+      // Keep the last (potentially incomplete) line in the buffer
+      buffer = lines.pop() ?? "";
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("data:")) continue;
+
+        const jsonStr = trimmed.slice("data:".length).trim();
+        if (!jsonStr || jsonStr === "[DONE]") continue;
+
+        let event: Record<string, unknown>;
+        try {
+          event = JSON.parse(jsonStr);
+        } catch {
+          continue;
+        }
+
+        const eventType = event.event_type as string | undefined;
+
+        if (eventType === "interaction.start" || eventType === "interaction.complete") {
+          // Capture model from either the native Gemini shape (nested under
+          // `interaction`) or the bridge shape (top-level `model` field).
+          const interaction = event.interaction as Record<string, unknown> | undefined;
+          if (typeof interaction?.model === "string" && interaction.model) {
+            responseModel = interaction.model;
+          } else if (typeof event.model === "string" && event.model) {
+            responseModel = event.model;
+          }
+        } else if (eventType === "content.delta" || eventType === "content.start") {
+          const delta = event.delta as Record<string, unknown> | undefined;
+          // Accept both native Gemini format {"type":"text","text":"..."} and bridge
+          // format {"text":"..."} (no type discriminator)
+          if (typeof delta?.text === "string" && delta.text) {
+            updateUI(delta.text, responseModel ?? selectedModel);
+          }
+        }
+        // content.start, content.stop, interaction.status_update — no UI action needed
+      }
+    }
+  } catch (error: unknown) {
+    if (signal?.aborted) {
+      console.log("Interactions request was cancelled");
+      throw error;
+    }
+    NotificationManager.fromBackend(
+      `Error occurred while making Interactions API request. Error: ${error}`,
+    );
+    throw error;
+  }
+}

_{You can send follow-ups to the cloud agent here.}

^{Reviewed by Cursor Bugbot for commit f54bd7d. Configure here.}

[mateo-berri]

@greptileai

[Sameerlite]

Good to merge?

[mateo-berri]

LGTM thanks!