feat: added agentkit implimenation

Author: iamprashant

rapida/__init__.py

@@ -162,10 +162,8 @@
     CreateBulkPhoneCallResponse,
     CreatePhoneCallRequest,
     CreatePhoneCallResponse,
-    AssistantTalkInput,
-    AssistantTalkOutput,
-    TalkInput,
-    TalkOutput,
+    AssistantTalkRequest,
+    AssistantTalkResponse,
     ConversationAssistantMessage,
     ConversationConfiguration,
     ConversationDirective,
@@ -174,6 +172,10 @@
     ConversationToolCall,
     ConversationToolResult
 )
+from rapida.clients.protos.agentkit_pb2 import (
+    TalkInput,
+    TalkOutput,
+)
 from rapida.clients.protos.assistant_analysis_pb2 import (
     AssistantAnalysis,
     CreateAssistantAnalysisRequest,
@@ -377,12 +379,14 @@
 )
 
 from rapida.clients.protos.talk_api_pb2_grpc import (
-    TalkServiceServicer, 
+    TalkServiceServicer,
+)
+from rapida.clients.protos.agentkit_pb2_grpc import (
     AgentKitStub,
     AgentKit,
     AgentKitServicer,
     add_AgentKitServicer_to_server,
-    )
+)
 
 # Agent Kit classes
 from rapida.agentkit import (
@@ -703,8 +707,8 @@
     "SSLConfig",
     "AuthConfig",
     "AuthorizationInterceptor",
-    "AssistantTalkInput",
-    "AssistantTalkOutput",
+    "AssistantTalkRequest",
+    "AssistantTalkResponse",
     "TalkInput",
     "TalkOutput",
     "ConversationAssistantMessage",

rapida/agentkit/__init__.py

@@ -33,20 +33,31 @@
 - Tool execution
 - Conversation logic
 
+Flow (mirrors the WebTalk/WebRTC flow):
+    1. Rapida sends ConversationInitialization — always the first message.
+       Acknowledge it with initialization_response().
+    2. Rapida may send ConversationConfiguration to change stream mode.
+       Acknowledge it with configuration_response().
+    3. Rapida sends ConversationUserMessage for each user turn.
+       Reply with assistant_response() chunks.
+
 Usage:
     from rapida import AgentKitServer, AgentKitAgent
-    
+
     class MyAgent(AgentKitAgent):
         def Talk(self, request_iterator, context):
             for request in request_iterator:
-                if request.HasField("configuration"):
+                if request.HasField("initialization"):
+                    # Always first — acknowledge and set up your session
+                    yield self.initialization_response(request.initialization)
+                elif request.HasField("configuration"):
                     yield self.configuration_response(request.configuration)
                 elif request.HasField("message"):
                     msg = request.message
                     # Your LLM logic here
                     yield self.assistant_response(msg.id, "Hello!", completed=False)
                     yield self.assistant_response(msg.id, "Hello!", completed=True)
-    
+
     server = AgentKitServer(
         agent=MyAgent(),
         port=50051,
@@ -67,20 +78,21 @@ def Talk(self, request_iterator, context):
 from grpc import ServerInterceptor
 
 from rapida.clients.protos.talk_api_pb2 import (
+    ConversationInitialization,
     ConversationConfiguration,
     ConversationAssistantMessage,
     ConversationDirective,
     ConversationToolCall,
     ConversationToolResult,
 )
-from rapida.clients.protos.talk_api_pb2 import (
+from rapida.clients.protos.agentkit_pb2 import (
     TalkInput,
     TalkOutput,
 )
 from rapida.clients.protos.common_pb2 import (
     Error,
 )
-from rapida.clients.protos.talk_api_pb2_grpc import (
+from rapida.clients.protos.agentkit_pb2_grpc import (
     AgentKitServicer,
     add_AgentKitServicer_to_server,
 )
@@ -184,11 +196,20 @@ class AgentKitAgent(AgentKitServicer):
 
     Subclass this and implement Talk() with your LLM logic.
 
+    The message flow mirrors WebTalk/WebRTC:
+        1. ConversationInitialization — always the first message. Acknowledge it.
+        2. ConversationConfiguration — optional mode change. Acknowledge it.
+        3. ConversationUserMessage — user turns. Reply with assistant_response().
+
     Example:
         class MyAgent(AgentKitAgent):
             def Talk(self, request_iterator, context):
                 for request in request_iterator:
-                    if request.HasField("configuration"):
+                    if request.HasField("initialization"):
+                        # Always first — set up your session here
+                        conv_id = self.get_conversation_id(request)
+                        yield self.initialization_response(request.initialization)
+                    elif request.HasField("configuration"):
                         yield self.configuration_response(request.configuration)
                     elif request.HasField("message"):
                         msg = request.message
@@ -218,19 +239,41 @@ def response(
         """
         return TalkOutput(code=code, success=success, **kwargs)
 
+    def initialization_response(
+        self, initialization: ConversationInitialization
+    ) -> TalkOutput:
+        """
+        Acknowledge a ConversationInitialization from Rapida.
+
+        This should always be the first response yielded in Talk().
+        Rapida always sends initialization as the first message on the stream,
+        mirroring the WebTalk/WebRTC flow.
+
+        Args:
+            initialization: The ConversationInitialization received from Rapida
+
+        Returns:
+            TalkOutput acknowledging the initialization
+        """
+        return self.response(initialization=initialization)
+
     def configuration_response(
-        self, configuration: ConversationConfiguration
+        self, configuration: ConversationConfiguration = None
     ) -> TalkOutput:
         """
         Acknowledge a configuration request from Rapida.
 
+        Note: TalkOutput has no configuration field in its data oneof, so this
+        sends a plain code-200 acknowledgement with no data payload.
+        Configuration changes do not carry a data ack in the AgentKit protocol.
+
         Args:
-            configuration: The configuration received from the request
+            configuration: Unused; kept for API compatibility.
 
         Returns:
-            TalkOutput acknowledging the configuration
+            TalkOutput with code=200 and no data payload
         """
-        return self.response(configuration=configuration)
+        return self.response()
 
     def assistant_response(
         self, msg_id: str, content: str, completed: bool = False
@@ -419,6 +462,38 @@ def get_message_id(self, request: TalkInput) -> Optional[str]:
             return request.message.id
         return None
 
+    def get_conversation_id(self, request: TalkInput) -> Optional[int]:
+        """
+        Extract the conversation ID from an initialization request.
+
+        Args:
+            request: The incoming initialization request from Rapida
+
+        Returns:
+            Conversation ID, or None if not an initialization request
+        """
+        if request.HasField("initialization"):
+            return request.initialization.assistantConversationId
+        return None
+
+    def get_assistant_id(self, request: TalkInput) -> Optional[int]:
+        """
+        Extract the assistant ID from an initialization request.
+
+        Args:
+            request: The incoming initialization request from Rapida
+
+        Returns:
+            Assistant ID, or None if not an initialization request or assistant is unset
+        """
+        if request.HasField("initialization") and request.initialization.HasField("assistant"):
+            return request.initialization.assistant.assistantId
+        return None
+
+    def is_initialization_request(self, request: TalkInput) -> bool:
+        """Check if request is the initial ConversationInitialization message."""
+        return request.HasField("initialization")
+
     def is_configuration_request(self, request: TalkInput) -> bool:
         """Check if request is a configuration request."""
         return request.HasField("configuration")
@@ -464,14 +539,17 @@ class AgentKitServer:
         class MyAgent(AgentKitAgent):
             def Talk(self, request_iterator, context):
                 for request in request_iterator:
-                    if self.is_configuration_request(request):
+                    if self.is_initialization_request(request):
+                        # Always first — set up your session here
+                        yield self.initialization_response(request.initialization)
+                    elif self.is_configuration_request(request):
                         yield self.configuration_response(request.configuration)
                     elif self.is_text_message(request):
                         msg_id = self.get_message_id(request)
                         text = self.get_user_text(request)
                         # Your LLM logic here
                         yield self.assistant_response(msg_id, "Hello!", completed=True)
-        
+
         server = AgentKitServer(agent=MyAgent(), port=50051)
         server.start()
         server.wait_for_termination()

rapida/clients/protos/agentkit_pb2.py

@@ -0,0 +1,46 @@
+import rapida.clients.protos.common_pb2 as _common_pb2
+import rapida.clients.protos.talk_api_pb2 as _talk_api_pb2
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from collections.abc import Mapping as _Mapping
+from typing import ClassVar as _ClassVar, Optional as _Optional, Union as _Union
+
+DESCRIPTOR: _descriptor.FileDescriptor
+
+class TalkInput(_message.Message):
+    __slots__ = ("initialization", "configuration", "message", "interruption", "metadata", "metric")
+    INITIALIZATION_FIELD_NUMBER: _ClassVar[int]
+    CONFIGURATION_FIELD_NUMBER: _ClassVar[int]
+    MESSAGE_FIELD_NUMBER: _ClassVar[int]
+    INTERRUPTION_FIELD_NUMBER: _ClassVar[int]
+    METADATA_FIELD_NUMBER: _ClassVar[int]
+    METRIC_FIELD_NUMBER: _ClassVar[int]
+    initialization: _talk_api_pb2.ConversationInitialization
+    configuration: _talk_api_pb2.ConversationConfiguration
+    message: _talk_api_pb2.ConversationUserMessage
+    interruption: _talk_api_pb2.ConversationInterruption
+    metadata: _talk_api_pb2.ConversationMetadata
+    metric: _talk_api_pb2.ConversationMetric
+    def __init__(self, initialization: _Optional[_Union[_talk_api_pb2.ConversationInitialization, _Mapping]] = ..., configuration: _Optional[_Union[_talk_api_pb2.ConversationConfiguration, _Mapping]] = ..., message: _Optional[_Union[_talk_api_pb2.ConversationUserMessage, _Mapping]] = ..., interruption: _Optional[_Union[_talk_api_pb2.ConversationInterruption, _Mapping]] = ..., metadata: _Optional[_Union[_talk_api_pb2.ConversationMetadata, _Mapping]] = ..., metric: _Optional[_Union[_talk_api_pb2.ConversationMetric, _Mapping]] = ...) -> None: ...
+
+class TalkOutput(_message.Message):
+    __slots__ = ("code", "success", "initialization", "interruption", "assistant", "tool", "toolResult", "directive", "error")
+    CODE_FIELD_NUMBER: _ClassVar[int]
+    SUCCESS_FIELD_NUMBER: _ClassVar[int]
+    INITIALIZATION_FIELD_NUMBER: _ClassVar[int]
+    INTERRUPTION_FIELD_NUMBER: _ClassVar[int]
+    ASSISTANT_FIELD_NUMBER: _ClassVar[int]
+    TOOL_FIELD_NUMBER: _ClassVar[int]
+    TOOLRESULT_FIELD_NUMBER: _ClassVar[int]
+    DIRECTIVE_FIELD_NUMBER: _ClassVar[int]
+    ERROR_FIELD_NUMBER: _ClassVar[int]
+    code: int
+    success: bool
+    initialization: _talk_api_pb2.ConversationInitialization
+    interruption: _talk_api_pb2.ConversationInterruption
+    assistant: _talk_api_pb2.ConversationAssistantMessage
+    tool: _talk_api_pb2.ConversationToolCall
+    toolResult: _talk_api_pb2.ConversationToolResult
+    directive: _talk_api_pb2.ConversationDirective
+    error: _common_pb2.Error
+    def __init__(self, code: _Optional[int] = ..., success: bool = ..., initialization: _Optional[_Union[_talk_api_pb2.ConversationInitialization, _Mapping]] = ..., interruption: _Optional[_Union[_talk_api_pb2.ConversationInterruption, _Mapping]] = ..., assistant: _Optional[_Union[_talk_api_pb2.ConversationAssistantMessage, _Mapping]] = ..., tool: _Optional[_Union[_talk_api_pb2.ConversationToolCall, _Mapping]] = ..., toolResult: _Optional[_Union[_talk_api_pb2.ConversationToolResult, _Mapping]] = ..., directive: _Optional[_Union[_talk_api_pb2.ConversationDirective, _Mapping]] = ..., error: _Optional[_Union[_common_pb2.Error, _Mapping]] = ...) -> None: ...