Merge branch 'main' into responses-and-safety

llama_stack/providers/inline/agents/meta_reference/__init__.py

@@ -21,6 +21,7 @@ async def get_provider_impl(config: MetaReferenceAgentsImplConfig, deps: dict[Ap
         deps[Api.safety],
         deps[Api.tool_runtime],
         deps[Api.tool_groups],
+        deps[Api.conversations],
         policy,
         Api.telemetry in deps,
     )

llama_stack/providers/inline/agents/meta_reference/agents.py

@@ -30,6 +30,7 @@ from llama_stack.apis.agents import (
 )
 from llama_stack.apis.agents.openai_responses import OpenAIResponseText
 from llama_stack.apis.common.responses import PaginatedResponse
+from llama_stack.apis.conversations import Conversations
 from llama_stack.apis.inference import (
     Inference,
     ToolConfig,
@@ -63,6 +64,7 @@ class MetaReferenceAgentsImpl(Agents):
         safety_api: Safety,
         tool_runtime_api: ToolRuntime,
         tool_groups_api: ToolGroups,
+        conversations_api: Conversations,
         policy: list[AccessRule],
         telemetry_enabled: bool = False,
     ):
@@ -72,6 +74,7 @@ class MetaReferenceAgentsImpl(Agents):
         self.safety_api = safety_api
         self.tool_runtime_api = tool_runtime_api
         self.tool_groups_api = tool_groups_api
+        self.conversations_api = conversations_api
         self.telemetry_enabled = telemetry_enabled
 
         self.in_memory_store = InmemoryKVStoreImpl()
@@ -89,6 +92,7 @@ class MetaReferenceAgentsImpl(Agents):
             responses_store=self.responses_store,
             vector_io_api=self.vector_io_api,
             safety_api=self.safety_api,
+            conversations_api=self.conversations_api,
         )
 
     async def create_agent(
@@ -326,6 +330,7 @@ class MetaReferenceAgentsImpl(Agents):
         model: str,
         instructions: str | None = None,
         previous_response_id: str | None = None,
+        conversation: str | None = None,
         store: bool | None = True,
         stream: bool | None = False,
         temperature: float | None = None,
@@ -340,6 +345,7 @@ class MetaReferenceAgentsImpl(Agents):
             model,
             instructions,
             previous_response_id,
+            conversation,
             store,
             stream,
             temperature,

llama_stack/providers/inline/agents/meta_reference/responses/openai_responses.py

@@ -27,6 +27,11 @@ from llama_stack.apis.agents.openai_responses import (
     OpenAIResponseText,
     OpenAIResponseTextFormat,
 )
+from llama_stack.apis.common.errors import (
+    InvalidConversationIdError,
+)
+from llama_stack.apis.conversations import Conversations
+from llama_stack.apis.conversations.conversations import ConversationItem
 from llama_stack.apis.inference import (
     Inference,
     Message,
@@ -71,6 +76,7 @@ class OpenAIResponsesImpl:
         responses_store: ResponsesStore,
         vector_io_api: VectorIO,  # VectorIO
         safety_api: Safety,
+        conversations_api: Conversations,
     ):
         self.inference_api = inference_api
         self.tool_groups_api = tool_groups_api
@@ -78,6 +84,7 @@ class OpenAIResponsesImpl:
         self.responses_store = responses_store
         self.vector_io_api = vector_io_api
         self.safety_api = safety_api
+        self.conversations_api = conversations_api
         self.tool_executor = ToolExecutor(
             tool_groups_api=tool_groups_api,
             tool_runtime_api=tool_runtime_api,
@@ -216,6 +223,7 @@ class OpenAIResponsesImpl:
         model: str,
         instructions: str | None = None,
         previous_response_id: str | None = None,
+        conversation: str | None = None,
         store: bool | None = True,
         stream: bool | None = False,
         temperature: float | None = None,
@@ -230,11 +238,27 @@ class OpenAIResponsesImpl:
 
         shield_ids = extract_shield_ids(shields) if shields else []
 
+        if conversation is not None and previous_response_id is not None:
+            raise ValueError(
+                "Mutually exclusive parameters: 'previous_response_id' and 'conversation'. Ensure you are only providing one of these parameters."
+            )
+
+        original_input = input  # needed for syncing to Conversations
+        if conversation is not None:
+            if not conversation.startswith("conv_"):
+                raise InvalidConversationIdError(conversation)
+
+            # Check conversation exists (raises ConversationNotFoundError if not)
+            _ = await self.conversations_api.get_conversation(conversation)
+            input = await self._load_conversation_context(conversation, input)
+
         stream_gen = self._create_streaming_response(
             input=input,
+            original_input=original_input,
             model=model,
             instructions=instructions,
             previous_response_id=previous_response_id,
+            conversation=conversation,
             store=store,
             temperature=temperature,
             text=text,
@@ -314,8 +338,10 @@ class OpenAIResponsesImpl:
         self,
         input: str | list[OpenAIResponseInput],
         model: str,
+        original_input: str | list[OpenAIResponseInput] | None = None,
         instructions: str | None = None,
         previous_response_id: str | None = None,
+        conversation: str | None = None,
         store: bool | None = True,
         temperature: float | None = None,
         text: OpenAIResponseText | None = None,
@@ -358,7 +384,7 @@ class OpenAIResponsesImpl:
         )
 
         # Create orchestrator and delegate streaming logic
-        response_id = f"resp-{uuid.uuid4()}"
+        response_id = f"resp_{uuid.uuid4()}"
         created_at = int(time.time())
 
         orchestrator = StreamingResponseOrchestrator(
@@ -384,13 +410,102 @@ class OpenAIResponsesImpl:
                 failed_response = stream_chunk.response
             yield stream_chunk
 
-        # Store the response if requested
-        if store and final_response and failed_response is None:
-            await self._store_response(
-                response=final_response,
-                input=all_input,
-                messages=orchestrator.final_messages,
-            )
+            # Store and sync immediately after yielding terminal events
+            # This ensures the storage/syncing happens even if the consumer breaks early
+            if (
+                stream_chunk.type in {"response.completed", "response.incomplete"}
+                and store
+                and final_response
+                and failed_response is None
+            ):
+                await self._store_response(
+                    response=final_response,
+                    input=all_input,
+                    messages=orchestrator.final_messages,
+                )
+
+            if stream_chunk.type in {"response.completed", "response.incomplete"} and conversation and final_response:
+                # for Conversations, we need to use the original_input if it's available, otherwise use input
+                sync_input = original_input if original_input is not None else input
+                await self._sync_response_to_conversation(conversation, sync_input, final_response)
 
     async def delete_openai_response(self, response_id: str) -> OpenAIDeleteResponseObject:
         return await self.responses_store.delete_response_object(response_id)
+
+    async def _load_conversation_context(
+        self, conversation_id: str, content: str | list[OpenAIResponseInput]
+    ) -> list[OpenAIResponseInput]:
+        """Load conversation history and merge with provided content."""
+        conversation_items = await self.conversations_api.list(conversation_id, order="asc")
+
+        context_messages = []
+        for item in conversation_items.data:
+            if isinstance(item, OpenAIResponseMessage):
+                if item.role == "user":
+                    context_messages.append(
+                        OpenAIResponseMessage(
+                            role="user", content=item.content, id=item.id if hasattr(item, "id") else None
+                        )
+                    )
+                elif item.role == "assistant":
+                    context_messages.append(
+                        OpenAIResponseMessage(
+                            role="assistant", content=item.content, id=item.id if hasattr(item, "id") else None
+                        )
+                    )
+
+        # add new content to context
+        if isinstance(content, str):
+            context_messages.append(OpenAIResponseMessage(role="user", content=content))
+        elif isinstance(content, list):
+            context_messages.extend(content)
+
+        return context_messages
+
+    async def _sync_response_to_conversation(
+        self, conversation_id: str, content: str | list[OpenAIResponseInput], response: OpenAIResponseObject
+    ) -> None:
+        """Sync content and response messages to the conversation."""
+        conversation_items = []
+
+        # add user content message(s)
+        if isinstance(content, str):
+            conversation_items.append(
+                {"type": "message", "role": "user", "content": [{"type": "input_text", "text": content}]}
+            )
+        elif isinstance(content, list):
+            for item in content:
+                if not isinstance(item, OpenAIResponseMessage):
+                    raise NotImplementedError(f"Unsupported input item type: {type(item)}")
+
+                if item.role == "user":
+                    if isinstance(item.content, str):
+                        conversation_items.append(
+                            {
+                                "type": "message",
+                                "role": "user",
+                                "content": [{"type": "input_text", "text": item.content}],
+                            }
+                        )
+                    elif isinstance(item.content, list):
+                        conversation_items.append({"type": "message", "role": "user", "content": item.content})
+                    else:
+                        raise NotImplementedError(f"Unsupported user message content type: {type(item.content)}")
+                elif item.role == "assistant":
+                    if isinstance(item.content, list):
+                        conversation_items.append({"type": "message", "role": "assistant", "content": item.content})
+                    else:
+                        raise NotImplementedError(f"Unsupported assistant message content type: {type(item.content)}")
+                else:
+                    raise NotImplementedError(f"Unsupported message role: {item.role}")
+
+        # add assistant response message
+        for output_item in response.output:
+            if isinstance(output_item, OpenAIResponseMessage) and output_item.role == "assistant":
+                if hasattr(output_item, "content") and isinstance(output_item.content, list):
+                    conversation_items.append({"type": "message", "role": "assistant", "content": output_item.content})
+
+        if conversation_items:
+            adapter = TypeAdapter(list[ConversationItem])
+            validated_items = adapter.validate_python(conversation_items)
+            await self.conversations_api.add_items(conversation_id, validated_items)