nora-lib 0.0.4__tar.gz → 0.0.5.dev1__tar.gz

{nora_lib-0.0.4 → nora_lib-0.0.5.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nora_lib
-Version: 0.0.4
+Version: 0.0.5.dev1
 Summary: For making and coordinating agents and tools
 Home-page: https://github.com/allenai/nora_lib
 Requires-Python: >=3.9

nora_lib-0.0.5.dev1/nora_lib/context/context_service.py

@@ -0,0 +1,42 @@
+from datetime import datetime, timezone
+from typing import List, Optional
+from uuid import UUID
+
+from nora_lib.interactions.interactions_service import InteractionsService
+from nora_lib.interactions.models import (
+    ReturnedMessage,
+    ReturnedAgentContextMessage,
+    ReturnedAgentContextEvent,
+    EventType,
+    AgentMessageData,
+    Event,
+)
+from nora_lib.context.models import WrappedTaskObject
+
+
+class ContextService:
+    """
+    Save and retrieve task agent context from interaction store
+    """
+
+    def __init__(
+        self,
+        agent_actor_id: str,  # uuid representing this agent in interaction store
+        interactions_base_url: str,
+        interactions_bearer_token: Optional[str],
+        timeout: int = 30,
+    ):
+        self.interactions_service = self._get_interactions_service(
+            interactions_base_url, interactions_bearer_token, timeout
+        )
+        self.agent_actor_id = agent_actor_id
+
+    def _get_interactions_service(self, url, token, timeout) -> InteractionsService:
+        return InteractionsService(url, timeout, token)
+
+    def get_message(self, message_id: str) -> str:
+        message: ReturnedMessage = self.interactions_service.get_message(message_id)
+        if message.annotated_text:
+            return message.annotated_text
+        else:
+            return message.text

nora_lib-0.0.5.dev1/nora_lib/context/models.py

@@ -0,0 +1,11 @@
+from typing import Optional
+from pydantic import BaseModel, Field
+
+
+class WrappedTaskObject(BaseModel):
+    """Encloses request or response object with additional metadata"""
+
+    message_id: str = Field(
+        description="id of originating message; key for istore retrieval"
+    )
+    data: dict = Field(description="Tool-defined request or response")

nora_lib-0.0.5.dev1/nora_lib/interactions/interactions_service.py

@@ -0,0 +1,227 @@
+from datetime import datetime
+import logging
+import requests
+from typing import List, Optional
+
+from nora_lib.interactions.models import (
+    Event,
+    EventType,
+    Message,
+    ReturnedMessage,
+    ThreadRelationsResponse,
+    ThreadForkEventData,
+)
+
+
+class InteractionsService:
+    """
+    Service which saves interactions to the Interactions API
+    """
+
+    def __init__(self, base_url: str, timeout: int = 30, token: Optional[str] = None):
+        self.base_url = base_url
+        self.timeout = timeout
+        self.headers = {"Authorization": f"Bearer {token}"} if token else None
+
+    def save_message(self, message: Message) -> None:
+        """Save a message to the Interactions API"""
+        message_url = f"{self.base_url}/interaction/v1/message"
+        response = requests.post(
+            message_url,
+            json=message.model_dump(),
+            headers=self.headers,
+            timeout=int(self.timeout),
+        )
+        response.raise_for_status()
+
+    def save_event(self, event: Event) -> None:
+        """Save an event to the Interactions API"""
+        event_url = f"{self.base_url}/interaction/v1/event"
+        response = requests.post(
+            event_url,
+            json=event.model_dump(),
+            headers=self.headers,
+            timeout=int(self.timeout),
+        )
+        response.raise_for_status()
+
+    def get_message(self, message_id: str) -> ReturnedMessage:
+        """Fetch a message from the Interactions API"""
+        message_url = f"{self.base_url}/interaction/v1/search/message"
+        request_body = {
+            "id": message_id,
+            "relations": {"thread": {}, "channel": {}, "events": {}, "annotations": {}},
+        }
+        response = requests.post(
+            message_url,
+            json=request_body,
+            headers=self.headers,
+            timeout=int(self.timeout),
+        )
+        response.raise_for_status()
+        res_dict = response.json()["message"]
+        res = ReturnedMessage.model_validate(res_dict)
+
+        # thread_id and channel_id are for some reason nested in the response
+        if not res.thread_id:
+            res.thread_id = res_dict.get("thread", {}).get("thread_id")
+        if not res.channel_id:
+            res.channel_id = res_dict.get("channel", {}).get("channel_id")
+
+        return res
+
+    def fetch_all_threads_by_channel(self, channel_id: str, min_timestamp: str) -> dict:
+        """Fetch a message from the Interactions API"""
+        message_url = f"{self.base_url}/interaction/v1/search/channel"
+        request_body = self._channel_lookup_request(
+            channel_id=channel_id, min_timestamp=min_timestamp
+        )
+        response = requests.post(
+            message_url,
+            json=request_body,
+            headers=self.headers,
+            timeout=int(self.timeout),
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def fetch_messages_and_agent_context_events_for_thread(
+        self, message_id: str, event_type: str
+    ) -> List[ReturnedMessage]:
+        """Build a history of messages for a given message including associated events.
+        This includes messages from pre-forked threads."""
+        messages_with_events: List[ReturnedMessage] = []
+
+        messages_for_thread: ThreadRelationsResponse = (
+            self.fetch_thread_messages_and_events_for_message(
+                message_id, [event_type, EventType.THREAD_FORK.value]
+            )
+        )
+        messages_with_events.extend(messages_for_thread.messages)
+
+        # Process any thread_fork events
+        try:
+            for msg in messages_for_thread.messages:
+                for event in msg.events:
+                    if event.type == EventType.THREAD_FORK.value:
+                        event_data = ThreadForkEventData.model_validate(event.data)
+                        forked_thread: ThreadRelationsResponse = (
+                            self.fetch_thread_messages_and_events_for_message(
+                                event_data.previous_message_id, [event_type]
+                            )
+                        )
+                        messages_with_events.extend(forked_thread.messages)
+        except Exception as e:  # pylint: disable=broad-except
+            logging.exception(
+                "Failed to fetch forked thread messages for message %s: %s",
+                message_id,
+                e,
+            )
+
+        messages_with_events.sort(key=lambda x: datetime.fromisoformat(x.ts))
+        return messages_with_events
+
+    def fetch_thread_messages_and_events_for_message(
+        self, message_id: str, event_types: list[str]
+    ) -> ThreadRelationsResponse:
+        """Fetch messages sorted by timestamp and events for agent context"""
+        message_url = f"{self.base_url}/interaction/v1/search/message"
+        request_body = self._thread_lookup_request(message_id, event_types=event_types)
+        response = requests.post(
+            message_url,
+            json=request_body,
+            headers=self.headers,
+            timeout=int(self.timeout),
+        )
+        response.raise_for_status()
+        json_response = response.json()
+
+        return ThreadRelationsResponse.model_validate(
+            json_response.get("message", {}).get("thread", {})
+        )
+
+    def fetch_messages_and_events_for_thread(
+        self,
+        thread_id: str,
+        event_type: Optional[str] = None,
+        min_timestamp: Optional[str] = None,
+    ) -> dict:
+        """Fetch messages and events for the given thread from the Interactions API"""
+        thread_search_url = f"{self.base_url}/interaction/v1/search/thread"
+        request_body = {
+            "id": thread_id,
+            "relations": {
+                "messages": (
+                    {"filter": {"min_timestamp": min_timestamp}}
+                    if min_timestamp
+                    else {}
+                ),
+                "events": {"filter": {"type": event_type}} if event_type else {},
+            },
+        }
+
+        response = requests.post(
+            thread_search_url,
+            json=request_body,
+            headers=self.headers,
+            timeout=int(self.timeout),
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def fetch_events_for_message(
+        self,
+        message_id: str,
+        event_type: Optional[str] = None,
+    ) -> dict:
+        """Fetch messages and events for the thread containing a given message from the Interactions API"""
+        message_search_url = f"{self.base_url}/interaction/v1/search/message"
+        request_body = {
+            "id": message_id,
+            "relations": {
+                "events": {"filter": {"type": event_type}} if event_type else {},
+            },
+        }
+
+        response = requests.post(
+            message_search_url,
+            json=request_body,
+            headers=self.headers,
+            timeout=int(self.timeout),
+        )
+        response.raise_for_status()
+        return response.json()
+
+    @staticmethod
+    def _channel_lookup_request(channel_id: str, min_timestamp: str) -> dict:
+        """Interaction service API request to get threads and messages for a channel"""
+        return {
+            "id": channel_id,
+            "relations": {
+                "threads": {
+                    "relations": {
+                        "messages": {
+                            "filter": {"min_timestamp": min_timestamp},
+                            "apply_annotations_from_actors": ["*"],
+                        }
+                    }
+                }
+            },
+        }
+
+    @staticmethod
+    def _thread_lookup_request(message_id: str, event_types: list[str]) -> dict:
+        """will return all messages for the thread containing the given message and events associated with each message"""
+        return {
+            "id": message_id,
+            "relations": {
+                "thread": {
+                    "relations": {
+                        "messages": {
+                            "relations": {"events": {"filter": {"type": event_types}}},
+                            "apply_annotations_from_actors": ["*"],
+                        },
+                    }
+                }
+            },
+        }

{nora_lib-0.0.4 → nora_lib-0.0.5.dev1}/nora_lib/interactions/models.py

@@ -10,6 +10,40 @@ from uuid import UUID
 from pydantic import BaseModel, Field, field_serializer, ConfigDict
 
 
+class Surface(str, Enum):
+    SLACK = "Slack"
+    WEB = "NoraWebapp"
+
+
+class Annotation(BaseModel):
+    # Need this config to stringify numeric values in attributes.
+    # Otherwise, we'll get 'Input should be a valid string' error.
+    model_config = ConfigDict(coerce_numbers_to_str=True)
+
+    tag: str
+    span: Tuple[int, int]
+    attributes: Optional[Dict[str, str]] = None
+
+
+class Message(BaseModel):
+    message_id: str
+    actor_id: UUID
+    text: str
+    thread_id: Optional[str]
+    channel_id: str
+    surface: Surface
+    ts: datetime
+    annotations: Optional[List[Annotation]] = None
+
+    @field_serializer("actor_id")
+    def serialize_actor_id(self, actor_id: UUID):
+        return str(actor_id)
+
+    @field_serializer("ts")
+    def serialize_ts(self, ts: datetime):
+        return ts.isoformat()
+
+
 class EventType(str, Enum):
     """Event types for the interactions service"""
 
@@ -26,7 +60,7 @@ class Event(BaseModel):
     )
     timestamp: datetime
     text: Optional[str] = None
-    data: Optional[dict] = Field(default_factory=dict)
+    data: dict = Field(default_factory=dict)
     message_id: Optional[str] = None
     thread_id: Optional[str] = None
     channel_id: Optional[str] = None
@@ -48,7 +82,10 @@ class ReturnedMessage(BaseModel):
     text: str
     ts: str
     annotated_text: Optional[str] = None
-    events: Optional[List[dict]] = None
+    events: List[Event] = Field(default_factory=list)
+    thread_id: Optional[str] = None
+    channel_id: Optional[str] = None
+    annotations: Optional[List[Annotation]] = None
 
 
 class AgentMessageData(BaseModel):
@@ -91,10 +128,12 @@ class ThreadRelationsResponse(BaseModel):
     """Thread format returned by interaction service for thread relations in a search response"""
 
     thread_id: str
-    events: Optional[List[Event]] = None  # events associated only with the thread
-    messages: Optional[List[ReturnedMessage]] = (
-        None  # includes events associated with each message
-    )
+    events: List[Event] = Field(
+        default_factory=list
+    )  # events associated only with the thread
+    messages: List[ReturnedMessage] = Field(
+        default_factory=list
+    )  # includes events associated with each message
 
 
 def thread_message_lookup_request(message_id: str, event_type: str) -> dict:

{nora_lib-0.0.4 → nora_lib-0.0.5.dev1}/nora_lib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nora_lib
-Version: 0.0.4
+Version: 0.0.5.dev1
 Summary: For making and coordinating agents and tools
 Home-page: https://github.com/allenai/nora_lib
 Requires-Python: >=3.9

{nora_lib-0.0.4 → nora_lib-0.0.5.dev1}/setup.py

@@ -7,7 +7,7 @@ dev_requirements = ["mypy", "pytest", "black", "types-requests"]
 
 setuptools.setup(
     name="nora_lib",
-    version="0.0.4",
+    version="0.0.5.dev1",
     description="For making and coordinating agents and tools",
     url="https://github.com/allenai/nora_lib",
     packages=setuptools.find_packages(exclude=(["tests"])),

nora_lib-0.0.4/nora_lib/context/context_service.py

@@ -1,95 +0,0 @@
-from datetime import datetime, timezone
-from typing import List, Optional
-from uuid import UUID
-
-from nora_lib.interactions.interactions_service import InteractionsService
-from nora_lib.interactions.models import (
-    ReturnedMessage,
-    ReturnedAgentContextMessage,
-    ReturnedAgentContextEvent,
-    EventType,
-    AgentMessageData,
-    Event,
-)
-from nora_lib.context.models import WrappedTaskObject
-
-
-class ContextService:
-    """
-    Save and retrieve task agent context from interaction store
-    """
-
-    def __init__(
-        self,
-        agent_actor_id: str,  # uuid representing this agent in interaction store
-        interactions_base_url: str,
-        interactions_bearer_token: Optional[str],
-        timeout: int = 30,
-    ):
-        self.interactions_service = self._get_interactions_service(
-            interactions_base_url, interactions_bearer_token, timeout
-        )
-        self.agent_actor_id = agent_actor_id
-
-    def _get_interactions_service(self, url, token, timeout) -> InteractionsService:
-        return InteractionsService(url, timeout, token)
-
-    def get_message(self, message_id: str) -> str:
-        message: ReturnedMessage = self.interactions_service.get_message(message_id)
-        if message.annotated_text:
-            return message.annotated_text
-        else:
-            return message.text
-
-    def fetch_context(
-        self, request: WrappedTaskObject
-    ) -> List[ReturnedAgentContextMessage]:
-        message_id = request.message_id
-
-        returned_messages: List[ReturnedMessage] = (
-            self.interactions_service.fetch_messages_and_events_for_forked_thread(
-                message_id, EventType.AGENT_CONTEXT
-            )
-        )
-
-        messages_with_filtered_events: List[ReturnedAgentContextMessage] = []
-        for message in returned_messages:
-            events_saved_by_this_agent: List[ReturnedAgentContextEvent] = []
-            if message.events:
-                for event in message.events:
-                    context_event = ReturnedAgentContextEvent.model_validate(event)
-                    if context_event.actor_id == self.agent_actor_id:
-                        events_saved_by_this_agent.append(context_event)
-
-                events_saved_by_this_agent.sort(
-                    key=lambda event: datetime.fromisoformat(event.timestamp)
-                )
-
-            updated_message = ReturnedAgentContextMessage(
-                message_id=message.message_id,
-                actor_id=message.actor_id,
-                text=message.text,
-                ts=message.ts,
-                annotated_text=message.annotated_text,
-                events=events_saved_by_this_agent,
-            )
-
-            messages_with_filtered_events.append(updated_message)
-
-        return messages_with_filtered_events
-
-    def save_context(self, event_data: WrappedTaskObject):
-        agent_data = AgentMessageData(
-            message_data=event_data.model_dump(),
-            data_sender_actor_id=event_data.sender_actor_id,
-            virtual_thread_id=event_data.virtual_thread_id,
-        )
-        event = Event(
-            type=EventType.AGENT_CONTEXT,
-            actor_id=UUID(self.agent_actor_id),
-            timestamp=datetime.now(timezone.utc),
-            data=agent_data.model_dump(),
-            message_id=event_data.message_id,
-        )
-
-        self.interactions_service.save_event(event)

nora_lib-0.0.4/nora_lib/context/models.py

@@ -1,21 +0,0 @@
-from typing import Generic, Optional, TypeVar
-from pydantic import BaseModel, Field
-
-
-R = TypeVar("R", bound=BaseModel)
-
-
-class WrappedTaskObject(BaseModel, Generic[R]):
-    """Encloses request or response object with additional metadata"""
-
-    message_id: str = Field(
-        description="id of originating message; key for istore retrieval"
-    )
-    sender_actor_id: str = Field(
-        description="string representation of uuid identifying agent sending data"
-    )
-    virtual_thread_id: Optional[str] = Field(
-        description="Tool-defined local thread to associate follow up requests"
-    )
-    task_id: Optional[str] = Field(description="Reference to a long-running task")
-    data: R = Field(description="Tool-defined request or response")

nora_lib-0.0.4/nora_lib/interactions/interactions_service.py

@@ -1,134 +0,0 @@
-from datetime import datetime
-import requests
-from typing import List, Optional
-
-from nora_lib.interactions.models import (
-    Event,
-    EventType,
-    ReturnedMessage,
-    ThreadRelationsResponse,
-    ThreadForkEventData,
-    thread_message_lookup_request,
-)
-
-
-class InteractionsService:
-    """
-    Service which saves interactions to the Interactions API
-    """
-
-    def __init__(self, base_url, timeout, token):
-        self.base_url = base_url
-        self.timeout = timeout
-        self.headers = {"Authorization": f"Bearer {token}"}
-
-    def save_event(self, event: Event) -> None:
-        """Save an event to the Interactions API"""
-        event_url = f"{self.base_url}/interaction/v1/event"
-        response = requests.post(
-            event_url,
-            json=event.model_dump(),
-            headers=self.headers,
-            timeout=int(self.timeout),
-        )
-        response.raise_for_status()
-
-    def get_message(self, message_id: str) -> ReturnedMessage:
-        """Fetch a message from the Interactions API"""
-        message_url = f"{self.base_url}/interaction/v1/search/message"
-        request_body = {
-            "id": message_id,
-        }
-        response = requests.post(
-            message_url,
-            json=request_body,
-            headers=self.headers,
-            timeout=int(self.timeout),
-        )
-        response.raise_for_status()
-        res_dict = response.json()["message"]
-
-        return ReturnedMessage.model_validate(res_dict)
-
-    def fetch_thread_messages_and_events_for_message(
-        self, message_id: str, event_type: str
-    ) -> ThreadRelationsResponse:
-        """Fetch messages and associated events from the same thread as provided messagev id"""
-        message_url = f"{self.base_url}/interaction/v1/search/message"
-        request_body = thread_message_lookup_request(message_id, event_type=event_type)
-        response = requests.post(
-            message_url,
-            json=request_body,
-            headers=self.headers,
-            timeout=int(self.timeout),
-        )
-        response.raise_for_status()
-        json_response = response.json()
-
-        return ThreadRelationsResponse.model_validate(
-            json_response.get("message", {}).get("thread", {})
-        )
-
-    def fetch_messages_and_events_for_thread(
-        self,
-        thread_id: str,
-        event_type: Optional[str] = None,
-        min_timestamp: Optional[str] = None,
-    ) -> dict:
-        """Fetch messages and events for the thread containing a given message from the Interactions API"""
-        THREAD_SEARCH_URL = f"{self.base_url}/interaction/v1/search/thread"
-        request_body = {
-            "id": thread_id,
-            "relations": {
-                "messages": (
-                    {"filter": {"min_timestamp": min_timestamp}}
-                    if min_timestamp
-                    else {}
-                ),
-                "events": {"filter": {"type": event_type}} if event_type else {},
-            },
-        }
-
-        response = requests.post(
-            THREAD_SEARCH_URL,
-            json=request_body,
-            headers=self.headers,
-            timeout=int(self.timeout),
-        )
-        response.raise_for_status()
-        return response.json()
-
-    def fetch_messages_and_events_for_forked_thread(
-        self, message_id: str, event_type: str
-    ) -> List[ReturnedMessage]:
-        """Build a history of messages for a given message including associated events.
-        This includes messages from pre-forked threads."""
-        returned_messages: List[ReturnedMessage] = []
-
-        messages_for_thread: ThreadRelationsResponse = (
-            self.fetch_thread_messages_and_events_for_message(message_id, event_type)
-        )
-        if messages_for_thread.messages:
-            returned_messages.extend(messages_for_thread.messages)
-
-        # Lookup any thread_fork events (conversation across surfaces)
-        thread_fork_events = self.fetch_messages_and_events_for_thread(
-            messages_for_thread.thread_id, EventType.THREAD_FORK.value
-        )
-        for forked_thread_event in thread_fork_events.get("thread", {}).get(
-            "events", []
-        ):
-            event_data = ThreadForkEventData.model_validate(
-                forked_thread_event.get("data", {})
-            )
-            forked_thread: ThreadRelationsResponse = (
-                self.fetch_thread_messages_and_events_for_message(
-                    event_data.previous_message_id, event_type
-                )
-            )
-            if forked_thread.messages:
-                returned_messages.extend(forked_thread.messages)
-
-        returned_messages.sort(key=lambda x: datetime.fromisoformat(x.ts))
-
-        return returned_messages