glaip-sdk 0.0.20__py3-none-any.whl → 0.7.7__py3-none-any.whl

glaip_sdk/models/common.py

@@ -0,0 +1,42 @@
+"""Common models for AIP SDK.
+
+This module contains common models that don't fit into specific categories.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+"""
+
+from pydantic import BaseModel
+
+
+class LanguageModelResponse(BaseModel):
+    """Language model response model."""
+
+    name: str
+    provider: str
+    description: str | None = None
+    capabilities: list[str] | None = None
+    max_tokens: int | None = None
+    supports_streaming: bool = False
+
+
+class TTYRenderer:
+    """Simple TTY renderer for non-Rich environments."""
+
+    def __init__(self, use_color: bool = True):
+        """Initialize the TTY renderer.
+
+        Args:
+            use_color: Whether to use color output
+        """
+        self.use_color = use_color
+
+    def render_message(self, message: str, event_type: str = "message") -> None:
+        """Render a message with optional color."""
+        if event_type == "error":
+            print(f"ERROR: {message}", flush=True)
+        elif event_type == "done":
+            print(f"\n✅ {message}", flush=True)
+        else:
+            print(message, flush=True)

glaip_sdk/models/mcp.py

@@ -0,0 +1,33 @@
+"""MCP response model for AIP SDK.
+
+This module contains the Pydantic model for MCP API responses.
+This is a pure data model with no runtime behavior.
+
+For the runtime MCP class with update/delete methods, use glaip_sdk.mcps.MCP.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+"""
+
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class MCPResponse(BaseModel):
+    """Pydantic model for MCP API responses.
+
+    This is a pure data model for deserializing API responses.
+    It does NOT have runtime methods (update, delete, get_tools).
+
+    For the runtime MCP class, use glaip_sdk.mcps.MCP.
+    """
+
+    id: str
+    name: str
+    description: str | None = None
+    config: dict[str, Any] | None = None
+    transport: str | None = None  # "sse" or "http"
+    authentication: dict[str, Any] | None = None
+    metadata: dict[str, Any] | None = None

glaip_sdk/models/schedule.py

@@ -0,0 +1,224 @@
+#!/usr/bin/env python3
+"""Schedule DTO models for AIP SDK.
+
+These models represent API payloads and responses. They are intentionally DTO-only
+and do not contain runtime behavior.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+"""
+
+from datetime import datetime
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict
+
+from glaip_sdk.models.agent_runs import RunStatus
+
+
+class ScheduleConfig(BaseModel):
+    """Cron-like schedule configuration matching backend ScheduleConfig.
+
+    All fields accept cron-style values:
+    - Specific values: "0", "9", "1"
+    - Wildcards: "*"
+    - Intervals: "*/5", "*/2"
+    - Ranges: "1-5", "9-17"
+    - Lists: "1,3,5"
+
+    Note: day_of_week uses 0-6 where 0=Monday.
+    """
+
+    minute: str = "*"
+    hour: str = "*"
+    day_of_month: str = "*"
+    month: str = "*"
+    day_of_week: str = "*"
+
+    model_config = ConfigDict(from_attributes=True)
+
+    def to_cron_string(self) -> str:
+        """Convert to standard cron string format.
+
+        Returns:
+            Cron string in format "minute hour day_of_month month day_of_week"
+        """
+        return f"{self.minute} {self.hour} {self.day_of_month} {self.month} {self.day_of_week}"
+
+    @classmethod
+    def from_cron_string(cls, cron: str) -> "ScheduleConfig":
+        """Parse a cron string into ScheduleConfig.
+
+        Args:
+            cron: Cron string in format "minute hour day_of_month month day_of_week"
+
+        Returns:
+            ScheduleConfig instance
+
+        Raises:
+            ValueError: If cron string doesn't have exactly 5 fields
+        """
+        parts = cron.split()
+        if len(parts) != 5:
+            raise ValueError(f"Invalid cron string: expected 5 fields, got {len(parts)}")
+        return cls(
+            minute=parts[0],
+            hour=parts[1],
+            day_of_month=parts[2],
+            month=parts[3],
+            day_of_week=parts[4],
+        )
+
+
+class ScheduleMetadata(BaseModel):
+    """Metadata embedded in schedule responses.
+
+    Contains the agent association, input text, and cron configuration.
+    """
+
+    agent_id: str
+    input: str
+    schedule: ScheduleConfig
+
+    model_config = ConfigDict(from_attributes=True)
+
+
+class ScheduleResponse(BaseModel):
+    """Schedule response DTO.
+
+    Attributes:
+        id: Schedule ID.
+        next_run_time: Next run time as returned by the API.
+        time_until_next_run: Human-readable duration until next run.
+        metadata: Schedule metadata.
+        created_at: Creation timestamp.
+        updated_at: Update timestamp.
+        agent_id: Agent ID derived from metadata.
+        input: Input text derived from metadata.
+        schedule_config: ScheduleConfig derived from metadata.
+    """
+
+    id: str
+    next_run_time: str | None = None
+    time_until_next_run: str | None = None
+    metadata: ScheduleMetadata | None = None
+    created_at: datetime | None = None
+    updated_at: datetime | None = None
+
+    model_config = ConfigDict(from_attributes=True)
+
+    @property
+    def agent_id(self) -> str | None:
+        """Get the agent ID from metadata."""
+        return self.metadata.agent_id if self.metadata else None
+
+    @property
+    def input(self) -> str | None:
+        """Get the scheduled input text from metadata."""
+        return self.metadata.input if self.metadata else None
+
+    @property
+    def schedule_config(self) -> ScheduleConfig | None:
+        """Get the schedule configuration from metadata."""
+        return self.metadata.schedule if self.metadata else None
+
+    def __repr__(self) -> str:
+        """Return a readable representation of the schedule."""
+        parts = [f"ScheduleResponse(id={self.id!r}"]
+        if self.next_run_time:
+            parts.append(f"next_run_time={self.next_run_time!r}")
+        if self.time_until_next_run:
+            parts.append(f"time_until_next_run={self.time_until_next_run!r}")
+        if self.agent_id:
+            parts.append(f"agent_id={self.agent_id!r}")
+        if self.created_at:
+            parts.append(f"created_at={self.created_at!r}")
+        return ", ".join(parts) + ")"
+
+    def __str__(self) -> str:
+        """Return a readable string representation."""
+        return self.__repr__()
+
+
+# Type alias for SSE event dictionaries
+ScheduleRunOutputChunk = dict[str, Any]
+
+
+class ScheduleRunResponse(BaseModel):
+    """Schedule run response DTO."""
+
+    id: str
+    agent_id: str
+    schedule_id: str | None = None  # May be None for non-scheduled runs
+    status: RunStatus  # Backend uses lowercase.
+    run_type: str | None = None  # "schedule" for scheduled runs
+    started_at: datetime | None = None
+    completed_at: datetime | None = None
+    input: str | None = None  # Input used for the execution.
+    config: ScheduleConfig | dict[str, str] | None = None  # Schedule config used.
+    created_at: datetime | None = None
+    updated_at: datetime | None = None
+
+    model_config = ConfigDict(from_attributes=True, extra="ignore")
+
+    @property
+    def duration(self) -> str | None:
+        """Calculate the duration of the run.
+
+        Returns:
+            Formatted duration string (HH:MM:SS) or None if incomplete
+        """
+        if self.started_at and self.completed_at:
+            delta = self.completed_at - self.started_at
+            total_seconds = int(delta.total_seconds())
+            hours, remainder = divmod(total_seconds, 3600)
+            minutes, seconds = divmod(remainder, 60)
+            return f"{hours:02d}:{minutes:02d}:{seconds:02d}"
+        return None
+
+    def __repr__(self) -> str:
+        """Return a readable representation of the run."""
+        parts = [f"ScheduleRunResponse(id={self.id!r}"]
+        parts.append(f"status={self.status!r}")
+        if self.started_at:
+            parts.append(f"started_at={self.started_at.isoformat()!r}")
+        if self.duration:
+            parts.append(f"duration={self.duration!r}")
+        return ", ".join(parts) + ")"
+
+    def __str__(self) -> str:
+        """Return a readable string representation."""
+        return self.__repr__()
+
+
+class ScheduleRunResult(BaseModel):
+    """Full output payload for a schedule run.
+
+    Maps to the backend's AgentRunWithOutputResponse which includes
+    run metadata plus the output stream.
+    """
+
+    id: str
+    agent_id: str
+    schedule_id: str | None = None
+    status: RunStatus
+    run_type: str | None = None
+    started_at: datetime | None = None
+    completed_at: datetime | None = None
+    input: str | None = None  # Input used for the execution.
+    config: ScheduleConfig | dict[str, str] | None = None  # Schedule config used.
+    output: list[ScheduleRunOutputChunk] | None = None
+    created_at: datetime | None = None
+    updated_at: datetime | None = None
+
+    model_config = ConfigDict(from_attributes=True, extra="ignore")
+
+    def __repr__(self) -> str:
+        """Return a readable representation of the result."""
+        output_count = len(self.output) if self.output else 0
+        return f"ScheduleRunResult(id={self.id!r}, status={self.status!r}, output_chunks={output_count})"
+
+    def __str__(self) -> str:
+        """Return a readable string representation."""
+        return self.__repr__()

glaip_sdk/models/tool.py

@@ -0,0 +1,33 @@
+"""Tool response model for AIP SDK.
+
+This module contains the Pydantic model for Tool API responses.
+This is a pure data model with no runtime behavior.
+
+For the runtime Tool class with update/delete methods, use glaip_sdk.tools.Tool.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+"""
+
+from pydantic import BaseModel
+
+
+class ToolResponse(BaseModel):
+    """Pydantic model for Tool API responses.
+
+    This is a pure data model for deserializing API responses.
+    It does NOT have runtime methods (update, delete, get_script).
+
+    For the runtime Tool class, use glaip_sdk.tools.Tool.
+    """
+
+    id: str
+    name: str
+    tool_type: str | None = None
+    description: str | None = None
+    framework: str | None = None
+    version: str | None = None
+    tool_script: str | None = None
+    tool_file: str | None = None
+    tags: str | list[str] | None = None

glaip_sdk/payload_schemas/__init__.py

@@ -4,16 +4,4 @@ Authors:
     Raymond Christopher (raymond.christopher@gdplabs.id)
 """
 
-from glaip_sdk.payload_schemas.agent import (
-    AgentImportOperation,
-    ImportFieldPlan,
-    get_import_field_plan,
-    list_server_only_fields,
-)
-
-__all__ = [
-    "AgentImportOperation",
-    "ImportFieldPlan",
-    "get_import_field_plan",
-    "list_server_only_fields",
-]
+__all__: list[str] = []

glaip_sdk/payload_schemas/agent.py

@@ -60,9 +60,7 @@ AGENT_FIELD_RULES: Mapping[str, FieldRule] = {
 }
 
 
-def get_import_field_plan(
-    field_name: str, operation: AgentImportOperation
-) -> ImportFieldPlan:
+def get_import_field_plan(field_name: str, operation: AgentImportOperation) -> ImportFieldPlan:
     """Return the import handling plan for ``field_name`` under ``operation``.
 
     Unknown fields default to being copied as-is so new API fields propagate

glaip_sdk/registry/__init__.py

@@ -0,0 +1,55 @@
+"""Registry package for GL AIP platform.
+
+This package provides registries that cache platform objects to avoid
+redundant API calls when deploying multi-agent systems.
+
+Example:
+    >>> from glaip_sdk.registry import get_agent_registry, get_tool_registry
+    >>> agent_registry = get_agent_registry()
+    >>> tool_registry = get_tool_registry()
+"""
+
+from __future__ import annotations
+
+import importlib
+from typing import TYPE_CHECKING
+
+from glaip_sdk.registry.base import BaseRegistry
+
+# Lazy imports to avoid circular dependencies
+if TYPE_CHECKING:  # pragma: no cover
+    from glaip_sdk.registry.agent import AgentRegistry, get_agent_registry
+    from glaip_sdk.registry.mcp import MCPRegistry, get_mcp_registry
+    from glaip_sdk.registry.tool import ToolRegistry, get_tool_registry
+
+__all__ = [
+    "BaseRegistry",
+    "AgentRegistry",
+    "get_agent_registry",
+    "ToolRegistry",
+    "get_tool_registry",
+    "MCPRegistry",
+    "get_mcp_registry",
+]
+
+
+def __getattr__(name: str) -> type:
+    """Lazy import to avoid circular dependencies."""
+    _agent_module = "glaip_sdk.registry.agent"
+    _tool_module = "glaip_sdk.registry.tool"
+    _mcp_module = "glaip_sdk.registry.mcp"
+
+    lazy_imports = {
+        "AgentRegistry": _agent_module,
+        "get_agent_registry": _agent_module,
+        "ToolRegistry": _tool_module,
+        "get_tool_registry": _tool_module,
+        "MCPRegistry": _mcp_module,
+        "get_mcp_registry": _mcp_module,
+    }
+
+    if name in lazy_imports:
+        module = importlib.import_module(lazy_imports[name])
+        return getattr(module, name)
+
+    raise AttributeError(f"module 'glaip_sdk.registry' has no attribute '{name}'")

glaip_sdk/registry/agent.py

@@ -0,0 +1,164 @@
+"""Agent registry for glaip_sdk.
+
+This module provides the AgentRegistry that caches deployed agents
+to avoid redundant API calls when deploying multi-agent systems.
+
+Authors:
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+from glaip_sdk.registry.base import BaseRegistry
+
+if TYPE_CHECKING:
+    from glaip_sdk.agents import Agent
+
+logger = logging.getLogger(__name__)
+
+
+class AgentRegistry(BaseRegistry["Agent"]):
+    """Registry for agents.
+
+    Resolves agent references to glaip_sdk.models.Agent objects.
+    Caches results to avoid redundant API calls and duplicate deployments.
+
+    Handles:
+        - glaip_sdk.agents.Agent classes → deploy, cache, return Agent
+        - glaip_sdk.agents.Agent instances → deploy, cache, return Agent
+        - glaip_sdk.models.Agent → return as-is (uses agent.id)
+        - String names → lookup on platform, cache, return Agent
+
+    Attributes:
+        _cache: Internal cache mapping names to Agent objects.
+
+    Example:
+        >>> registry = get_agent_registry()
+        >>> agent = registry.resolve(GreeterAgent)  # Returns deployed Agent
+        >>> print(agent.id)   # "uuid-123"
+        >>> print(agent.name) # "greeter_agent"
+    """
+
+    def _extract_name(self, ref: Any) -> str:
+        """Extract agent name from a reference.
+
+        Args:
+            ref: An agent class, instance, or string name.
+
+        Returns:
+            The extracted agent name.
+
+        Raises:
+            ValueError: If name cannot be extracted from the reference.
+        """
+        # Lazy import to avoid circular dependency
+        from glaip_sdk.agents.base import Agent  # noqa: PLC0415
+
+        # Agent class
+        if isinstance(ref, type) and issubclass(ref, Agent):
+            return ref().name
+
+        # Agent instance
+        if isinstance(ref, Agent):
+            return ref.name
+
+        # Already deployed agent (glaip_sdk.models.Agent)
+        if hasattr(ref, "id") and hasattr(ref, "name") and not isinstance(ref, type):
+            return ref.name
+
+        # String name
+        if isinstance(ref, str):
+            return ref
+
+        raise ValueError(f"Cannot extract name from: {ref}")
+
+    def _resolve_and_cache(self, ref: Any, name: str) -> Agent:
+        """Resolve agent reference - deploy if class/instance, find if string.
+
+        Args:
+            ref: The agent reference to resolve.
+            name: The extracted agent name.
+
+        Returns:
+            The resolved glaip_sdk.models.Agent object.
+
+        Raises:
+            ValueError: If the agent cannot be resolved.
+        """
+        # Lazy imports to avoid circular dependency
+        from glaip_sdk.agents.base import Agent  # noqa: PLC0415
+        from glaip_sdk.utils.discovery import find_agent  # noqa: PLC0415
+
+        # Agent class
+        if isinstance(ref, type) and issubclass(ref, Agent):
+            logger.info("Deploying Agent class: %s", name)
+            deployed = ref().deploy()
+            self._cache[name] = deployed
+            return deployed
+
+        # Agent instance
+        if isinstance(ref, Agent):
+            logger.info("Deploying Agent instance: %s", name)
+            deployed = ref.deploy()
+            self._cache[name] = deployed
+            return deployed
+
+        # Already deployed agent (glaip_sdk.models.Agent) - just cache and return
+        if hasattr(ref, "id") and hasattr(ref, "name") and not isinstance(ref, type):
+            logger.debug("Caching already deployed agent: %s", name)
+            self._cache[name] = ref
+            return ref
+
+        # String name - look up on platform
+        if isinstance(ref, str):
+            logger.info("Looking up agent by name: %s", name)
+            agent = find_agent(name)
+            if agent:
+                self._cache[name] = agent
+                return agent
+            raise ValueError(f"Agent not found on platform: {name}")
+
+        raise ValueError(f"Could not resolve agent reference: {ref}")
+
+
+class _AgentRegistrySingleton:
+    """Singleton holder for AgentRegistry to avoid global statement."""
+
+    _instance: AgentRegistry | None = None
+
+    @classmethod
+    def get_instance(cls) -> AgentRegistry:
+        """Get or create the singleton instance.
+
+        Returns:
+            The global AgentRegistry instance.
+        """
+        if cls._instance is None:
+            cls._instance = AgentRegistry()
+        return cls._instance
+
+    @classmethod
+    def reset(cls) -> None:
+        """Reset the singleton instance (for testing)."""
+        cls._instance = None
+
+
+def get_agent_registry() -> AgentRegistry:
+    """Get the singleton AgentRegistry instance.
+
+    Returns a global AgentRegistry that caches agents across the session.
+    Use this function to get the registry instead of creating instances directly.
+
+    Returns:
+        The global AgentRegistry instance.
+
+    Example:
+        >>> from glaip_sdk.registry import get_agent_registry
+        >>> registry = get_agent_registry()
+        >>> agent = registry.resolve("weather_agent")
+        >>> print(agent.name)
+    """
+    return _AgentRegistrySingleton.get_instance()