oagi-core 0.9.0__py3-none-any.whl → 0.9.2__py3-none-any.whl

oagi/__init__.py

@@ -7,7 +7,6 @@
 # -----------------------------------------------------------------------------
 import importlib
 
-from oagi.async_single_step import async_single_step
 from oagi.client import AsyncClient, SyncClient
 from oagi.exceptions import (
     APIError,
@@ -21,8 +20,7 @@ from oagi.exceptions import (
     ServerError,
     ValidationError,
 )
-from oagi.single_step import single_step
-from oagi.task import AsyncShortTask, AsyncTask, ShortTask, Task
+from oagi.task import Actor, AsyncActor, AsyncShortTask, AsyncTask, ShortTask, Task
 from oagi.types import (
     AsyncActionHandler,
     AsyncImageProvider,
@@ -33,12 +31,12 @@ from oagi.types.models import ErrorDetail, ErrorResponse, LLMResponse
 # Lazy imports for pyautogui-dependent modules
 # These will only be imported when actually accessed
 _LAZY_IMPORTS = {
-    "AsyncPyautoguiActionHandler": "oagi.async_pyautogui_action_handler",
-    "AsyncScreenshotMaker": "oagi.async_screenshot_maker",
-    "PILImage": "oagi.pil_image",
-    "PyautoguiActionHandler": "oagi.pyautogui_action_handler",
-    "PyautoguiConfig": "oagi.pyautogui_action_handler",
-    "ScreenshotMaker": "oagi.screenshot_maker",
+    "AsyncPyautoguiActionHandler": "oagi.handler.async_pyautogui_action_handler",
+    "AsyncScreenshotMaker": "oagi.handler.async_screenshot_maker",
+    "PILImage": "oagi.handler.pil_image",
+    "PyautoguiActionHandler": "oagi.handler.pyautogui_action_handler",
+    "PyautoguiConfig": "oagi.handler.pyautogui_action_handler",
+    "ScreenshotMaker": "oagi.handler.screenshot_maker",
     # Agent modules (to avoid circular imports)
     "TaskerAgent": "oagi.agent.tasker",
     # Server modules (optional - requires server dependencies)
@@ -59,18 +57,17 @@ def __getattr__(name: str):
 
 __all__ = [
     # Core sync classes
-    "Task",
-    "ShortTask",
+    "Actor",
+    "AsyncActor",
+    "Task",  # Deprecated: Use Actor instead
+    "ShortTask",  # Deprecated
     "SyncClient",
     # Core async classes
-    "AsyncTask",
-    "AsyncShortTask",
+    "AsyncTask",  # Deprecated: Use AsyncActor instead
+    "AsyncShortTask",  # Deprecated
     "AsyncClient",
     # Agent classes
     "TaskerAgent",
-    # Functions
-    "single_step",
-    "async_single_step",
     # Async protocols
     "AsyncActionHandler",
     "AsyncImageProvider",

oagi/agent/default.py

@@ -8,10 +8,11 @@
 
 import logging
 
-from .. import AsyncTask
+from .. import AsyncActor
 from ..types import (
     AsyncActionHandler,
     AsyncImageProvider,
+    AsyncStepObserver,
 )
 
 logger = logging.getLogger(__name__)
@@ -24,15 +25,17 @@ class AsyncDefaultAgent:
         self,
         api_key: str | None = None,
         base_url: str | None = None,
-        model: str = "lux-v1",
-        max_steps: int = 30,
-        temperature: float | None = None,
+        model: str = "lux-actor-1",
+        max_steps: int = 20,
+        temperature: float | None = 0.5,
+        step_observer: AsyncStepObserver | None = None,
     ):
         self.api_key = api_key
         self.base_url = base_url
         self.model = model
         self.max_steps = max_steps
         self.temperature = temperature
+        self.step_observer = step_observer
 
     async def execute(
         self,
@@ -40,11 +43,11 @@ class AsyncDefaultAgent:
         action_handler: AsyncActionHandler,
         image_provider: AsyncImageProvider,
     ) -> bool:
-        async with AsyncTask(
+        async with AsyncActor(
             api_key=self.api_key, base_url=self.base_url, model=self.model
-        ) as self.task:
+        ) as self.actor:
             logger.info(f"Starting async task execution: {instruction}")
-            await self.task.init_task(instruction, max_steps=self.max_steps)
+            await self.actor.init_task(instruction, max_steps=self.max_steps)
 
             for i in range(self.max_steps):
                 logger.debug(f"Executing step {i + 1}/{self.max_steps}")
@@ -53,15 +56,28 @@ class AsyncDefaultAgent:
                 image = await image_provider()
 
                 # Get next step from OAGI
-                step = await self.task.step(image, temperature=self.temperature)
+                step = await self.actor.step(image, temperature=self.temperature)
 
                 # Log reasoning
                 if step.reason:
-                    logger.debug(f"Step {i + 1} reasoning: {step.reason}")
+                    logger.info(f"Step {i + 1}: {step.reason}")
+
+                # Notify observer if present
+                if self.step_observer:
+                    await self.step_observer.on_step(i + 1, step.reason, step.actions)
 
                 # Execute actions if any
                 if step.actions:
-                    logger.debug(f"Executing {len(step.actions)} actions")
+                    logger.info(f"Actions ({len(step.actions)}):")
+                    for action in step.actions:
+                        count_suffix = (
+                            f" x{action.count}"
+                            if action.count and action.count > 1
+                            else ""
+                        )
+                        logger.info(
+                            f"  [{action.type.value}] {action.argument}{count_suffix}"
+                        )
                     await action_handler(step.actions)
 
                 # Check if task is complete

oagi/agent/factories.py

@@ -6,6 +6,7 @@
 #  Licensed under the MIT License.
 # -----------------------------------------------------------------------------
 from oagi.agent.tasker import TaskerAgent
+from oagi.types import AsyncStepObserver
 
 from .default import AsyncDefaultAgent
 from .protocol import AsyncAgent
@@ -19,6 +20,7 @@ def create_default_agent(
     model: str = "lux-v1",
     max_steps: int = 20,
     temperature: float = 0.1,
+    step_observer: AsyncStepObserver | None = None,
 ) -> AsyncAgent:
     return AsyncDefaultAgent(
         api_key=api_key,
@@ -26,6 +28,7 @@ def create_default_agent(
         model=model,
         max_steps=max_steps,
         temperature=temperature,
+        step_observer=step_observer,
     )
 
 
@@ -37,6 +40,7 @@ def create_planner_agent(
     max_steps: int = 30,
     temperature: float = 0.0,
     reflection_interval: int = 20,
+    step_observer: AsyncStepObserver | None = None,
 ) -> AsyncAgent:
     tasker = TaskerAgent(
         api_key=api_key,
@@ -45,6 +49,7 @@ def create_planner_agent(
         max_steps=max_steps,
         temperature=temperature,
         reflection_interval=reflection_interval,
+        step_observer=step_observer,
     )
     # tasker.set_task()
     return tasker

oagi/agent/tasker/planner.py

@@ -20,19 +20,28 @@ class Planner:
     This class provides planning and reflection capabilities using OAGI workers.
     """
 
-    def __init__(self, client: AsyncClient | None = None):
+    def __init__(
+        self,
+        client: AsyncClient | None = None,
+        api_key: str | None = None,
+        base_url: str | None = None,
+    ):
         """Initialize the planner.
 
         Args:
             client: AsyncClient for OAGI API calls. If None, one will be created when needed.
+            api_key: API key for creating internal client
+            base_url: Base URL for creating internal client
         """
         self.client = client
+        self.api_key = api_key
+        self.base_url = base_url
         self._owns_client = False  # Track if we created the client
 
     def _ensure_client(self) -> AsyncClient:
         """Ensure we have a client, creating one if needed."""
         if not self.client:
-            self.client = AsyncClient()
+            self.client = AsyncClient(api_key=self.api_key, base_url=self.base_url)
             self._owns_client = True
         return self.client
 

oagi/agent/tasker/taskee_agent.py

@@ -10,8 +10,8 @@ import logging
 from datetime import datetime
 from typing import Any
 
-from oagi import AsyncTask
-from oagi.types import AsyncActionHandler, AsyncImageProvider
+from oagi import AsyncActor
+from oagi.types import AsyncActionHandler, AsyncImageProvider, AsyncStepObserver
 
 from ..protocol import AsyncAgent
 from .memory import PlannerMemory
@@ -35,13 +35,14 @@ class TaskeeAgent(AsyncAgent):
         self,
         api_key: str | None = None,
         base_url: str | None = None,
-        model: str = "lux-v1",
-        max_steps_per_subtask: int = 10,
-        reflection_interval: int = 20,
-        temperature: float = 0.0,
+        model: str = "lux-actor-1",
+        max_steps_per_subtask: int = 20,
+        reflection_interval: int = 4,
+        temperature: float = 0.5,
         planner: Planner | None = None,
         external_memory: PlannerMemory | None = None,
         todo_index: int | None = None,
+        step_observer: AsyncStepObserver | None = None,
     ):
         """Initialize the taskee agent.
 
@@ -55,6 +56,7 @@ class TaskeeAgent(AsyncAgent):
             planner: Planner for planning and reflection
             external_memory: External memory from parent agent
             todo_index: Index of the todo being executed
+            step_observer: Optional observer for step tracking
         """
         self.api_key = api_key
         self.base_url = base_url
@@ -62,12 +64,13 @@ class TaskeeAgent(AsyncAgent):
         self.max_steps_per_subtask = max_steps_per_subtask
         self.reflection_interval = reflection_interval
         self.temperature = temperature
-        self.planner = planner or Planner()
+        self.planner = planner or Planner(api_key=api_key, base_url=base_url)
         self.external_memory = external_memory
         self.todo_index = todo_index
+        self.step_observer = step_observer
 
         # Internal state
-        self.task: AsyncTask | None = None
+        self.actor: AsyncActor | None = None
         self.current_todo: str = ""
         self.current_instruction: str = ""
         self.actions: list[Action] = []
@@ -135,10 +138,10 @@ class TaskeeAgent(AsyncAgent):
             )
             return False
         finally:
-            # Clean up task
-            if self.task:
-                await self.task.close()
-                self.task = None
+            # Clean up actor
+            if self.actor:
+                await self.actor.close()
+                self.actor = None
 
     async def _initial_plan(self, image_provider: AsyncImageProvider) -> None:
         """Generate initial plan for the todo.
@@ -199,17 +202,17 @@ class TaskeeAgent(AsyncAgent):
         logger.info(f"Executing subtask with max {max_steps} steps")
 
         # Use async with for automatic resource management
-        async with AsyncTask(
+        async with AsyncActor(
             api_key=self.api_key,
             base_url=self.base_url,
             model=self.model,
             temperature=self.temperature,
-        ) as task:
+        ) as actor:
             # Store reference for potential cleanup in execute's finally block
-            self.task = task
+            self.actor = actor
 
-            # Initialize task with current instruction
-            await task.init_task(self.current_instruction)
+            # Initialize actor with current instruction
+            await actor.init_task(self.current_instruction)
 
             steps_taken = 0
             for step_num in range(max_steps):
@@ -218,7 +221,7 @@ class TaskeeAgent(AsyncAgent):
 
                 # Get next step from OAGI
                 try:
-                    step = await task.step(screenshot, instruction=None)
+                    step = await actor.step(screenshot, instruction=None)
                 except Exception as e:
                     logger.error(f"Error getting step from OAGI: {e}")
                     self._record_action(
@@ -228,8 +231,30 @@ class TaskeeAgent(AsyncAgent):
                     )
                     break
 
+                # Log reasoning
+                if step.reason:
+                    logger.info(f"Step {self.total_actions + 1}: {step.reason}")
+
+                # Notify observer if present
+                if self.step_observer:
+                    await self.step_observer.on_step(
+                        self.total_actions + 1, step.reason, step.actions
+                    )
+
                 # Record OAGI actions
                 if step.actions:
+                    # Log actions with details
+                    logger.info(f"Actions ({len(step.actions)}):")
+                    for action in step.actions:
+                        count_suffix = (
+                            f" x{action.count}"
+                            if action.count and action.count > 1
+                            else ""
+                        )
+                        logger.info(
+                            f"  [{action.type.value}] {action.argument}{count_suffix}"
+                        )
+
                     for action in step.actions:
                         self._record_action(
                             action_type=action.type.lower(),
@@ -255,9 +280,9 @@ class TaskeeAgent(AsyncAgent):
                     logger.info("Reflection interval reached")
                     break
 
-            # Task will be automatically closed by async with context manager
+            # Actor will be automatically closed by async with context manager
             # Clear reference after context manager closes it
-            self.task = None
+            self.actor = None
             return steps_taken
 
     async def _reflect_and_decide(self, image_provider: AsyncImageProvider) -> bool:

oagi/agent/tasker/tasker_agent.py

@@ -9,7 +9,7 @@
 import logging
 from typing import Any
 
-from oagi.types import AsyncActionHandler, AsyncImageProvider
+from oagi.types import AsyncActionHandler, AsyncImageProvider, AsyncStepObserver
 
 from ..protocol import AsyncAgent
 from .memory import PlannerMemory
@@ -34,11 +34,12 @@ class TaskerAgent(AsyncAgent):
         self,
         api_key: str | None = None,
         base_url: str | None = None,
-        model: str = "lux-v1",
-        max_steps: int = 30,
-        temperature: float = 0.0,
-        reflection_interval: int = 20,
+        model: str = "lux-actor-1",
+        max_steps: int = 60,
+        temperature: float = 0.5,
+        reflection_interval: int = 4,
         planner: Planner | None = None,
+        step_observer: AsyncStepObserver | None = None,
     ):
         """Initialize the tasker agent.
 
@@ -50,6 +51,7 @@ class TaskerAgent(AsyncAgent):
             temperature: Sampling temperature
             reflection_interval: Actions before reflection
             planner: Planner for planning and reflection
+            step_observer: Optional observer for step tracking
         """
         self.api_key = api_key
         self.base_url = base_url
@@ -57,7 +59,8 @@ class TaskerAgent(AsyncAgent):
         self.max_steps = max_steps
         self.temperature = temperature
         self.reflection_interval = reflection_interval
-        self.planner = planner or Planner()
+        self.planner = planner or Planner(api_key=api_key, base_url=base_url)
+        self.step_observer = step_observer
 
         # Memory for tracking workflow
         self.memory = PlannerMemory()
@@ -168,12 +171,13 @@ class TaskerAgent(AsyncAgent):
             api_key=self.api_key,
             base_url=self.base_url,
             model=self.model,
-            max_steps_per_subtask=10,  # Smaller steps per subtask
+            max_steps_per_subtask=20,  # Smaller steps per subtask
             reflection_interval=self.reflection_interval,
             temperature=self.temperature,
             planner=self.planner,
             external_memory=self.memory,  # Share memory with child
             todo_index=todo_index,  # Pass the todo index
+            step_observer=self.step_observer,  # Pass step observer
         )
 
         self.current_todo_index = todo_index

oagi/cli/agent.py

@@ -10,9 +10,14 @@ import argparse
 import asyncio
 import os
 import sys
+import time
+import traceback
 
 from oagi.exceptions import check_optional_dependency
 
+from .display import display_step_table
+from .tracking import StepTracker
+
 
 def add_agent_parser(subparsers: argparse._SubParsersAction) -> None:
     agent_parser = subparsers.add_parser("agent", help="Agent execution commands")
@@ -25,12 +30,14 @@ def add_agent_parser(subparsers: argparse._SubParsersAction) -> None:
     run_parser.add_argument(
         "instruction", type=str, help="Task instruction for the agent to execute"
     )
-    run_parser.add_argument("--model", type=str, help="Model to use (default: lux-v1)")
     run_parser.add_argument(
-        "--max-steps", type=int, help="Maximum number of steps (default: 30)"
+        "--model", type=str, help="Model to use (default: lux-actor-1)"
+    )
+    run_parser.add_argument(
+        "--max-steps", type=int, help="Maximum number of steps (default: 20)"
     )
     run_parser.add_argument(
-        "--temperature", type=float, help="Sampling temperature (default: 0.0)"
+        "--temperature", type=float, help="Sampling temperature (default: 0.5)"
     )
     run_parser.add_argument(
         "--mode",
@@ -74,12 +81,15 @@ def run_agent(args: argparse.Namespace) -> None:
     base_url = args.oagi_base_url or os.getenv(
         "OAGI_BASE_URL", "https://api.agiopen.org"
     )
-    model = args.model or "lux-v1"
-    max_steps = args.max_steps or 30
-    temperature = args.temperature if args.temperature is not None else 0.0
+    model = args.model or "lux-actor-1"
+    max_steps = args.max_steps or 20
+    temperature = args.temperature if args.temperature is not None else 0.5
     mode = args.mode or "actor"
 
-    # Create agent
+    # Create step tracker
+    step_tracker = StepTracker()
+
+    # Create agent with step tracker
     agent = create_agent(
         mode=mode,
         api_key=api_key,
@@ -87,6 +97,7 @@ def run_agent(args: argparse.Namespace) -> None:
         model=model,
         max_steps=max_steps,
         temperature=temperature,
+        step_observer=step_tracker,
     )
 
     # Create handlers
@@ -99,7 +110,10 @@ def run_agent(args: argparse.Namespace) -> None:
     )
     print("-" * 60)
 
-    # Run agent
+    start_time = time.time()
+    success = False
+    interrupted = False
+
     try:
         success = asyncio.run(
             agent.execute(
@@ -108,18 +122,22 @@ def run_agent(args: argparse.Namespace) -> None:
                 image_provider=image_provider,
             )
         )
-
-        print("-" * 60)
-        if success:
-            print("Task completed successfully!")
-            sys.exit(0)
-        else:
-            print("Task failed or reached max steps without completion.")
-            sys.exit(1)
-
     except KeyboardInterrupt:
-        print("\nAgent execution interrupted.")
-        sys.exit(130)
+        print("\nAgent execution interrupted by user (Ctrl+C)")
+        interrupted = True
     except Exception as e:
-        print(f"Error during agent execution: {e}", file=sys.stderr)
-        sys.exit(1)
+        print(f"\nError during agent execution: {e}", file=sys.stderr)
+        traceback.print_exc()
+    finally:
+        duration = time.time() - start_time
+
+        if step_tracker.steps:
+            print("\n" + "=" * 60)
+            display_step_table(step_tracker.steps, success, duration)
+        else:
+            print("\nNo steps were executed.")
+
+        if interrupted:
+            sys.exit(130)
+        elif not success:
+            sys.exit(1)

oagi/cli/display.py

@@ -0,0 +1,56 @@
+# -----------------------------------------------------------------------------
+#  Copyright (c) OpenAGI Foundation
+#  All rights reserved.
+#
+#  This file is part of the official API project.
+#  Licensed under the MIT License.
+# -----------------------------------------------------------------------------
+
+from rich.console import Console
+from rich.table import Table
+
+from .tracking import StepData
+
+
+def display_step_table(
+    steps: list[StepData], success: bool, duration: float | None = None
+):
+    console = Console()
+
+    table = Table(title="Agent Execution Summary", show_lines=True)
+    table.add_column("Step", justify="center", style="cyan", width=6)
+    table.add_column("Reasoning", style="white")
+    table.add_column("Actions", style="yellow", width=35)
+    table.add_column("Status", justify="center", width=8)
+
+    for step in steps:
+        reason = step.reasoning or "N/A"
+
+        actions_display = []
+        for action in step.actions[:3]:
+            arg = action.argument[:20] if action.argument else ""
+            actions_display.append(f"{action.type.value}({arg})")
+
+        actions_str = ", ".join(actions_display)
+        if len(step.actions) > 3:
+            actions_str += f" (+{len(step.actions) - 3} more)"
+
+        status_display = "✓" if step.status == "complete" else "→"
+
+        table.add_row(
+            str(step.step_num),
+            reason,
+            actions_str,
+            status_display,
+        )
+
+    console.print(table)
+
+    status_text = "Success" if success else "Failed/Interrupted"
+    console.print(
+        f"\nTotal Steps: {len(steps)} | Status: {status_text}",
+        style="bold",
+    )
+
+    if duration:
+        console.print(f"Duration: {duration:.2f}s")

oagi/cli/tracking.py

@@ -0,0 +1,45 @@
+# -----------------------------------------------------------------------------
+#  Copyright (c) OpenAGI Foundation
+#  All rights reserved.
+#
+#  This file is part of the official API project.
+#  Licensed under the MIT License.
+# -----------------------------------------------------------------------------
+
+from dataclasses import dataclass
+from datetime import datetime
+
+from oagi.types import Action
+
+
+@dataclass
+class StepData:
+    step_num: int
+    timestamp: datetime
+    reasoning: str | None
+    actions: list[Action]
+    action_count: int
+    status: str
+
+
+class StepTracker:
+    """Tracks agent step execution by implementing AsyncStepObserver protocol."""
+
+    def __init__(self):
+        self.steps: list[StepData] = []
+
+    async def on_step(
+        self,
+        step_num: int,
+        reasoning: str | None,
+        actions: list[Action],
+    ) -> None:
+        step_data = StepData(
+            step_num=step_num,
+            timestamp=datetime.now(),
+            reasoning=reasoning,
+            actions=actions,
+            action_count=len(actions),
+            status="running",
+        )
+        self.steps.append(step_data)

oagi/cli/utils.py

@@ -15,10 +15,16 @@ from oagi.exceptions import check_optional_dependency
 
 
 def get_sdk_version() -> str:
-    try:
-        return get_version("oagi")
-    except Exception:
-        return "unknown"
+    # Try oagi-core first (development install), then oagi (metapackage install)
+    for package_name in ["oagi-core", "oagi"]:
+        try:
+            version = get_version(package_name)
+            # Skip if version is 0.0.0 (placeholder/invalid)
+            if version != "0.0.0":
+                return version
+        except Exception:
+            continue
+    return "unknown"
 
 
 def display_version() -> None:
@@ -50,6 +56,7 @@ def display_config() -> None:
     config_vars = {
         "OAGI_API_KEY": os.getenv("OAGI_API_KEY", ""),
         "OAGI_BASE_URL": os.getenv("OAGI_BASE_URL", "https://api.agiopen.org"),
+        "OAGI_DEFAULT_MODEL": os.getenv("OAGI_DEFAULT_MODEL", "lux-actor-1"),
         "OAGI_LOG_LEVEL": os.getenv("OAGI_LOG_LEVEL", "INFO"),
         "OAGI_SERVER_HOST": os.getenv("OAGI_SERVER_HOST", "0.0.0.0"),
         "OAGI_SERVER_PORT": os.getenv("OAGI_SERVER_PORT", "8000"),

oagi/client/base.py

@@ -41,16 +41,12 @@ class BaseClient(Generic[HttpClientT]):
 
     def __init__(self, base_url: str | None = None, api_key: str | None = None):
         # Get from environment if not provided
-        self.base_url = base_url or os.getenv("OAGI_BASE_URL")
+        self.base_url = (
+            base_url or os.getenv("OAGI_BASE_URL") or "https://api.agiopen.org"
+        )
         self.api_key = api_key or os.getenv("OAGI_API_KEY")
 
         # Validate required configuration
-        if not self.base_url:
-            raise ConfigurationError(
-                "OAGI base URL must be provided either as 'base_url' parameter or "
-                "OAGI_BASE_URL environment variable"
-            )
-
         if not self.api_key:
             raise ConfigurationError(
                 "OAGI API key must be provided either as 'api_key' parameter or "