Python SDK

from asteroid_odyssey import (
    Configuration,
    ApiClient,
    AgentsApi,
    ExecutionApi,
    AgentsAgentExecuteAgentRequest,
)
import time
import os

# Terminal statuses
TERMINAL_STATUSES = {"completed", "failed", "cancelled"}

def main():
    # Configure client
    config = Configuration(
        api_key={"ApiKeyAuth": os.environ.get("ASTEROID_API_KEY")}
    )
    client = ApiClient(config)

    # Execute agent
    agents_api = AgentsApi(client)
    request = AgentsAgentExecuteAgentRequest(
        inputs={
            "username": "[email protected]",
            "order_id": "ORD-12345"
        }
    )
    response = agents_api.agent_execute_post(
        agent_id="your-agent-id",
        agents_agent_execute_agent_request=request
    )
    execution_id = response.execution_id
    print(f"Execution started: {execution_id}")

    # Poll for completion
    execution_api = ExecutionApi(client)
    while True:
        result = execution_api.execution_get(execution_id=execution_id)
        status = result.status.value
        print(f"Status: {status}")

        if status in TERMINAL_STATUSES:
            break
        time.sleep(2)

    print(f"Execution finished with status: {status}")

if __name__ == "__main__":
    main()

from asteroid_odyssey import (
    Configuration,
    ApiClient,
    AgentsApi,
    ExecutionApi,
    AgentsAgentExecuteAgentRequest,
    AgentsExecutionUserMessagesAddTextBody,
)
import time
import os

TERMINAL_STATUSES = {"completed", "failed", "cancelled"}

def main():
    config = Configuration(
        api_key={"ApiKeyAuth": os.environ.get("ASTEROID_API_KEY")}
    )
    client = ApiClient(config)

    # Start execution
    agents_api = AgentsApi(client)
    request = AgentsAgentExecuteAgentRequest(
        inputs={"task": "Book an appointment"}
    )
    response = agents_api.agent_execute_post(
        agent_id="your-agent-id",
        agents_agent_execute_agent_request=request
    )
    execution_id = response.execution_id
    print(f"Execution started: {execution_id}")

    execution_api = ExecutionApi(client)

    while True:
        result = execution_api.execution_get(execution_id=execution_id)
        status = result.status.value
        print(f"Status: {status}")

        if status in TERMINAL_STATUSES:
            print(f"Execution completed with status: {status}")
            break

        if status == "paused_by_agent":
            # Agent is waiting for user input
            print("Agent is waiting for input...")
            user_input = input("Your response: ")

            body = AgentsExecutionUserMessagesAddTextBody(text=user_input)
            execution_api.execution_user_messages_add(
                execution_id=execution_id,
                agents_execution_user_messages_add_text_body=body
            )
            print("Message sent!")

        time.sleep(2)

if __name__ == "__main__":
    main()

from asteroid_odyssey import (
    Configuration,
    ApiClient,
    FilesApi,
)
import os

def upload_files_example():
    config = Configuration(
        api_key={"ApiKeyAuth": os.environ.get("ASTEROID_API_KEY")}
    )
    client = ApiClient(config)
    files_api = FilesApi(client)

    execution_id = "your-execution-id"

    # Upload a file from disk
    with open("document.pdf", "rb") as f:
        file_content = f.read()

    files_api.execution_context_files_upload(
        execution_id=execution_id,
        files=[("document.pdf", file_content)]
    )
    print("File uploaded successfully!")

    # Upload multiple files
    files_to_upload = []
    for filename in ["file1.txt", "file2.txt"]:
        with open(filename, "rb") as f:
            files_to_upload.append((filename, f.read()))

    files_api.execution_context_files_upload(
        execution_id=execution_id,
        files=files_to_upload
    )
    print(f"Uploaded {len(files_to_upload)} files")

if __name__ == "__main__":
    upload_files_example()

from asteroid_odyssey import (
    Configuration,
    ApiClient,
    AgentsApi,
    AgentProfilesApi,
    AgentsAgentExecuteAgentRequest,
    AgentsProfileCreateAgentProfileRequest,
    AgentsProfileCountryCode,
    AgentsProfileProxyType,
    AgentsProfileCookie,
)
import os

def profile_example():
    config = Configuration(
        api_key={"ApiKeyAuth": os.environ.get("ASTEROID_API_KEY")}
    )
    client = ApiClient(config)

    profiles_api = AgentProfilesApi(client)

    # Create a profile with proxy and cookies
    request = AgentsProfileCreateAgentProfileRequest(
        name="E-commerce Profile",
        organization_id="your-org-id",
        country_code=AgentsProfileCountryCode.US,
        proxy_type=AgentsProfileProxyType.RESIDENTIAL,
        captcha_solver_active=True,
        cookies=[
            AgentsProfileCookie(
                name="session",
                key="session_id",
                value="abc123",
                domain="example.com",
                secure=True,
                http_only=True,
            )
        ]
    )
    profile = profiles_api.agent_profiles_create(
        agents_profile_create_agent_profile_request=request
    )
    print(f"Created profile: {profile.id}")

    # Execute an agent with the profile
    agents_api = AgentsApi(client)
    exec_request = AgentsAgentExecuteAgentRequest(
        inputs={"product_url": "https://example.com/product/123"},
        agent_profile_id=profile.id
    )
    response = agents_api.agent_execute_post(
        agent_id="your-agent-id",
        agents_agent_execute_agent_request=exec_request
    )
    print(f"Execution started: {response.execution_id}")

if __name__ == "__main__":
    profile_example()

from asteroid_odyssey import (
    Configuration,
    ApiClient,
    AgentsApi,
    AgentProfilesApi,
    AgentProfilePoolsApi,
    ExecutionApi,
    AgentsProfileCreateAgentProfileRequest,
    AgentsProfileCountryCode,
    AgentsProfileProxyType,
    AgentsProfilePoolCreateProfilePoolRequest,
    AgentsProfilePoolAddMembersRequest,
    AgentsProfilePoolSelectionStrategy,
    AgentsAgentExecuteAgentRequest,
)
import os
import time

TERMINAL_STATUSES = {"completed", "failed", "cancelled"}

def profile_pool_example():
    config = Configuration(
        api_key={"ApiKeyAuth": os.environ.get("ASTEROID_API_KEY")}
    )
    client = ApiClient(config)

    profiles_api = AgentProfilesApi(client)
    pools_api = AgentProfilePoolsApi(client)
    agents_api = AgentsApi(client)
    execution_api = ExecutionApi(client)

    org_id = "your-org-id"

    # Create multiple profiles with different credentials
    profile_names = ["Account 1", "Account 2", "Account 3"]
    profiles = []
    for name in profile_names:
        request = AgentsProfileCreateAgentProfileRequest(
            name=name,
            organization_id=org_id,
            country_code=AgentsProfileCountryCode.US,
            proxy_type=AgentsProfileProxyType.RESIDENTIAL,
        )
        profile = profiles_api.agent_profiles_create(
            agents_profile_create_agent_profile_request=request
        )
        profiles.append(profile)
        print(f"Created profile: {profile.id}")

    print(f"Created {len(profiles)} profiles")

    # Create a pool with LRU strategy
    pool_request = AgentsProfilePoolCreateProfilePoolRequest(
        name="Rotation Pool",
        organization_id=org_id,
        selection_strategy=AgentsProfilePoolSelectionStrategy.LEAST_RECENTLY_USED,
        allow_concurrent_use=False,  # Prevent credential conflicts
    )
    pool = pools_api.agent_profile_pool_create(
        agents_profile_pool_create_profile_pool_request=pool_request
    )
    print(f"Created pool: {pool.id}")

    # Add profiles to the pool
    add_request = AgentsProfilePoolAddMembersRequest(
        profile_ids=[p.id for p in profiles]
    )
    pools_api.agent_profile_pool_members_add(
        pool_id=pool.id,
        agents_profile_pool_add_members_request=add_request
    )
    print("Added profiles to pool")

    # Run multiple executions - system will distribute across profiles
    execution_ids = []
    for i in range(3):
        exec_request = AgentsAgentExecuteAgentRequest(
            inputs={"task": f"Execution {i+1}"},
            agent_profile_pool_id=pool.id
        )
        response = agents_api.agent_execute_post(
            agent_id="your-agent-id",
            agents_agent_execute_agent_request=exec_request
        )
        execution_ids.append(response.execution_id)
        print(f"Started execution: {response.execution_id}")

    print(f"Started {len(execution_ids)} executions with pool")

    # Wait for all to complete
    for exec_id in execution_ids:
        print(f"Waiting for execution: {exec_id}")
        while True:
            result = execution_api.execution_get(execution_id=exec_id)
            status = result.status.value
            if status in TERMINAL_STATUSES:
                print(f"{exec_id}: {status}")
                break
            time.sleep(2)

    print("All executions completed")

if __name__ == "__main__":
    profile_pool_example()