planar 0.7.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

planar/ai/agent_base.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+import abc
+from dataclasses import dataclass, field
+from typing import (
+    Any,
+    Callable,
+    Coroutine,
+    Type,
+    cast,
+    overload,
+)
+
+from pydantic import BaseModel
+
+from planar.ai.agent_utils import AgentEventEmitter
+from planar.ai.models import (
+    AgentConfig,
+    AgentRunResult,
+)
+from planar.logging import get_logger
+from planar.modeling.field_helpers import JsonSchema
+from planar.utils import P, R, T, U
+from planar.workflows import as_step
+from planar.workflows.models import StepType
+
+logger = get_logger(__name__)
+
+
+@dataclass
+class AgentBase[
+    # TODO: add `= str` default when we upgrade to 3.13
+    TInput: BaseModel | str,
+    TOutput: BaseModel | str,
+](abc.ABC):
+    """An LLM-powered agent that can be called directly within workflows."""
+
+    name: str
+    system_prompt: str
+    output_type: Type[TOutput] | None = None
+    input_type: Type[TInput] | None = None
+    user_prompt: str = ""
+    tools: list[Callable] = field(default_factory=list)
+    max_turns: int = 2
+    model_parameters: dict[str, Any] = field(default_factory=dict)
+    event_emitter: AgentEventEmitter | None = None
+    durable: bool = True
+
+    # TODO: move here to serialize to frontend
+    #
+    # built_in_vars: Dict[str, str] = field(default_factory=lambda: {
+    #     "datetime_now": datetime.datetime.now().isoformat(),
+    #     "date_today": datetime.date.today().isoformat(),
+    # })
+
+    def __post_init__(self):
+        if self.input_type:
+            if (
+                not issubclass(self.input_type, BaseModel)
+                and self.input_type is not str
+            ):
+                raise ValueError(
+                    "input_type must be 'str' or a subclass of a Pydantic model"
+                )
+        if self.max_turns < 1:
+            raise ValueError("Max_turns must be greater than or equal to 1.")
+        if self.tools and self.max_turns <= 1:
+            raise ValueError(
+                "For tool calling to work, max_turns must be greater than 1."
+            )
+
+    def input_schema(self) -> JsonSchema | None:
+        if self.input_type is None:
+            return None
+        if self.input_type is str:
+            return None
+        assert issubclass(self.input_type, BaseModel), (
+            "input_type must be a subclass of BaseModel or str"
+        )
+        return self.input_type.model_json_schema()
+
+    def output_schema(self) -> JsonSchema | None:
+        if self.output_type is None:
+            return None
+        if self.output_type is str:
+            return None
+        assert issubclass(self.output_type, BaseModel), (
+            "output_type must be a subclass of BaseModel or str"
+        )
+        return self.output_type.model_json_schema()
+
+    @overload
+    async def __call__(
+        self: "AgentBase[TInput, str]",
+        input_value: TInput,
+    ) -> AgentRunResult[str]: ...
+
+    @overload
+    async def __call__(
+        self: "AgentBase[TInput, TOutput]",
+        input_value: TInput,
+    ) -> AgentRunResult[TOutput]: ...
+
+    def as_step_if_durable(
+        self,
+        func: Callable[P, Coroutine[T, U, R]],
+        step_type: StepType,
+        display_name: str | None = None,
+        return_type: Type[R] | None = None,
+    ) -> Callable[P, Coroutine[T, U, R]]:
+        if not self.durable:
+            return func
+        return as_step(
+            func,
+            step_type=step_type,
+            display_name=display_name or self.name,
+            return_type=return_type,
+        )
+
+    async def __call__(
+        self,
+        input_value: TInput,
+    ) -> AgentRunResult[Any]:
+        if self.input_type is not None and not isinstance(input_value, self.input_type):
+            raise ValueError(
+                f"Input value must be of type {self.input_type}, but got {type(input_value)}"
+            )
+        elif not isinstance(input_value, (str, BaseModel)):
+            # Should not happen based on type constraints, but just in case
+            # user does not have type checking enabled
+            raise ValueError(
+                "Input value must be a string or a Pydantic model if input_type is not provided"
+            )
+
+        if self.output_type is None:
+            run_step = self.as_step_if_durable(
+                self.run_step,
+                step_type=StepType.AGENT,
+                display_name=self.name,
+                return_type=AgentRunResult[str],
+            )
+        else:
+            run_step = self.as_step_if_durable(
+                self.run_step,
+                step_type=StepType.AGENT,
+                display_name=self.name,
+                return_type=AgentRunResult[self.output_type],
+            )
+
+        result = await run_step(input_value=input_value)
+        # Cast the result to ensure type compatibility
+        return cast(AgentRunResult[TOutput], result)
+
+    @abc.abstractmethod
+    async def run_step(
+        self,
+        input_value: TInput,
+    ) -> AgentRunResult[TOutput]: ...
+
+    @abc.abstractmethod
+    def get_model_str(self) -> str: ...
+
+    def to_config(self) -> AgentConfig:
+        return AgentConfig(
+            system_prompt=self.system_prompt,
+            user_prompt=self.user_prompt,
+            model=self.get_model_str(),
+            max_turns=self.max_turns,
+            model_parameters=self.model_parameters,
+        )

planar/ai/agent_utils.py

@@ -26,6 +26,13 @@ from planar.workflows import step
 logger = get_logger(__name__)
 
 
+class ModelSpec(BaseModel):
+    """Pydantic model for AI model specifications."""
+
+    model_id: str
+    parameters: dict[str, Any] = {}
+
+
 class AgentEventType(str, Enum):
     """Valid event types that can be emitted by an Agent."""
 

planar/ai/pydantic_ai.py

@@ -1,5 +1,6 @@
 import base64
 import json
+import os
 import re
 import textwrap
 from typing import Any, Literal, Protocol, Type, cast
@@ -28,12 +29,13 @@ from pydantic_ai.messages import (
     UserContent,
     UserPromptPart,
 )
-from pydantic_ai.models import Model, ModelRequestParameters
+from pydantic_ai.models import KnownModelName, Model, ModelRequestParameters
 from pydantic_ai.settings import ModelSettings
 from pydantic_ai.tools import ToolDefinition
 from pydantic_core import ErrorDetails
 
 from planar.ai import models as m
+from planar.files.models import PlanarFile
 from planar.logging import get_logger
 from planar.utils import partition
 
@@ -67,7 +69,65 @@ def format_validation_errors(errors: list[ErrorDetails], function: bool) -> str:
     return "\n".join(lines)
 
 
-async def build_file_map(messages: list[m.ModelMessage]) -> m.FileMap:
+async def openai_try_upload_file(
+    model: KnownModelName | Model, file: PlanarFile
+) -> m.FileIdContent | None:
+    # Currently pydanticAI doesn't support passing file_ids, but leaving the
+    # implementation here for when they add support.
+    return None
+
+    if file.content_type != "application/pdf":
+        # old implementation only does this for pdf files, so keep the behavior for now
+        return None
+
+    if isinstance(model, str) and not model.startswith("openai:"):
+        # not using openai provider
+        return None
+
+    try:
+        # make this code work with openai as optional dependency
+        from pydantic_ai.models.openai import OpenAIModel
+    except ImportError:
+        return None
+
+    if os.getenv("OPENAI_BASE_URL", None) is not None:
+        # cannot use OpenAI file upload if using a custom base url
+        return None
+
+    if (
+        isinstance(model, OpenAIModel)
+        and model.client.base_url.host != "api.openai.com"
+    ):
+        # same as above
+        return None
+
+    logger.debug("uploading pdf file to openai", filename=file.filename)
+
+    # use a separate AsyncClient instance since the model might be provided as a string
+    from openai import AsyncClient
+
+    client = AsyncClient()
+
+    # upload the file to the provider
+    openai_file = await client.files.create(
+        file=(
+            file.filename,
+            await file.get_content(),
+            file.content_type,
+        ),
+        purpose="user_data",
+    )
+    logger.info(
+        "uploaded pdf file to openai",
+        filename=file.filename,
+        openai_file_id=openai_file.id,
+    )
+    return m.FileIdContent(content=openai_file.id)
+
+
+async def build_file_map(
+    model: KnownModelName | Model, messages: list[m.ModelMessage]
+) -> m.FileMap:
     logger.debug("building file map", num_messages=len(messages))
     file_dict = {}
 
@@ -86,6 +146,12 @@ async def build_file_map(messages: list[m.ModelMessage]) -> m.FileMap:
                     content_type=file.content_type,
                 )
 
+                file_content_id = await openai_try_upload_file(model, file)
+                # TODO: add more `try_upload_file` implementations for other providers that support
+                if file_content_id is not None:
+                    file_dict[str(file.id)] = file_content_id
+                    continue
+
                 # For now we are not using uploaded files with Gemini, so convert all to base64
                 if file.content_type.startswith(
                     ("image/", "audio/", "video/", "application/pdf")
@@ -107,7 +173,9 @@ async def build_file_map(messages: list[m.ModelMessage]) -> m.FileMap:
     return m.FileMap(mapping=file_dict)
 
 
-async def prepare_messages(messages: list[m.ModelMessage]) -> list[Any]:
+async def prepare_messages(
+    model: KnownModelName | Model, messages: list[m.ModelMessage]
+) -> list[Any]:
     """Prepare messages from Planar representations into the format expected by PydanticAI.
 
     Args:
@@ -118,7 +186,7 @@ async def prepare_messages(messages: list[m.ModelMessage]) -> list[Any]:
         List of messages in PydanticAI format
     """
     pydantic_messages: list[ModelMessage] = []
-    file_map = await build_file_map(messages)
+    file_map = await build_file_map(model, messages)
 
     def append_request_part(part: ModelRequestPart):
         last = (
@@ -315,7 +383,7 @@ class ModelRunResponse[TOutput: BaseModel | str](BaseModel):
 
 
 async def model_run[TOutput: BaseModel | str](
-    model: Model | str,
+    model: Model | KnownModelName,
     max_extra_turns: int,
     model_settings: dict[str, Any] | None = None,
     messages: list[m.ModelMessage] = [],
@@ -354,7 +422,7 @@ async def model_run[TOutput: BaseModel | str](
         if event_handler:
             event_handler.emit(event_type, content)
 
-    history = await prepare_messages(messages=messages)
+    history = await prepare_messages(model, messages=messages)
 
     if structured_output:
         if supports_native_structured_output:

planar/ai/test_agent_serialization.py

@@ -56,7 +56,7 @@ def test_agent_with_tools():
         name="test_agent_with_tools",
         system_prompt="System with tools",
         user_prompt="User: {input}",
-        model="anthropic:claude-3-sonnet",
+        model="anthropic:claude-3-5-sonnet-latest",
         max_turns=5,
         tools=[test_tool],
     )

planar/routers/test_agents_router.py

@@ -42,7 +42,7 @@ def app_fixture():
         name="agent_with_tools",
         system_prompt="System with tools",
         user_prompt="User: {input}",
-        model="anthropic:claude-3-sonnet",
+        model="anthropic:claude-3-5-sonnet-latest",
         max_turns=5,
         tools=[test_tool],
     )

{planar-0.7.0.dist-info → planar-0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: planar
-Version: 0.7.0
+Version: 0.8.0
 Summary: Add your description here
 License-Expression: LicenseRef-Proprietary
 Requires-Python: >=3.12

{planar-0.7.0.dist-info → planar-0.8.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 planar/__init__.py,sha256=FAYRGjuJOH2Y_XYFA0-BrRFjuKdPzIShNbaYwJbtu6A,499
-planar/_version.py,sha256=3acS1SXu-uxuFh9KAe5eEzbrP7hTsqs8yTGli2vtXKk,18
+planar/_version.py,sha256=dZWiMFvyJ9WmUBmP_1Yn0Ze7otmWd3MrPYqf8mefKr4,18
 planar/app.py,sha256=SKIpNY1K6NFF4_20kDxT40BIfJotiyhjNPwjU7P8_Ek,18695
 planar/cli.py,sha256=2ObR5XkLGbdbnDqp5mrBzDVhSacHCNsVNSHnXkrMQzQ,9593
 planar/config.py,sha256=NHNrvJl8h1QkUHUxZ96Th_v1TSxoxf8u0C4CA1VBr2k,17557
@@ -16,15 +16,12 @@ planar/test_sqlalchemy.py,sha256=F0aKqm5tStQj_Mqjh50kiLX4r7kphBFDOUDu_Iw7S3s,557
 planar/test_utils.py,sha256=gKenXotj36SN_bb3bQpYPfD8t06IjnGBQqEgWpujHcA,3086
 planar/utils.py,sha256=v7q9AJyWgQWl9VPSN_0qxw3rBvYe-_Pb_KcwqSsjOFU,3103
 planar/ai/__init__.py,sha256=ABOKvqQOLlVJkptcvXcuLjVZZWEsK8h-1RyFGK7kib8,231
-planar/ai/agent.py,sha256=ROLNF8iLxuceOHKynw34lqlwz2IWbzgtgFVCacHu7Iw,17728
-planar/ai/agent_utils.py,sha256=uwU5w5qXcCNO7CPOINSP5kMZMy2bRaVTSLPQvGiwPLI,5827
+planar/ai/agent.py,sha256=kcrFLQzIU7QPGNjgl_7irP1jJOReHs8EYz8-_H_TV0A,11929
+planar/ai/agent_base.py,sha256=X4Gl4PmxyxD_HLnVyxK7fnhKgmudznrGwcv5nMzAXWs,5349
+planar/ai/agent_utils.py,sha256=r7WGGMs5fCo5MlLX5vPlA9ry0mMzpSuf4Ro6Gnvp2TQ,5966
 planar/ai/models.py,sha256=Rxvt00kCaQzbU59LcYDegK7kV8qYTRVH3YhU3ufuJCY,3532
-planar/ai/providers.py,sha256=eXVDx-8manGKXVN0b5TDLWI2QfTAtnjLMitneQ21LhI,41400
-planar/ai/pydantic_ai.py,sha256=OtN0ZPp-66JVqgzXyRQuovhvMbScgerV6pv2yUvd6BA,21266
-planar/ai/pydantic_ai_agent.py,sha256=iNJQIiJHKm0u029BTubyTPedNUoUrAMZrSWUM1MjZVA,11951
-planar/ai/test_agent.py,sha256=B_eHcycNRQ_43-H_mTXsRyyvTYUCqu8ickPCTkYcXcE,44429
-planar/ai/test_agent_serialization.py,sha256=LZlgk147A8OM5DPuSLjEjVy16N4vdaAQvXv_8OJDSK4,8064
-planar/ai/test_providers.py,sha256=JEaIr0ex-02ij8Tl5X4vAfsAbp7nV2I0Wj0wIu6MBRQ,16282
+planar/ai/pydantic_ai.py,sha256=IAVavvbqp7KIUpwFQwWf5hXtsxn2yMxIjl2NjeL3EsE,23423
+planar/ai/test_agent_serialization.py,sha256=zYLIxhYdFhOZzBrEBoQNyYLyNcNxWwaMTkjt_ARTkZk,8073
 planar/ai/utils.py,sha256=WVBW0TGaoKytC4bNd_a9lXrBf5QsDRut4GBcA53U2Ww,3116
 planar/db/__init__.py,sha256=SNgB6unQ1f1E9dB9O-KrsPsYM17KLsgOW1u0ajqs57I,318
 planar/db/alembic.ini,sha256=8G9IWbmF61Vwp1BXbkNOXTTgCEUMBQhOK_e-nnpnSYY,4309
@@ -82,7 +79,7 @@ planar/routers/info.py,sha256=HQa-mumw4zitG61V9isJlZ3cMr8pEwlB54Ct_LrpJDo,4473
 planar/routers/models.py,sha256=RwXjXpJw2uyluM4Fjc34UA0Jm7J95cUjbmTTarD_P9k,4669
 planar/routers/object_config_router.py,sha256=zA8-gGBQp1-Gm3uCC4WJ6nLicFwt4CsCqCYLFp1lRN8,4802
 planar/routers/rule.py,sha256=d6giUwYRKzxQFPeoWbe8Ylp2Cxd71_uK8yoS9NrOOBg,3563
-planar/routers/test_agents_router.py,sha256=ZOc18sp5v8fWjjaNKV3BmWQzufo8LUtIOzLBUkHSFlg,6073
+planar/routers/test_agents_router.py,sha256=d_d_lZT5zuSxNY2MEu51SmgLRGNZ3yCpGUooAXLpEaY,6082
 planar/routers/test_files_router.py,sha256=_uYpRJkxSxyjFJAG7aj3letx25iDSkaOgZDTRHfU8TU,1559
 planar/routers/test_object_config_router.py,sha256=HBOsQZXccPuWOLCPxEsduSd93loswUsbSk3eTM6KHRc,11389
 planar/routers/test_routes_security.py,sha256=DsyEbpaNsLGTE_aWhs_KyePJxw2qTBviP2Tn-GZj3T8,5508
@@ -163,7 +160,7 @@ planar/workflows/test_suspend_deserialization.py,sha256=ddw2jToSJ-ebQ0RfT7KWTRMC
 planar/workflows/test_workflow.py,sha256=KArm9m44IBXKY9j4v_O74MAweFN6jEb7tVRomziaeFU,64011
 planar/workflows/tracing.py,sha256=E7E_kj2VBQisDqrllviIshbvOmB9QcEeRwMapunqio4,2732
 planar/workflows/wrappers.py,sha256=KON6RGg1D6yStboNbuMEeTXRpPTEa8S6Elh1tOnMAlM,1149
-planar-0.7.0.dist-info/METADATA,sha256=k2JmBunmIPOgko0N6hsfbD0YdbXCY7dujm9F2pNosQw,12020
-planar-0.7.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-planar-0.7.0.dist-info/entry_points.txt,sha256=ZtFgrZ0eeoVmhLA51ESipK0nHg2t_prjW0Cm8WhpP54,95
-planar-0.7.0.dist-info/RECORD,,
+planar-0.8.0.dist-info/METADATA,sha256=D4RMLkoOUDNlZgbuEjMrnTjV4ga6FHJ3ZtxeC2uUe6A,12020
+planar-0.8.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+planar-0.8.0.dist-info/entry_points.txt,sha256=ZtFgrZ0eeoVmhLA51ESipK0nHg2t_prjW0Cm8WhpP54,95
+planar-0.8.0.dist-info/RECORD,,