oagi-core 0.10.2__py3-none-any.whl → 0.11.0__py3-none-any.whl

oagi/agent/default.py

@@ -10,6 +10,13 @@ import asyncio
 import logging
 
 from .. import AsyncActor
+from ..constants import (
+    DEFAULT_MAX_STEPS,
+    DEFAULT_STEP_DELAY,
+    DEFAULT_TEMPERATURE,
+    MODEL_ACTOR,
+)
+from ..handler import reset_handler
 from ..types import (
     ActionEvent,
     AsyncActionHandler,
@@ -36,11 +43,11 @@ class AsyncDefaultAgent:
         self,
         api_key: str | None = None,
         base_url: str | None = None,
-        model: str = "lux-actor-1",
-        max_steps: int = 20,
-        temperature: float | None = 0.5,
+        model: str = MODEL_ACTOR,
+        max_steps: int = DEFAULT_MAX_STEPS,
+        temperature: float | None = DEFAULT_TEMPERATURE,
         step_observer: AsyncObserver | None = None,
-        step_delay: float = 0.3,
+        step_delay: float = DEFAULT_STEP_DELAY,
     ):
         self.api_key = api_key
         self.base_url = base_url
@@ -62,6 +69,9 @@ class AsyncDefaultAgent:
             logger.info(f"Starting async task execution: {instruction}")
             await self.actor.init_task(instruction, max_steps=self.max_steps)
 
+            # Reset handler state at automation start
+            reset_handler(action_handler)
+
             for i in range(self.max_steps):
                 step_num = i + 1
                 logger.debug(f"Executing step {step_num}/{self.max_steps}")

oagi/agent/factories.py

@@ -6,6 +6,16 @@
 #  Licensed under the MIT License.
 # -----------------------------------------------------------------------------
 from oagi.agent.tasker import TaskerAgent
+from oagi.constants import (
+    DEFAULT_MAX_STEPS,
+    DEFAULT_MAX_STEPS_TASKER,
+    DEFAULT_MAX_STEPS_THINKER,
+    DEFAULT_REFLECTION_INTERVAL_TASKER,
+    DEFAULT_STEP_DELAY,
+    DEFAULT_TEMPERATURE_LOW,
+    MODEL_ACTOR,
+    MODEL_THINKER,
+)
 from oagi.types import AsyncStepObserver
 
 from .default import AsyncDefaultAgent
@@ -17,11 +27,11 @@ from .registry import async_agent_register
 def create_default_agent(
     api_key: str | None = None,
     base_url: str | None = None,
-    model: str = "lux-actor-1",
-    max_steps: int = 20,
-    temperature: float = 0.1,
+    model: str = MODEL_ACTOR,
+    max_steps: int = DEFAULT_MAX_STEPS,
+    temperature: float = DEFAULT_TEMPERATURE_LOW,
     step_observer: AsyncStepObserver | None = None,
-    step_delay: float = 0.3,
+    step_delay: float = DEFAULT_STEP_DELAY,
 ) -> AsyncAgent:
     return AsyncDefaultAgent(
         api_key=api_key,
@@ -38,11 +48,11 @@ def create_default_agent(
 def create_thinker_agent(
     api_key: str | None = None,
     base_url: str | None = None,
-    model: str = "lux-thinker-1",
-    max_steps: int = 100,
-    temperature: float = 0.1,
+    model: str = MODEL_THINKER,
+    max_steps: int = DEFAULT_MAX_STEPS_THINKER,
+    temperature: float = DEFAULT_TEMPERATURE_LOW,
     step_observer: AsyncStepObserver | None = None,
-    step_delay: float = 0.3,
+    step_delay: float = DEFAULT_STEP_DELAY,
 ) -> AsyncAgent:
     return AsyncDefaultAgent(
         api_key=api_key,
@@ -55,16 +65,22 @@ def create_thinker_agent(
     )
 
 
-@async_agent_register(mode="tasker")
-def create_planner_agent(
+@async_agent_register(mode="tasker:cvs_appointment")
+def create_cvs_appointment_agent(
     api_key: str | None = None,
     base_url: str | None = None,
-    model: str = "lux-actor-1",
-    max_steps: int = 30,
-    temperature: float = 0.1,
-    reflection_interval: int = 20,
+    model: str = MODEL_ACTOR,
+    max_steps: int = DEFAULT_MAX_STEPS_TASKER,
+    temperature: float = DEFAULT_TEMPERATURE_LOW,
+    reflection_interval: int = DEFAULT_REFLECTION_INTERVAL_TASKER,
     step_observer: AsyncStepObserver | None = None,
-    step_delay: float = 0.3,
+    step_delay: float = DEFAULT_STEP_DELAY,
+    # CVS-specific parameters
+    first_name: str = "First",
+    last_name: str = "Last",
+    email: str = "user@example.com",
+    birthday: str = "01-01-1990",  # MM-DD-YYYY
+    zip_code: str = "00000",
 ) -> AsyncAgent:
     tasker = TaskerAgent(
         api_key=api_key,
@@ -76,5 +92,71 @@ def create_planner_agent(
         step_observer=step_observer,
         step_delay=step_delay,
     )
-    # tasker.set_task()
+
+    month, day, year = birthday.split("-")
+    instruction = (
+        f"Schedule an appointment at CVS for {first_name} {last_name} "
+        f"with email {email} and birthday {birthday}"
+    )
+    todos = [
+        "Open a new tab, go to www.cvs.com, type 'flu shot' in the search bar and press enter, "
+        "wait for the page to load, then click on the button of Schedule vaccinations on the "
+        "top of the page",
+        f"Enter the first name '{first_name}', last name '{last_name}', and email '{email}' "
+        "in the form. Do not use any suggested autofills. Make sure the mobile phone number "
+        "is empty.",
+        f"Slightly scroll down to see the date of birth, enter Month '{month}', Day '{day}', "
+        f"and Year '{year}' in the form",
+        "Click on 'Continue as guest' button, wait for the page to load with wait, "
+        "click on 'Add vaccines' button, select 'Flu' and click on 'Add vaccines'",
+        f"Click on 'next' to enter the page with recommendation vaccines, then click on "
+        f"'next' again, until on the page of entering zip code, enter '{zip_code}', select "
+        "the first option from the dropdown menu, and click on 'Search'",
+    ]
+
+    tasker.set_task(instruction, todos)
+    return tasker
+
+
+@async_agent_register(mode="tasker:software_qa")
+def create_software_qa_agent(
+    api_key: str | None = None,
+    base_url: str | None = None,
+    model: str = MODEL_ACTOR,
+    max_steps: int = DEFAULT_MAX_STEPS_TASKER,
+    temperature: float = DEFAULT_TEMPERATURE_LOW,
+    reflection_interval: int = DEFAULT_REFLECTION_INTERVAL_TASKER,
+    step_observer: AsyncStepObserver | None = None,
+    step_delay: float = DEFAULT_STEP_DELAY,
+) -> AsyncAgent:
+    tasker = TaskerAgent(
+        api_key=api_key,
+        base_url=base_url,
+        model=model,
+        max_steps=max_steps,
+        temperature=temperature,
+        reflection_interval=reflection_interval,
+        step_observer=step_observer,
+        step_delay=step_delay,
+    )
+
+    instruction = "QA: click through every sidebar button in the Nuclear Player UI"
+    todos = [
+        "Click on 'Dashboard' in the left sidebar",
+        "Click on 'Downloads' in the left sidebar",
+        "Click on 'Lyrics' in the left sidebar",
+        "Click on 'Plugins' in the left sidebar",
+        "Click on 'Search Results' in the left sidebar",
+        "Click on 'Settings' in the left sidebar",
+        "Click on 'Equalizer' in the left sidebar",
+        "Click on 'Visualizer' in the left sidebar",
+        "Click on 'Listening History' in the left sidebar",
+        "Click on 'Favorite Albums' in the left sidebar",
+        "Click on 'Favorite Tracks' in the left sidebar",
+        "Click on 'Favorite Artists' in the left sidebar",
+        "Click on 'Local Library' in the left sidebar",
+        "Click on 'Playlists' in the left sidebar",
+    ]
+
+    tasker.set_task(instruction, todos)
     return tasker

oagi/agent/tasker/planner.py

@@ -10,7 +10,8 @@ import json
 from typing import Any
 
 from ...client import AsyncClient
-from ...types import URL, Image
+from ...constants import DEFAULT_REFLECTION_INTERVAL
+from ...types import URL, Image, extract_uuid_from_url
 from .memory import PlannerMemory
 from .models import Action, PlannerOutput, ReflectionOutput
 
@@ -137,11 +138,16 @@ class Planner:
         # Ensure we have a client
         client = self._ensure_client()
 
-        # Upload screenshot if provided
+        # Get screenshot UUID - either extract from URL or upload
         screenshot_uuid = None
         if screenshot:
-            upload_response = await client.put_s3_presigned_url(screenshot)
-            screenshot_uuid = upload_response.uuid
+            # Check if screenshot is already a URL (already uploaded to S3)
+            if isinstance(screenshot, str):
+                screenshot_uuid = extract_uuid_from_url(screenshot)
+            # If not a URL or UUID extraction failed, upload the image
+            if not screenshot_uuid:
+                upload_response = await client.put_s3_presigned_url(screenshot)
+                screenshot_uuid = upload_response.uuid
 
         # Extract memory data if provided
         (
@@ -175,7 +181,7 @@ class Planner:
         memory: PlannerMemory | None = None,
         todo_index: int | None = None,
         current_instruction: str | None = None,
-        reflection_interval: int = 4,
+        reflection_interval: int = DEFAULT_REFLECTION_INTERVAL,
     ) -> ReflectionOutput:
         """Reflect on recent actions and progress.
 
@@ -194,11 +200,16 @@ class Planner:
         # Ensure we have a client
         client = self._ensure_client()
 
-        # Upload screenshot if provided
+        # Get screenshot UUID - either extract from URL or upload
         result_screenshot_uuid = None
         if screenshot:
-            upload_response = await client.put_s3_presigned_url(screenshot)
-            result_screenshot_uuid = upload_response.uuid
+            # Check if screenshot is already a URL (already uploaded to S3)
+            if isinstance(screenshot, str):
+                result_screenshot_uuid = extract_uuid_from_url(screenshot)
+            # If not a URL or UUID extraction failed, upload the image
+            if not result_screenshot_uuid:
+                upload_response = await client.put_s3_presigned_url(screenshot)
+                result_screenshot_uuid = upload_response.uuid
 
         # Extract memory data if provided
         (

oagi/agent/tasker/taskee_agent.py

@@ -12,6 +12,14 @@ from datetime import datetime
 from typing import Any
 
 from oagi import AsyncActor
+from oagi.constants import (
+    DEFAULT_MAX_STEPS,
+    DEFAULT_REFLECTION_INTERVAL,
+    DEFAULT_STEP_DELAY,
+    DEFAULT_TEMPERATURE,
+    MODEL_ACTOR,
+)
+from oagi.handler import reset_handler
 from oagi.types import (
     URL,
     ActionEvent,
@@ -21,6 +29,7 @@ from oagi.types import (
     Image,
     PlanEvent,
     StepEvent,
+    extract_uuid_from_url,
 )
 
 from ..protocol import AsyncAgent
@@ -52,15 +61,15 @@ class TaskeeAgent(AsyncAgent):
         self,
         api_key: str | None = None,
         base_url: str | None = None,
-        model: str = "lux-actor-1",
-        max_steps: int = 20,
-        reflection_interval: int = 4,
-        temperature: float = 0.5,
+        model: str = MODEL_ACTOR,
+        max_steps: int = DEFAULT_MAX_STEPS,
+        reflection_interval: int = DEFAULT_REFLECTION_INTERVAL,
+        temperature: float = DEFAULT_TEMPERATURE,
         planner: Planner | None = None,
         external_memory: PlannerMemory | None = None,
         todo_index: int | None = None,
         step_observer: AsyncObserver | None = None,
-        step_delay: float = 0.3,
+        step_delay: float = DEFAULT_STEP_DELAY,
     ):
         """Initialize the taskee agent.
 
@@ -114,6 +123,9 @@ class TaskeeAgent(AsyncAgent):
         Returns:
             True if successful, False otherwise
         """
+        # Reset handler state at todo execution start
+        reset_handler(action_handler)
+
         self.current_todo = instruction
         self.actions = []
         self.total_actions = 0
@@ -249,11 +261,21 @@ class TaskeeAgent(AsyncAgent):
             # Capture screenshot
             screenshot = await image_provider()
 
-            # Upload screenshot first to get UUID (avoids re-upload in actor.step)
+            # Get screenshot UUID - either extract from URL or upload
             try:
-                upload_response = await client.put_s3_presigned_url(screenshot)
-                screenshot_uuid = upload_response.uuid
-                screenshot_url = upload_response.download_url
+                screenshot_uuid = None
+                screenshot_url = None
+
+                # Check if screenshot is already a URL (from SocketIOImageProvider)
+                if isinstance(screenshot, str):
+                    screenshot_uuid = extract_uuid_from_url(screenshot)
+                    screenshot_url = screenshot
+
+                # If not a URL or UUID extraction failed, upload the image
+                if not screenshot_uuid:
+                    upload_response = await client.put_s3_presigned_url(screenshot)
+                    screenshot_uuid = upload_response.uuid
+                    screenshot_url = upload_response.download_url
             except Exception as e:
                 logger.error(f"Error uploading screenshot: {e}")
                 self._record_action(

oagi/agent/tasker/tasker_agent.py

@@ -9,6 +9,14 @@
 import logging
 from typing import Any
 
+from oagi.constants import (
+    DEFAULT_MAX_STEPS_TASKER,
+    DEFAULT_REFLECTION_INTERVAL,
+    DEFAULT_STEP_DELAY,
+    DEFAULT_TEMPERATURE,
+    MODEL_ACTOR,
+)
+from oagi.handler import reset_handler
 from oagi.types import AsyncActionHandler, AsyncImageProvider, AsyncObserver, SplitEvent
 
 from ..protocol import AsyncAgent
@@ -34,13 +42,13 @@ class TaskerAgent(AsyncAgent):
         self,
         api_key: str | None = None,
         base_url: str | None = None,
-        model: str = "lux-actor-1",
-        max_steps: int = 60,
-        temperature: float = 0.5,
-        reflection_interval: int = 4,
+        model: str = MODEL_ACTOR,
+        max_steps: int = DEFAULT_MAX_STEPS_TASKER,
+        temperature: float = DEFAULT_TEMPERATURE,
+        reflection_interval: int = DEFAULT_REFLECTION_INTERVAL,
         planner: Planner | None = None,
         step_observer: AsyncObserver | None = None,
-        step_delay: float = 0.3,
+        step_delay: float = DEFAULT_STEP_DELAY,
     ):
         """Initialize the tasker agent.
 
@@ -105,6 +113,9 @@ class TaskerAgent(AsyncAgent):
         Returns:
             True if all todos completed successfully, False otherwise
         """
+        # Reset handler state at automation start
+        reset_handler(action_handler)
+
         overall_success = True
 
         # Execute todos until none remain

oagi/cli/agent.py

@@ -14,6 +14,14 @@ import time
 import traceback
 
 from oagi.agent.observer import AsyncAgentObserver
+from oagi.constants import (
+    API_KEY_HELP_URL,
+    DEFAULT_BASE_URL,
+    DEFAULT_MAX_STEPS_THINKER,
+    DEFAULT_STEP_DELAY,
+    MODE_ACTOR,
+    MODEL_THINKER,
+)
 from oagi.exceptions import check_optional_dependency
 
 from .display import display_step_table
@@ -29,22 +37,30 @@ def add_agent_parser(subparsers: argparse._SubParsersAction) -> None:
         "run", help="Run an agent with the given instruction"
     )
     run_parser.add_argument(
-        "instruction", type=str, help="Task instruction for the agent to execute"
+        "instruction",
+        type=str,
+        nargs="?",
+        default="",
+        help="Task instruction for the agent to execute (optional for pre-configured modes)",
     )
     run_parser.add_argument(
-        "--model", type=str, help="Model to use (default: lux-actor-1)"
+        "--model", type=str, help="Model to use (default: determined by mode)"
     )
     run_parser.add_argument(
-        "--max-steps", type=int, help="Maximum number of steps (default: 20)"
+        "--max-steps",
+        type=int,
+        help="Maximum number of steps (default: determined by mode)",
     )
     run_parser.add_argument(
-        "--temperature", type=float, help="Sampling temperature (default: 0.5)"
+        "--temperature",
+        type=float,
+        help="Sampling temperature (default: determined by mode)",
     )
     run_parser.add_argument(
         "--mode",
         type=str,
-        default="actor",
-        help="Agent mode to use (default: actor). Available modes: actor, planner",
+        default=MODE_ACTOR,
+        help=f"Agent mode to use (default: {MODE_ACTOR}). Use 'oagi agent modes' to list available modes",
     )
     run_parser.add_argument(
         "--oagi-api-key", type=str, help="OAGI API key (default: OAGI_API_KEY env var)"
@@ -52,7 +68,7 @@ def add_agent_parser(subparsers: argparse._SubParsersAction) -> None:
     run_parser.add_argument(
         "--oagi-base-url",
         type=str,
-        help="OAGI base URL (default: https://api.agiopen.org, or OAGI_BASE_URL env var)",
+        help=f"OAGI base URL (default: {DEFAULT_BASE_URL}, or OAGI_BASE_URL env var)",
     )
     run_parser.add_argument(
         "--export",
@@ -68,9 +84,12 @@ def add_agent_parser(subparsers: argparse._SubParsersAction) -> None:
     run_parser.add_argument(
         "--step-delay",
         type=float,
-        help="Delay in seconds after each step before next screenshot (default: 0.3)",
+        help=f"Delay in seconds after each step before next screenshot (default: {DEFAULT_STEP_DELAY})",
     )
 
+    # agent modes command
+    agent_subparsers.add_parser("modes", help="List available agent modes")
+
     # agent permission command
     agent_subparsers.add_parser(
         "permission",
@@ -81,10 +100,22 @@ def add_agent_parser(subparsers: argparse._SubParsersAction) -> None:
 def handle_agent_command(args: argparse.Namespace) -> None:
     if args.agent_command == "run":
         run_agent(args)
+    elif args.agent_command == "modes":
+        list_modes()
     elif args.agent_command == "permission":
         check_permissions()
 
 
+def list_modes() -> None:
+    """List all available agent modes."""
+    from oagi.agent import list_agent_modes  # noqa: PLC0415
+
+    modes = list_agent_modes()
+    print("Available agent modes:")
+    for mode in modes:
+        print(f"  - {mode}")
+
+
 def check_permissions() -> None:
     """Check and request macOS permissions for screen recording and accessibility.
 
@@ -189,19 +220,15 @@ def run_agent(args: argparse.Namespace) -> None:
     if not api_key:
         print(
             "Error: OAGI API key not provided.\n"
-            "Set OAGI_API_KEY environment variable or use --oagi-api-key flag.",
+            "Set OAGI_API_KEY environment variable or use --oagi-api-key flag.\n"
+            f"Get your API key at {API_KEY_HELP_URL}",
             file=sys.stderr,
         )
         sys.exit(1)
 
-    base_url = args.oagi_base_url or os.getenv(
-        "OAGI_BASE_URL", "https://api.agiopen.org"
-    )
-    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"
-    step_delay = args.step_delay if args.step_delay is not None else 0.3
+    base_url = args.oagi_base_url or os.getenv("OAGI_BASE_URL", DEFAULT_BASE_URL)
+    mode = args.mode or MODE_ACTOR
+    step_delay = args.step_delay if args.step_delay is not None else DEFAULT_STEP_DELAY
     export_format = args.export
     export_file = args.export_file
 
@@ -218,26 +245,38 @@ def run_agent(args: argparse.Namespace) -> None:
 
     observer = CombinedObserver()
 
-    # Create agent with observer
-    agent = create_agent(
-        mode=mode,
-        api_key=api_key,
-        base_url=base_url,
-        model=model,
-        max_steps=max_steps,
-        temperature=temperature,
-        step_observer=observer,
-        step_delay=step_delay,
-    )
+    # Build agent kwargs - only pass explicitly provided values, let factory use defaults
+    agent_kwargs = {
+        "mode": mode,
+        "api_key": api_key,
+        "base_url": base_url,
+        "step_observer": observer,
+        "step_delay": step_delay,
+    }
+    if args.model:
+        agent_kwargs["model"] = args.model
+        # If thinker model specified without max_steps, use thinker's default
+        if args.model == MODEL_THINKER and not args.max_steps:
+            agent_kwargs["max_steps"] = DEFAULT_MAX_STEPS_THINKER
+    if args.max_steps:
+        agent_kwargs["max_steps"] = args.max_steps
+    if args.temperature is not None:
+        agent_kwargs["temperature"] = args.temperature
+
+    # Create agent
+    agent = create_agent(**agent_kwargs)
 
     # Create handlers
     action_handler = AsyncPyautoguiActionHandler()
     image_provider = AsyncScreenshotMaker()
 
-    print(f"Starting agent with instruction: {args.instruction}")
+    if args.instruction:
+        print(f"Starting agent with instruction: {args.instruction}")
+    else:
+        print(f"Starting agent with mode: {mode} (using pre-configured instruction)")
     print(
-        f"Mode: {mode}, Model: {model}, Max steps: {max_steps}, "
-        f"Temperature: {temperature}, Step delay: {step_delay}s"
+        f"Mode: {mode}, Model: {agent.model}, Max steps: {agent.max_steps}, "
+        f"Temperature: {agent.temperature}, Step delay: {step_delay}s"
     )
     print("-" * 60)
 

oagi/cli/display.py

@@ -29,7 +29,8 @@ def display_step_table(
         actions_display = []
         for action in step.actions[:3]:
             arg = action.argument[:20] if action.argument else ""
-            actions_display.append(f"{action.type.value}({arg})")
+            count_str = f" x{action.count}" if action.count and action.count > 1 else ""
+            actions_display.append(f"{action.type.value}({arg}){count_str}")
 
         actions_str = ", ".join(actions_display)
         if len(step.actions) > 3:

oagi/cli/server.py

@@ -25,7 +25,7 @@ def add_server_parser(subparsers: argparse._SubParsersAction) -> None:
     start_parser.add_argument(
         "--host",
         type=str,
-        help="Server host (default: 0.0.0.0, or OAGI_SERVER_HOST env var)",
+        help="Server host (default: 127.0.0.1, or OAGI_SERVER_HOST env var)",
     )
     start_parser.add_argument(
         "--port",

oagi/cli/utils.py

@@ -11,6 +11,7 @@ import os
 import sys
 from importlib.metadata import version as get_version
 
+from oagi.constants import DEFAULT_BASE_URL, MODEL_ACTOR
 from oagi.exceptions import check_optional_dependency
 
 
@@ -55,10 +56,10 @@ def display_version() -> None:
 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_BASE_URL": os.getenv("OAGI_BASE_URL", DEFAULT_BASE_URL),
+        "OAGI_DEFAULT_MODEL": os.getenv("OAGI_DEFAULT_MODEL", MODEL_ACTOR),
         "OAGI_LOG_LEVEL": os.getenv("OAGI_LOG_LEVEL", "INFO"),
-        "OAGI_SERVER_HOST": os.getenv("OAGI_SERVER_HOST", "0.0.0.0"),
+        "OAGI_SERVER_HOST": os.getenv("OAGI_SERVER_HOST", "127.0.0.1"),
         "OAGI_SERVER_PORT": os.getenv("OAGI_SERVER_PORT", "8000"),
         "OAGI_MAX_STEPS": os.getenv("OAGI_MAX_STEPS", "30"),
     }

oagi/client/async_.py

@@ -10,6 +10,13 @@ from functools import wraps
 
 import httpx
 
+from ..constants import (
+    API_HEALTH_ENDPOINT,
+    API_V1_FILE_UPLOAD_ENDPOINT,
+    API_V1_GENERATE_ENDPOINT,
+    API_V2_MESSAGE_ENDPOINT,
+    HTTP_CLIENT_TIMEOUT,
+)
 from ..logging import get_logger
 from ..types import Image
 from ..types.models import GenerateResponse, LLMResponse, UploadFileResponse
@@ -41,7 +48,7 @@ class AsyncClient(BaseClient[httpx.AsyncClient]):
     def __init__(self, base_url: str | None = None, api_key: str | None = None):
         super().__init__(base_url, api_key)
         self.client = httpx.AsyncClient(base_url=self.base_url)
-        self.upload_client = httpx.AsyncClient(timeout=60)  # client for uploading image
+        self.upload_client = httpx.AsyncClient(timeout=HTTP_CLIENT_TIMEOUT)
         logger.info(f"AsyncClient initialized with base_url: {self.base_url}")
 
     async def __aenter__(self):
@@ -121,7 +128,10 @@ class AsyncClient(BaseClient[httpx.AsyncClient]):
         # Make request
         try:
             response = await self.client.post(
-                "/v2/message", json=payload, headers=headers, timeout=self.timeout
+                API_V2_MESSAGE_ENDPOINT,
+                json=payload,
+                headers=headers,
+                timeout=self.timeout,
             )
             return self._process_response(response)
         except (httpx.TimeoutException, httpx.NetworkError) as e:
@@ -136,7 +146,7 @@ class AsyncClient(BaseClient[httpx.AsyncClient]):
         """
         logger.debug("Making async health check request")
         try:
-            response = await self.client.get("/health")
+            response = await self.client.get(API_HEALTH_ENDPOINT)
             response.raise_for_status()
             result = response.json()
             logger.debug("Async health check successful")
@@ -158,12 +168,12 @@ class AsyncClient(BaseClient[httpx.AsyncClient]):
         Returns:
             UploadFileResponse: The response from /v1/file/upload with uuid and presigned S3 URL
         """
-        logger.debug("Making async API request to /v1/file/upload")
+        logger.debug(f"Making async API request to {API_V1_FILE_UPLOAD_ENDPOINT}")
 
         try:
             headers = self._build_headers(api_version)
             response = await self.client.get(
-                "/v1/file/upload", headers=headers, timeout=self.timeout
+                API_V1_FILE_UPLOAD_ENDPOINT, headers=headers, timeout=self.timeout
             )
             return self._process_upload_response(response)
         except (httpx.TimeoutException, httpx.NetworkError, httpx.HTTPStatusError) as e:
@@ -283,7 +293,10 @@ class AsyncClient(BaseClient[httpx.AsyncClient]):
         # Make request
         try:
             response = await self.client.post(
-                "/v1/generate", json=payload, headers=headers, timeout=self.timeout
+                API_V1_GENERATE_ENDPOINT,
+                json=payload,
+                headers=headers,
+                timeout=self.timeout,
             )
             return self._process_generate_response(response)
         except (httpx.TimeoutException, httpx.NetworkError) as e: