glaip-sdk 0.6.19__py3-none-any.whl → 0.7.27__py3-none-any.whl

glaip_sdk/runner/tool_adapter/langchain_tool_adapter.py

@@ -9,9 +9,10 @@ Authors:
 
 from typing import Any
 
-from glaip_sdk.runner.tool_adapter.base_tool_adapter import BaseToolAdapter
 from gllm_core.utils import LoggerManager
 
+from glaip_sdk.runner.tool_adapter.base_tool_adapter import BaseToolAdapter
+
 logger = LoggerManager().get_logger(__name__)
 
 # Constant for unknown tool name placeholder
@@ -73,8 +74,30 @@ class LangChainToolAdapter(BaseToolAdapter):
         if self._is_langchain_tool(tool_ref):
             return self._instantiate_langchain_tool(tool_ref)
 
-        # 3. Platform tools (not supported)
+        # 3. Native tools with discovered class
         if self._is_platform_tool(tool_ref):
+            # Try to discover local implementation for native tool
+            from glaip_sdk.utils.tool_detection import (  # noqa: PLC0415
+                find_aip_agents_tool_class,
+                get_tool_name,
+            )
+
+            # Get tool name from reference
+            tool_name = get_tool_name(tool_ref) if not isinstance(tool_ref, str) else tool_ref
+
+            if tool_name:
+                discovered_class = find_aip_agents_tool_class(tool_name)
+                if discovered_class:
+                    logger.info("Instantiating native tool locally: %s", tool_name)
+                    try:
+                        return discovered_class()
+                    except TypeError as exc:
+                        raise ValueError(
+                            f"Could not instantiate native tool '{tool_name}'. "
+                            "Ensure it has a zero-argument constructor or adjust the instantiation logic."
+                        ) from exc
+
+            # If no local class found, raise platform tool error
             raise ValueError(self._get_platform_tool_error(tool_ref))
 
         # 4. Unknown type

glaip_sdk/schedules/__init__.py

@@ -0,0 +1,22 @@
+"""Schedules runtime package.
+
+This package contains runtime schedule resource objects (class-based) that
+encapsulate behavior and API interactions via attached clients.
+
+Authors:
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+"""
+
+from glaip_sdk.schedules.base import (
+    Schedule,
+    ScheduleListResult,
+    ScheduleRun,
+    ScheduleRunListResult,
+)
+
+__all__ = [
+    "Schedule",
+    "ScheduleListResult",
+    "ScheduleRun",
+    "ScheduleRunListResult",
+]

glaip_sdk/schedules/base.py

@@ -0,0 +1,291 @@
+"""Schedule runtime resources.
+
+This module contains class-based runtime resources for schedules.
+
+The runtime resources:
+- Are not Pydantic models.
+- Are returned from public client APIs.
+- Delegate API operations to a bound ScheduleClient.
+
+Authors:
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+from glaip_sdk.models.agent_runs import RunStatus
+from glaip_sdk.models.schedule import (
+    ScheduleConfig,
+    ScheduleMetadata,
+    ScheduleResponse,
+    ScheduleRunResponse,
+    ScheduleRunResult,
+)
+
+if TYPE_CHECKING:  # pragma: no cover
+    from glaip_sdk.client.schedules import ScheduleClient
+
+_SCHEDULE_CLIENT_REQUIRED_MSG = "No client available. Use client.schedules.get() to get a client-connected schedule."
+_SCHEDULE_RUN_CLIENT_REQUIRED_MSG = (
+    "No client available. Use client.schedules.list_runs() to get a client-connected schedule run."
+)
+
+
+class Schedule:
+    """Runtime schedule resource.
+
+    Attributes:
+        id (str): The schedule ID.
+        next_run_time (str | None): Next run time as returned by the API.
+        time_until_next_run (str | None): Human readable duration until next run.
+        metadata (ScheduleMetadata | None): Schedule metadata.
+        created_at (datetime | None): Creation timestamp.
+        updated_at (datetime | None): Update timestamp.
+    """
+
+    def __init__(
+        self,
+        *,
+        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,
+        _client: ScheduleClient | None = None,
+    ) -> None:
+        """Initialize a runtime Schedule."""
+        self.id = id
+        self.next_run_time = next_run_time
+        self.time_until_next_run = time_until_next_run
+        self.metadata = metadata
+        self.created_at = created_at
+        self.updated_at = updated_at
+        self._client = _client
+
+    @classmethod
+    def from_response(cls, response: ScheduleResponse, *, client: ScheduleClient) -> Schedule:
+        """Build a runtime Schedule from a DTO response.
+
+        Args:
+            response: Parsed schedule response DTO.
+            client: ScheduleClient to bind.
+
+        Returns:
+            Runtime Schedule.
+        """
+        return cls(
+            id=response.id,
+            next_run_time=response.next_run_time,
+            time_until_next_run=response.time_until_next_run,
+            metadata=response.metadata,
+            created_at=response.created_at,
+            updated_at=response.updated_at,
+            _client=client,
+        )
+
+    @property
+    def agent_id(self) -> str | None:
+        """Agent ID derived from metadata."""
+        return self.metadata.agent_id if self.metadata else None
+
+    @property
+    def input(self) -> str | None:
+        """Input text derived from metadata."""
+        return self.metadata.input if self.metadata else None
+
+    @property
+    def schedule_config(self) -> ScheduleConfig | None:
+        """Schedule configuration derived from metadata."""
+        return self.metadata.schedule if self.metadata else None
+
+    def update(
+        self,
+        *,
+        input: str | None = None,
+        schedule: ScheduleConfig | dict[str, str] | str | None = None,
+    ) -> Schedule:
+        """Update this schedule."""
+        if self._client is None:
+            raise RuntimeError(_SCHEDULE_CLIENT_REQUIRED_MSG)
+        return self._client.update(self.id, input=input, schedule=schedule)
+
+    def delete(self) -> None:
+        """Delete this schedule."""
+        if self._client is None:
+            raise RuntimeError(_SCHEDULE_CLIENT_REQUIRED_MSG)
+        self._client.delete(self.id)
+
+    def list_runs(
+        self,
+        *,
+        status: RunStatus | None = None,
+        limit: int | None = None,
+        page: int | None = None,
+    ) -> ScheduleRunListResult:
+        """List runs for this schedule."""
+        if self._client is None:
+            raise RuntimeError(_SCHEDULE_CLIENT_REQUIRED_MSG)
+        if self.agent_id is None:
+            raise ValueError("Schedule has no agent_id")
+        return self._client.list_runs(
+            self.agent_id,
+            schedule_id=self.id,
+            status=status,
+            limit=limit,
+            page=page,
+        )
+
+    def __repr__(self) -> str:
+        """Return a developer-friendly representation."""
+        parts: list[str] = [f"id={self.id!r}"]
+        if self.agent_id is not None:
+            parts.append(f"agent_id={self.agent_id!r}")
+        if self.next_run_time is not None:
+            parts.append(f"next_run_time={self.next_run_time!r}")
+        if self.time_until_next_run is not None:
+            parts.append(f"time_until_next_run={self.time_until_next_run!r}")
+        if self.created_at is not None:
+            parts.append(f"created_at={self.created_at!r}")
+        return f"Schedule({', '.join(parts)})"
+
+    def __str__(self) -> str:
+        """Return a readable string representation."""
+        return self.__repr__()
+
+
+class ScheduleRun:
+    """Runtime schedule run resource."""
+
+    def __init__(
+        self,
+        *,
+        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,
+        config: ScheduleConfig | dict[str, str] | None = None,
+        created_at: datetime | None = None,
+        updated_at: datetime | None = None,
+        _client: ScheduleClient | None = None,
+    ) -> None:
+        """Initialize a runtime ScheduleRun."""
+        self.id = id
+        self.agent_id = agent_id
+        self.schedule_id = schedule_id
+        self.status = status
+        self.run_type = run_type
+        self.started_at = started_at
+        self.completed_at = completed_at
+        self.input = input
+        self.config = config
+        self.created_at = created_at
+        self.updated_at = updated_at
+        self._client = _client
+
+    @classmethod
+    def from_response(cls, response: ScheduleRunResponse, *, client: ScheduleClient) -> ScheduleRun:
+        """Build a runtime ScheduleRun from a DTO response."""
+        return cls(
+            id=response.id,
+            agent_id=response.agent_id,
+            schedule_id=response.schedule_id,
+            status=response.status,
+            run_type=response.run_type,
+            started_at=response.started_at,
+            completed_at=response.completed_at,
+            input=response.input,
+            config=response.config,
+            created_at=response.created_at,
+            updated_at=response.updated_at,
+            _client=client,
+        )
+
+    def get_result(self) -> ScheduleRunResult:
+        """Retrieve the full output payload for this run."""
+        if self._client is None:
+            raise RuntimeError(_SCHEDULE_RUN_CLIENT_REQUIRED_MSG)
+        if self.agent_id is None:
+            raise ValueError("Schedule run has no agent_id")
+        return self._client.get_run_result(self.agent_id, self.id)
+
+    @property
+    def duration(self) -> str | None:
+        """Formatted duration (HH:MM:SS) when both timestamps are available."""
+        if not self.started_at or not self.completed_at:
+            return None
+
+        total_seconds = int((self.completed_at - self.started_at).total_seconds())
+        minutes, seconds = divmod(total_seconds, 60)
+        hours, minutes = divmod(minutes, 60)
+        return f"{hours:02d}:{minutes:02d}:{seconds:02d}"
+
+    def __repr__(self) -> str:
+        """Return a developer-friendly representation."""
+        parts: list[str] = [f"id={self.id!r}", f"status={self.status!r}"]
+        if self.started_at is not None:
+            parts.append(f"started_at={self.started_at.isoformat()!r}")
+        duration = self.duration
+        if duration is not None:
+            parts.append(f"duration={duration!r}")
+        return f"ScheduleRun({', '.join(parts)})"
+
+    def __str__(self) -> str:
+        """Return a readable string representation."""
+        return self.__repr__()
+
+
+@dataclass
+class ScheduleListResult:
+    """Paginated list wrapper for runtime schedules."""
+
+    items: list[Schedule]
+    total: int | None = field(default=None)
+    page: int | None = field(default=None)
+    limit: int | None = field(default=None)
+    has_next: bool | None = field(default=None)
+    has_prev: bool | None = field(default=None)
+
+    def __iter__(self):
+        """Iterate over schedules."""
+        yield from self.items
+
+    def __len__(self) -> int:
+        """Return the number of schedules in this page."""
+        return self.items.__len__()
+
+    def __getitem__(self, index: int) -> Schedule:
+        """Return the schedule at the given index."""
+        return self.items[index]
+
+
+@dataclass
+class ScheduleRunListResult:
+    """Paginated list wrapper for runtime schedule runs."""
+
+    items: list[ScheduleRun]
+    total: int | None = field(default=None)
+    page: int | None = field(default=None)
+    limit: int | None = field(default=None)
+    has_next: bool | None = field(default=None)
+    has_prev: bool | None = field(default=None)
+
+    def __iter__(self):
+        """Iterate over schedule runs."""
+        yield from self.items
+
+    def __len__(self) -> int:
+        """Return the number of runs in this page."""
+        return self.items.__len__()
+
+    def __getitem__(self, index: int) -> ScheduleRun:
+        """Return the run at the given index."""
+        return self.items[index]

glaip_sdk/tools/base.py

@@ -231,6 +231,9 @@ class Tool:
         Native tools are pre-existing tools on the GL AIP platform
         that don't require uploading (e.g., "time_tool", "web_search").
 
+        For local execution, automatically discovers the corresponding aip_agents.tools
+        class if available. If not found, tool can only be used after deployment.
+
         Args:
             name: The name of the native tool on the platform.
 
@@ -241,7 +244,14 @@ class Tool:
             >>> time_tool = Tool.from_native("time_tool")
             >>> web_search = Tool.from_native("web_search")
         """
-        return cls(name=name, type=ToolType.NATIVE)
+        # Try to discover local implementation for native execution
+        from glaip_sdk.utils.tool_detection import (  # noqa: PLC0415
+            find_aip_agents_tool_class,
+        )
+
+        tool_class = find_aip_agents_tool_class(name)
+
+        return cls(name=name, type=ToolType.NATIVE, tool_class=tool_class)
 
     @classmethod
     def from_langchain(cls, tool_class: type) -> Tool:
@@ -256,6 +266,9 @@ class Tool:
         Returns:
             A Tool reference that will be uploaded during Agent.deploy().
 
+        Raises:
+            ValueError: If the tool class has no valid string 'name' attribute or field.
+
         Example:
             >>> from langchain_core.tools import BaseTool
             >>>
@@ -267,7 +280,34 @@ class Tool:
             >>>
             >>> greeting_tool = Tool.from_langchain(GreetingTool)
         """
-        return cls(tool_class=tool_class, type=ToolType.CUSTOM)
+        # Extract name from tool_class to populate the name attribute
+        tool_name = cls._extract_tool_name(tool_class)
+        return cls(name=tool_name, tool_class=tool_class, type=ToolType.CUSTOM)
+
+    @staticmethod
+    def _extract_tool_name(tool_class: type) -> str:
+        """Extract tool name from a LangChain tool class.
+
+        Args:
+            tool_class: A LangChain BaseTool subclass.
+
+        Returns:
+            The extracted tool name.
+
+        Raises:
+            ValueError: If name cannot be extracted or is not a valid string.
+        """
+        from glaip_sdk.utils.tool_detection import get_tool_name  # noqa: PLC0415
+
+        name = get_tool_name(tool_class)
+        if name:
+            return name
+
+        # If we can't extract the name, raise an error
+        raise ValueError(
+            f"Cannot extract name from tool class {tool_class.__name__}. "
+            f"Ensure the tool class has a 'name' attribute or field with a valid string value."
+        )
 
     def get_import_path(self) -> str | None:
         """Get the import path for custom tools.
@@ -292,15 +332,8 @@ class Tool:
             return self.name
 
         if self.tool_class is not None:
-            # LangChain BaseTool - get name from model_fields
-            if hasattr(self.tool_class, "model_fields"):
-                name_field = self.tool_class.model_fields.get("name")
-                if name_field and name_field.default:
-                    return name_field.default
-
-            # Direct name attribute
-            if hasattr(self.tool_class, "name"):
-                return self.tool_class.name
+            # Reuse extraction logic for consistency
+            return self._extract_tool_name(self.tool_class)
 
         raise ValueError(f"Cannot determine name for tool: {self}")
 
@@ -354,12 +387,22 @@ class Tool:
         if not self._client:
             raise RuntimeError(_CLIENT_NOT_AVAILABLE_MSG)
 
+        # Handle both Client (has .tools) and ToolClient (direct methods)
+        # Priority: Check if client has a 'tools' attribute (Client instance)
+        # Otherwise, use client directly (ToolClient instance)
+        if hasattr(self._client, "tools") and self._client.tools is not None:
+            # Main Client instance - use the tools sub-client
+            tools_client = self._client.tools
+        else:
+            # ToolClient instance - use directly
+            tools_client = self._client
+
         # Check if file upload is requested
         if "file" in kwargs:
             file_path = kwargs.pop("file")
-            response = self._client.tools.update_via_file(self._id, file_path, **kwargs)
+            response = tools_client.update_tool_via_file(self._id, file_path, **kwargs)
         else:
-            response = self._client.tools.update(tool_id=self._id, **kwargs)
+            response = tools_client.update_tool(tool_id=self._id, **kwargs)
 
         # Update local properties from response
         if hasattr(response, "name") and response.name:
@@ -383,7 +426,17 @@ class Tool:
         if not self._client:
             raise RuntimeError(_CLIENT_NOT_AVAILABLE_MSG)
 
-        self._client.tools.delete(tool_id=self._id)
+        # Handle both Client (has .tools) and ToolClient (direct methods)
+        # Priority: Check if client has a 'tools' attribute (Client instance)
+        # Otherwise, use client directly (ToolClient instance)
+        if hasattr(self._client, "tools") and self._client.tools is not None:
+            # Main Client instance - use the tools sub-client
+            tools_client = self._client.tools
+        else:
+            # ToolClient instance - use directly
+            tools_client = self._client
+
+        tools_client.delete_tool(self._id)
         self._id = None
         self._client = None
 

glaip_sdk/utils/__init__.py

@@ -77,6 +77,7 @@ def __getattr__(name: str) -> type:
         "get_client": _client_module,
         "set_client": _client_module,
         "reset_client": _client_module,
+        "tool_detection": "glaip_sdk.utils.tool_detection",
     }
 
     if name in lazy_imports:

glaip_sdk/utils/agent_config.py

@@ -83,7 +83,9 @@ def resolve_language_model_selection(merged_data: dict[str, Any], cli_model: str
     """
     # Priority 1: CLI --model flag
     if cli_model:
-        return {"model": cli_model}, False
+        from glaip_sdk.models._validation import _validate_model  # noqa: PLC0415
+
+        return {"model": _validate_model(cli_model)}, False
 
     # Priority 2: language_model_id from import
     if merged_data.get("language_model_id"):
@@ -92,7 +94,11 @@ def resolve_language_model_selection(merged_data: dict[str, Any], cli_model: str
     # Priority 3: Legacy lm_name from agent_config
     agent_config = merged_data.get("agent_config") or {}
     if isinstance(agent_config, dict) and agent_config.get("lm_name"):
-        return {"model": agent_config["lm_name"]}, True  # Strip LM identity when extracting from agent_config
+        from glaip_sdk.models._validation import _validate_model  # noqa: PLC0415
+
+        return {
+            "model": _validate_model(agent_config["lm_name"])
+        }, True  # Strip LM identity when extracting from agent_config
 
     # No LM selection found
     return {}, False