seekrai 0.5.2__py3-none-any.whl → 0.5.24__py3-none-any.whl

seekrai/abstract/response_parsing.py

@@ -22,6 +22,8 @@ def parse_data_line(line: str) -> str:
 def parse_stream(chunks: Iterator[str]) -> Iterator[Any]:
     buffer = []
     for chunk in chunks:
+        if chunk == "data: [DONE]":
+            break
         content = parse_data_line(chunk)
 
         if content:

seekrai/client.py

@@ -24,6 +24,8 @@ class SeekrFlow:
     deployments: resources.Deployments
     vector_database: resources.VectorDatabase
     agents: resources.Agents
+    observability: resources.AgentObservability
+    explainability: resources.Explainability
 
     # client options
     client: SeekrFlowClient
@@ -89,6 +91,8 @@ class SeekrFlow:
         self.deployments = resources.Deployments(self.client)
         self.vector_database = resources.VectorDatabase(self.client)
         self.agents = resources.Agents(self.client)
+        self.observability = resources.AgentObservability(self.client)
+        self.explainability = resources.Explainability(self.client)
 
 
 class AsyncSeekrFlow:
@@ -105,6 +109,8 @@ class AsyncSeekrFlow:
     deployments: resources.AsyncDeployments
     vector_database: resources.AsyncVectorDatabase
     agents: resources.AsyncAgents
+    observability: resources.AsyncAgentObservability
+    explainability: resources.AsyncExplainability
 
     # client options
     client: SeekrFlowClient
@@ -170,6 +176,8 @@ class AsyncSeekrFlow:
         self.deployments = resources.AsyncDeployments(self.client)
         self.vector_database = resources.AsyncVectorDatabase(self.client)
         self.agents = resources.AsyncAgents(self.client)
+        self.observability = resources.AsyncAgentObservability(self.client)
+        self.explainability = resources.AsyncExplainability(self.client)
 
 
 Client = SeekrFlow

seekrai/resources/__init__.py

@@ -1,9 +1,21 @@
-from seekrai.resources.agents import AgentInference, Agents, AsyncAgents
-from seekrai.resources.alignment import Alignment, AsyncAlignment
+from seekrai.resources.agents import (
+    AgentInference,
+    AgentObservability,
+    Agents,
+    AsyncAgentObservability,
+    AsyncAgents,
+)
+from seekrai.resources.alignment import (
+    Alignment,
+    AsyncAlignment,
+    AsyncSystemPromptResource,
+    SystemPromptResource,
+)
 from seekrai.resources.chat import AsyncChat, Chat
 from seekrai.resources.completions import AsyncCompletions, Completions
 from seekrai.resources.deployments import AsyncDeployments, Deployments
 from seekrai.resources.embeddings import AsyncEmbeddings, Embeddings
+from seekrai.resources.explainability import AsyncExplainability, Explainability
 from seekrai.resources.files import AsyncFiles, Files
 from seekrai.resources.finetune import AsyncFineTuning, FineTuning
 from seekrai.resources.images import AsyncImages, Images
@@ -16,6 +28,8 @@ from seekrai.resources.vectordb import AsyncVectorDatabase, VectorDatabase
 __all__ = [
     "AsyncAlignment",
     "Alignment",
+    "AsyncSystemPromptResource",
+    "SystemPromptResource",
     "AsyncCompletions",
     "Completions",
     "AsyncChat",
@@ -38,7 +52,11 @@ __all__ = [
     "Deployments",
     "AsyncAgents",
     "Agents",
+    "AgentObservability",
+    "AsyncAgentObservability",
     "VectorDatabase",
     "AsyncVectorDatabase",
     "AgentInference",
+    "AsyncExplainability",
+    "Explainability",
 ]

seekrai/resources/agents/__init__.py

@@ -1,5 +1,13 @@
 from seekrai.resources.agents.agent_inference import AgentInference, AsyncAgentInference
+from seekrai.resources.agents.agent_observability import (
+    AgentObservability,
+    AsyncAgentObservability,
+)
 from seekrai.resources.agents.agents import Agents, AsyncAgents
+from seekrai.resources.agents.python_functions import (
+    AsyncCustomFunctions,
+    CustomFunctions,
+)
 from seekrai.resources.agents.threads import AgentThreads, AsyncAgentThreads
 
 
@@ -10,4 +18,8 @@ __all__ = [
     "AsyncAgents",
     "AgentThreads",
     "AsyncAgentThreads",
+    "CustomFunctions",
+    "AsyncCustomFunctions",
+    "AgentObservability",
+    "AsyncAgentObservability",
 ]

seekrai/resources/agents/agent_inference.py

@@ -1,8 +1,9 @@
-from typing import Any, AsyncGenerator, Iterator, Union
+from typing import Any, AsyncGenerator, Iterator, Optional, Union
 
 from seekrai.abstract import api_requestor
 from seekrai.seekrflow_response import SeekrFlowResponse
-from seekrai.types import Run, RunRequest, RunResponse, SeekrFlowRequest
+from seekrai.types import ModelSettings, Run, RunRequest, RunResponse, SeekrFlowRequest
+from seekrai.types.agents.runs import ResponseFormat
 
 
 class AgentInference:
@@ -16,7 +17,10 @@ class AgentInference:
         thread_id: str,
         *,
         stream: bool = False,
-        **model_settings: Any,
+        model_settings: ModelSettings = ModelSettings(),
+        response_format: Optional[Any] = None,
+        group: Optional[str] = "default_group",
+        metadata: Optional[dict[str, str]] = None,
     ) -> Union[RunResponse, Iterator[Any]]:
         """
         Run an inference call on a deployed agent.
@@ -25,13 +29,23 @@ class AgentInference:
             agent_id (str): The unique identifier of the deployed agent.
             thread_id (str): A thread identifier.
             stream (bool, optional): Whether to stream the response. Defaults to False.
-            **model_settings: Additional parameters (such as temperature, max_tokens, etc).
+            model_settings (optional): Additional parameters (such as temperature, max_tokens, etc).
+            response_format: Optional structured output specification. If provided, the LLM will be constrained to return JSON matching this schema.
+            group (str, optional): Label used to associate a group of runs. Defaults to 'default_group'.
+            metadata (dict[str, str], optional): Additional metadata used to label runs. Defaults to None.
 
         Returns:
             A dictionary with the response (if non-streaming) or an iterator over response chunks.
         """
-        payload = RunRequest(agent_id=agent_id).model_dump()
-        payload.update(model_settings)
+        payload = RunRequest(
+            agent_id=agent_id,
+            model_settings=model_settings,
+            response_format=ResponseFormat.from_value(response_format)
+            if response_format
+            else None,
+            group=group,
+            metadata=metadata,
+        ).model_dump()
         endpoint = f"threads/{thread_id}/runs"
         if stream:
             endpoint += "/stream"
@@ -146,7 +160,10 @@ class AsyncAgentInference:
         thread_id: str,
         *,
         stream: bool = False,
-        **model_settings: Any,
+        model_settings: ModelSettings = ModelSettings(),
+        response_format: Optional[Any] = None,
+        group: Optional[str] = "default_group",
+        metadata: Optional[dict[str, str]] = None,
     ) -> Union[RunResponse, AsyncGenerator[Any, None]]:
         """
         Run an inference call on a deployed agent.
@@ -155,13 +172,23 @@ class AsyncAgentInference:
             agent_id (str): The unique identifier of the deployed agent.
             thread_id (str): A thread identifier.
             stream (bool, optional): Whether to stream the response. Defaults to False.
-            **model_settings: Additional parameters (such as temperature, max_tokens, etc).
+            model_settings (optional): Additional parameters (such as temperature, max_tokens, etc).
+            response_format: Optional structured output specification. If provided, the LLM will be constrained to return JSON matching this schema.
+            group (str, optional): Label used to associate a group of runs. Defaults to 'default_group'.
+            metadata (dict[str, str], optional): Additional metadata used to label runs. Defaults to None.
 
         Returns:
             A dictionary with the response (if non-streaming) or an iterator over response chunks.
         """
-        payload = RunRequest(agent_id=agent_id).model_dump()
-        payload.update(model_settings)
+        payload = RunRequest(
+            agent_id=agent_id,
+            model_settings=model_settings,
+            response_format=ResponseFormat.from_value(response_format)
+            if response_format
+            else None,
+            group=group,
+            metadata=metadata,
+        ).model_dump()
         endpoint = f"threads/{thread_id}/runs"
         if stream:
             endpoint += "/stream"

seekrai/resources/agents/agent_observability.py

@@ -0,0 +1,135 @@
+from datetime import datetime
+from typing import Any, Optional
+
+from seekrai.abstract import api_requestor
+from seekrai.seekrflow_response import SeekrFlowResponse
+from seekrai.types import SeekrFlowRequest
+from seekrai.types.agents.observability import (
+    ObservabilitySpansRequest,
+    ObservabilitySpansResponse,
+)
+
+
+BASE_OBSERVABILITY_ENDPOINT = "observability/spans"
+
+
+class AgentObservability:
+    def __init__(self, client: Any):
+        self._client = client
+        self._requestor = api_requestor.APIRequestor(client=self._client)
+
+    def query_spans(
+        self,
+        min_start_time: Optional[datetime] = None,
+        max_start_time: Optional[datetime] = None,
+        agent_id: Optional[str] = None,
+        run_id: Optional[str] = None,
+        trace_id: Optional[str] = None,
+        thread_id: Optional[str] = None,
+        group: Optional[str] = None,
+        metadata: Optional[dict[str, str]] = None,
+        limit: int = 100,
+        order: str = "desc",
+        offset: int = 0,
+    ) -> ObservabilitySpansResponse:
+        """
+        Retrieve spans for a given run or group of runs given a set of facets.
+        """
+        payload = ObservabilitySpansRequest(
+            min_start_datetime=min_start_time,
+            max_start_datetime=max_start_time,
+            agent_id=agent_id,
+            run_id=run_id,
+            trace_id=trace_id,
+            thread_id=thread_id,
+            group=group,
+            metadata=metadata,
+            limit=limit,
+            order=order,
+            offset=offset,
+        ).model_dump()
+
+        response, _, _ = self._requestor.request(
+            options=SeekrFlowRequest(
+                method="POST", url=BASE_OBSERVABILITY_ENDPOINT, params=payload
+            )
+        )
+
+        assert isinstance(response, SeekrFlowResponse)
+
+        return ObservabilitySpansResponse(spans=response.data)
+
+    def retrieve_span(self, span_id: str) -> Optional[dict[str, Any]]:
+        """
+        Retrieve a specific span given a span_id.
+        """
+        endpoint = f"{BASE_OBSERVABILITY_ENDPOINT}/{span_id}"
+
+        response, _, _ = self._requestor.request(
+            options=SeekrFlowRequest(method="GET", url=endpoint)
+        )
+
+        assert isinstance(response, SeekrFlowResponse)
+
+        return response.data
+
+
+class AsyncAgentObservability:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+        self._requestor = api_requestor.APIRequestor(client=self._client)
+
+    async def query_spans(
+        self,
+        min_start_time: Optional[datetime] = None,
+        max_start_time: Optional[datetime] = None,
+        agent_id: Optional[str] = None,
+        run_id: Optional[str] = None,
+        trace_id: Optional[str] = None,
+        thread_id: Optional[str] = None,
+        group: Optional[str] = None,
+        metadata: Optional[dict[str, str]] = None,
+        limit: int = 100,
+        order: str = "desc",
+        offset: int = 0,
+    ) -> ObservabilitySpansResponse:
+        """
+        Retrieve spans for a given run or group of runs given a set of facets.
+        """
+        payload = ObservabilitySpansRequest(
+            min_start_datetime=min_start_time,
+            max_start_datetime=max_start_time,
+            agent_id=agent_id,
+            run_id=run_id,
+            trace_id=trace_id,
+            thread_id=thread_id,
+            group=group,
+            metadata=metadata,
+            limit=limit,
+            order=order,
+            offset=offset,
+        ).model_dump()
+
+        response, _, _ = await self._requestor.arequest(
+            options=SeekrFlowRequest(
+                method="POST", url=BASE_OBSERVABILITY_ENDPOINT, params=payload
+            )
+        )
+
+        assert isinstance(response, SeekrFlowResponse)
+
+        return ObservabilitySpansResponse(spans=response.data)
+
+    async def retrieve_span(self, span_id: str) -> Optional[dict[str, Any]]:
+        """
+        Retrieve a specific span given a span_id.
+        """
+        endpoint = f"{BASE_OBSERVABILITY_ENDPOINT}/{span_id}"
+
+        response, _, _ = self._requestor.request(
+            options=SeekrFlowRequest(method="GET", url=endpoint)
+        )
+
+        assert isinstance(response, SeekrFlowResponse)
+
+        return response.data

seekrai/resources/agents/agents.py

@@ -1,5 +1,9 @@
 from seekrai.abstract import api_requestor
 from seekrai.resources.agents.agent_inference import AgentInference, AsyncAgentInference
+from seekrai.resources.agents.python_functions import (
+    AsyncCustomFunctions,
+    CustomFunctions,
+)
 from seekrai.resources.agents.threads import AgentThreads, AsyncAgentThreads
 from seekrai.seekrflow_response import SeekrFlowResponse
 from seekrai.types import SeekrFlowClient, SeekrFlowRequest
@@ -7,6 +11,7 @@ from seekrai.types.agents.agent import (
     Agent,
     AgentDeleteResponse,
     CreateAgentRequest,
+    UpdateAgentRequest,
 )
 
 
@@ -18,6 +23,7 @@ class Agents:
         )
         self.runs = AgentInference(client)
         self.threads = AgentThreads(client)
+        self.custom_functions = CustomFunctions(client)
 
     def retrieve(self, agent_id: str) -> Agent:
         """
@@ -140,6 +146,28 @@ class Agents:
         assert isinstance(response, SeekrFlowResponse)
         return AgentDeleteResponse(**response.data)
 
+    def update(self, agent_id: str, request: UpdateAgentRequest) -> Agent:
+        """
+        Update an existing agent's configuration.
+
+        Args:
+            agent_id: The ID of the agent to update.
+            request: The request object containing updated agent config.
+
+        Returns:
+            The updated agent.
+        """
+        response, _, _ = self._requestor.request(
+            options=SeekrFlowRequest(
+                method="PUT",
+                url=f"flow/agents/{agent_id}/update",
+                params=request.model_dump(),
+            ),
+        )
+
+        assert isinstance(response, SeekrFlowResponse)
+        return Agent(**response.data)
+
 
 class AsyncAgents:
     def __init__(self, client: SeekrFlowClient) -> None:
@@ -149,6 +177,7 @@ class AsyncAgents:
         )
         self.runs = AsyncAgentInference(client)
         self.threads = AsyncAgentThreads(client)
+        self.custom_functions = AsyncCustomFunctions(client)
 
     async def retrieve(self, agent_id: str) -> Agent:
         """
@@ -270,3 +299,25 @@ class AsyncAgents:
 
         assert isinstance(response, SeekrFlowResponse)
         return AgentDeleteResponse(**response.data)
+
+    async def update(self, agent_id: str, request: UpdateAgentRequest) -> Agent:
+        """
+        Update an existing agent's configuration.
+
+        Args:
+            agent_id: The ID of the agent to update.
+            request: The request object containing updated agent config.
+
+        Returns:
+            The updated agent.
+        """
+        response, _, _ = await self._requestor.arequest(
+            options=SeekrFlowRequest(
+                method="PUT",
+                url=f"flow/agents/{agent_id}/update",
+                params=request.model_dump(),
+            ),
+        )
+
+        assert isinstance(response, SeekrFlowResponse)
+        return Agent(**response.data)