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

planar/_version.py

@@ -1 +1 @@
-VERSION = "0.8.0"
+VERSION = "0.9.1"

planar/ai/agent.py

@@ -7,19 +7,20 @@ from pydantic_ai import models
 
 from planar.ai.agent_base import AgentBase
 from planar.ai.agent_utils import (
-    AgentEventType,
     ModelSpec,
-    ToolCallResult,
     create_tool_definition,
     extract_files_from_model,
     get_agent_config,
     render_template,
 )
 from planar.ai.models import (
+    AgentEventEmitter,
+    AgentEventType,
     AgentRunResult,
     AssistantMessage,
     ModelMessage,
     SystemMessage,
+    ToolCallResult,
     ToolDefinition,
     ToolMessage,
     ToolResponse,
@@ -29,10 +30,22 @@ from planar.ai.pydantic_ai import ModelRunResponse, model_run
 from planar.logging import get_logger
 from planar.utils import utc_now
 from planar.workflows.models import StepType
+from planar.workflows.notifications import agent_text, agent_think
 
 logger = get_logger(__name__)
 
 
+class AgentWorkflowNotifier(AgentEventEmitter):
+    def emit(self, event_type, data):
+        match event_type:
+            case AgentEventType.THINK:
+                agent_think(str(data))
+            case AgentEventType.TEXT:
+                agent_text(str(data))
+            case _:
+                ...
+
+
 @dataclass
 class Agent[
     TInput: BaseModel | str,
@@ -53,7 +66,10 @@ class Agent[
         Returns:
             AgentRunResult containing the agent's response
         """
-        event_emitter = self.event_emitter
+        if self.event_emitter:
+            event_emitter = self.event_emitter
+        else:
+            event_emitter = AgentWorkflowNotifier()
         logger.debug(
             "agent run_step called", agent_name=self.name, input_type=type(input_value)
         )

planar/ai/agent_base.py

@@ -13,11 +13,7 @@ from typing import (
 
 from pydantic import BaseModel
 
-from planar.ai.agent_utils import AgentEventEmitter
-from planar.ai.models import (
-    AgentConfig,
-    AgentRunResult,
-)
+from planar.ai.models import AgentConfig, AgentEventEmitter, AgentRunResult
 from planar.logging import get_logger
 from planar.modeling.field_helpers import JsonSchema
 from planar.utils import P, R, T, U

planar/ai/agent_utils.py

@@ -1,8 +1,4 @@
-import asyncio
 import inspect
-import json
-from collections.abc import AsyncGenerator
-from enum import Enum
 from typing import (
     Any,
     Callable,
@@ -20,7 +16,6 @@ from planar.ai.models import (
 from planar.files.models import PlanarFile
 from planar.logging import get_logger
 from planar.object_config import ConfigurableObjectType, ObjectConfigurationIO
-from planar.utils import utc_now
 from planar.workflows import step
 
 logger = get_logger(__name__)
@@ -33,73 +28,6 @@ class ModelSpec(BaseModel):
     parameters: dict[str, Any] = {}
 
 
-class AgentEventType(str, Enum):
-    """Valid event types that can be emitted by an Agent."""
-
-    RESPONSE = "response"
-    TOOL_RESPONSE = "tool_response"
-    COMPLETED = "completed"
-    ERROR = "error"
-    THINK = "think"
-    TEXT = "text"
-
-
-class AgentEvent:
-    def __init__(
-        self,
-        event_type: AgentEventType,
-        data: BaseModel | str | None,
-    ):
-        self.event_type = event_type
-        self.data = data
-        self.timestamp = utc_now().isoformat()
-
-
-class AgentEventEmitter:
-    def __init__(self):
-        self.queue: asyncio.Queue[AgentEvent] = asyncio.Queue()
-
-    def emit(self, event_type: AgentEventType, data: BaseModel | str | None):
-        event = AgentEvent(event_type, data)
-        self.queue.put_nowait(event)
-
-    async def get_events(self) -> AsyncGenerator[str, None]:
-        while True:
-            event = await self.queue.get()
-
-            if isinstance(event.data, BaseModel):
-                data = {
-                    "data": event.data.model_dump(),
-                    "event_type": event.event_type,
-                }
-            else:
-                data = {
-                    "data": event.data,
-                    "event_type": event.event_type,
-                }
-
-            yield f"data: {json.dumps(data)}\n\n"
-
-            self.queue.task_done()
-
-            if event.event_type in (AgentEventType.COMPLETED, AgentEventType.ERROR):
-                break
-
-    def is_empty(self) -> bool:
-        """Check if the queue is empty."""
-        return self.queue.empty()
-
-
-# Define JsonData type as a union of valid JSON values
-JsonData = str | int | float | bool | None | dict[str, Any] | list[Any]
-
-
-class ToolCallResult(BaseModel):
-    tool_call_id: str
-    tool_call_name: str
-    content: BaseModel | JsonData
-
-
 def extract_files_from_model(
     model: BaseModel | str | None,
 ) -> list[PlanarFile]:

planar/ai/models.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from enum import Enum
 from typing import (
     Annotated,
     Any,
@@ -7,6 +8,7 @@ from typing import (
     List,
     Literal,
     Optional,
+    Protocol,
     TypeVar,
     Union,
 )
@@ -88,10 +90,23 @@ class ToolMessage(ModelMessage):
     tool_call_id: str  # ID of the tool call this is responding to
 
 
+# Define JsonData type as a union of valid JSON values
+JsonData = str | int | float | bool | None | dict[str, Any] | list[Any]
+
+
+class ToolCallResult(BaseModel):
+    tool_call_id: str
+    tool_call_name: str
+    content: BaseModel | JsonData
+
+
 class CompletionResponse[T: BaseModel | str](BaseModel):
     """Response object that may contain content or tool calls."""
 
     content: Optional[T] = None  # Content as str or parsed Pydantic model
+    text_content: Optional[str] = (
+        None  # Optional text content, if separate from structured output
+    )
     reasoning_content: Optional[str] = None  # Optional reasoning content
     tool_calls: Optional[List[ToolCall]] = None  # List of tool calls, if any
 
@@ -138,3 +153,18 @@ class AgentSerializeable(BaseModel):
 
     # TODO: actually fetch built_in_vars from agent object
     built_in_vars: dict[str, str] = Field(default_factory=dict)
+
+
+class AgentEventType(str, Enum):
+    """Valid event types that can be emitted by an Agent."""
+
+    RESPONSE = "response"
+    TOOL_RESPONSE = "tool_response"
+    COMPLETED = "completed"
+    ERROR = "error"
+    THINK = "think"
+    TEXT = "text"
+
+
+class AgentEventEmitter(Protocol):
+    def emit(self, event_type: AgentEventType, data: BaseModel | str | None): ...

planar/ai/pydantic_ai.py

@@ -3,7 +3,7 @@ import json
 import os
 import re
 import textwrap
-from typing import Any, Literal, Protocol, Type, cast
+from typing import Any, Type, cast
 
 from pydantic import BaseModel, ValidationError
 from pydantic_ai import BinaryContent
@@ -265,10 +265,6 @@ async def prepare_messages(
     return pydantic_messages
 
 
-class StreamEventHandler(Protocol):
-    def emit(self, event: Literal["text", "think"], data: str) -> None: ...
-
-
 def setup_native_structured_output(
     request_params: ModelRequestParameters,
     output_type: Type[BaseModel],
@@ -330,12 +326,14 @@ def return_native_structured_output[TOutput: BaseModel](
         result = m.CompletionResponse(
             content=output_type.model_validate_json(content),
             tool_calls=final_tool_calls,
+            text_content=content,
             reasoning_content=thinking,
         )
         logger.info(
             "model run completed with structured output",
             content=result.content,
             reasoning_content=result.reasoning_content,
+            text_content=content,
             tool_calls=result.tool_calls,
         )
         return result
@@ -359,6 +357,7 @@ def return_tool_structured_output[TOutput: BaseModel](
         result = m.CompletionResponse(
             content=output_type.model_validate(final_result_tc.arguments),
             tool_calls=tool_calls,
+            text_content=content,
             reasoning_content=thinking,
         )
         logger.info(
@@ -388,7 +387,7 @@ async def model_run[TOutput: BaseModel | str](
     model_settings: dict[str, Any] | None = None,
     messages: list[m.ModelMessage] = [],
     tools: list[m.ToolDefinition] = [],
-    event_handler: StreamEventHandler | None = None,
+    event_handler: m.AgentEventEmitter | None = None,
     output_type: Type[TOutput] = str,
 ) -> ModelRunResponse[TOutput]:
     # assert that the caller doesn't provide a tool called "final_result"
@@ -418,7 +417,7 @@ async def model_run[TOutput: BaseModel | str](
 
     structured_output = issubclass(output_type, BaseModel)
 
-    def emit(event_type: Literal["text", "think"], content: str):
+    def emit(event_type: m.AgentEventType, content: str):
         if event_handler:
             event_handler.emit(event_type, content)
 
@@ -451,10 +450,10 @@ async def model_run[TOutput: BaseModel | str](
                     case PartStartEvent(part=part):
                         response_parts.append(part)
                         if isinstance(part, TextPart):
-                            emit("text", part.content)
+                            emit(m.AgentEventType.TEXT, part.content)
                             text_buffer.append(part.content)
                         elif isinstance(part, ThinkingPart):
-                            emit("think", part.content)
+                            emit(m.AgentEventType.THINK, part.content)
                             think_buffer.append(part.content)
                         elif isinstance(part, ToolCallPart):
                             if current_tool_call is not None:
@@ -480,14 +479,14 @@ async def model_run[TOutput: BaseModel | str](
                         current = response_parts[-1]
                         if isinstance(delta, TextPartDelta):
                             assert isinstance(current, TextPart)
-                            emit("text", delta.content_delta)
+                            emit(m.AgentEventType.TEXT, delta.content_delta)
                             text_buffer.append(delta.content_delta)
                             current.content += delta.content_delta
                         elif (
                             isinstance(delta, ThinkingPartDelta) and delta.content_delta
                         ):
                             assert isinstance(current, ThinkingPart)
-                            emit("think", delta.content_delta)
+                            emit(m.AgentEventType.THINK, delta.content_delta)
                             think_buffer.append(delta.content_delta)
                             current.content += delta.content_delta
                         elif isinstance(delta, ToolCallPartDelta):
@@ -547,6 +546,7 @@ async def model_run[TOutput: BaseModel | str](
             return ModelRunResponse(
                 response=m.CompletionResponse(
                     tool_calls=final_tool_calls,
+                    text_content=content,
                     reasoning_content=thinking,
                 ),
                 extra_turns_used=extra_turns_used,
@@ -623,6 +623,7 @@ async def model_run[TOutput: BaseModel | str](
             m.CompletionResponse(
                 content=content,
                 tool_calls=final_tool_calls,
+                text_content=content,
                 reasoning_content=thinking,
             ),
         )

planar/app.py

@@ -37,7 +37,6 @@ from planar.security.authorization import PolicyService, policy_service_context
 from planar.session import config_var, session_context
 from planar.sse.proxy import SSEProxy
 from planar.workflows import (
-    Workflow,
     WorkflowNotification,
     WorkflowNotificationCallback,
     WorkflowOrchestrator,
@@ -81,7 +80,10 @@ class PlanarApp:
         )
         self.policy_service: PolicyService | None = None
 
-        self.db_manager = DatabaseManager(db_url=self.config.connection_url())
+        self.db_manager = DatabaseManager(
+            db_url=self.config.connection_url(),
+            entity_schema=self.config.app.entity_schema,
+        )
 
         if self.config.storage:
             self.storage = create_from_config(self.config.storage)
@@ -169,13 +171,8 @@ class PlanarApp:
             return
 
         def on_workflow_notification(notification: WorkflowNotification):
-            workflow_id = (
-                notification.data.id
-                if isinstance(notification.data, Workflow)
-                else notification.data.workflow_id
-            )
             self.sse_proxy.push(
-                f"{notification.kind.value}:{workflow_id}",
+                f"{notification.kind.value}:{notification.workflow_id}",
                 notification.data.model_dump(mode="json"),
             )
 
@@ -226,9 +223,7 @@ class PlanarApp:
 
         # Begin the normal lifespan logic
         self.db_manager.connect()
-        await self.db_manager.migrate(
-            self.config.use_alembic if self.config.use_alembic is not None else True
-        )
+        await self.db_manager.migrate()
 
         self.orchestrator = WorkflowOrchestrator(self.db_manager.get_engine())
         config_tok = config_var.set(self.config)

planar/config.py

@@ -21,6 +21,7 @@ from pydantic import (
 )
 from sqlalchemy import URL, make_url
 
+from planar.data.config import DataConfig
 from planar.files.storage.config import LocalDirectoryConfig, StorageConfig
 from planar.logging import get_logger
 
@@ -126,6 +127,10 @@ DatabaseConfig = Annotated[
 class AppConfig(BaseModel):
     db_connection: str
     max_db_conflict_retries: int | None = None
+    # Default schema for user-defined entities (PlanarBaseEntity)
+    # Postgres: used as the target schema for user tables
+    # SQLite: ignored (SQLite has no schemas)
+    entity_schema: str = "planar_entity"
 
 
 def default_storage_config() -> StorageConfig:
@@ -223,8 +228,8 @@ class PlanarConfig(BaseModel):
     environment: Environment = Environment.DEV
     security: SecurityConfig = SecurityConfig()
     logging: dict[str, LoggerConfig] | None = None
-    use_alembic: bool | None = True
     otel: OtelConfig | None = None
+    data: DataConfig | None = None
 
     # forbid extra keys in the config to prevent accidental misconfiguration
     model_config = ConfigDict(extra="forbid")

planar/data/__init__.py

@@ -0,0 +1,17 @@
+from typing import TYPE_CHECKING
+
+from planar.dependencies import lazy_exports
+
+lazy_exports(
+    __name__,
+    {
+        "PlanarDataset": (".dataset", "PlanarDataset"),
+    },
+)
+
+if TYPE_CHECKING:
+    from .dataset import PlanarDataset
+
+    __all__ = [
+        "PlanarDataset",
+    ]

planar/data/config.py

@@ -0,0 +1,49 @@
+"""Configuration for Planar data module."""
+
+from typing import Annotated, Literal
+
+from pydantic import BaseModel, Field
+
+from planar.files.storage.config import StorageConfig
+
+
+class DuckDBCatalogConfig(BaseModel):
+    """Configuration for DuckDB catalog backend."""
+
+    type: Literal["duckdb"]
+    path: str  # Path to .ducklake file
+
+
+class PostgresCatalogConfig(BaseModel):
+    """Configuration for PostgreSQL catalog backend."""
+
+    type: Literal["postgres"]
+    host: str | None = None
+    port: int | None = None
+    user: str | None = None
+    password: str | None = None
+    db: str
+
+
+class SQLiteCatalogConfig(BaseModel):
+    """Configuration for SQLite catalog backend."""
+
+    type: Literal["sqlite"]
+    path: str  # Path to .sqlite file
+
+
+# Discriminated union for catalog configurations
+CatalogConfig = Annotated[
+    DuckDBCatalogConfig | PostgresCatalogConfig | SQLiteCatalogConfig,
+    Field(discriminator="type"),
+]
+
+
+class DataConfig(BaseModel):
+    """Configuration for data features."""
+
+    catalog: CatalogConfig
+    storage: StorageConfig  # Reuse existing StorageConfig from files
+
+    # Optional settings
+    catalog_name: str = "planar_data"  # Default catalog name in Ducklake