aip-agents-binary 0.0.0__py3-none-any.whl

aip_agents/examples/hello_world_multi_agent_tool_output_server.py

@@ -0,0 +1,131 @@
+"""Example A2A server demonstrating multi-agent tool output management.
+
+This server provides a multi-agent system for data generation and visualization,
+demonstrating how tool outputs can be shared across agent boundaries using
+a shared ToolOutputManager.
+
+Workflow:
+1. CoordinatorAgent: Receives user request and delegates tasks.
+2. GeneratorAgent: Generates sample data and stores it.
+3. VisualizerAgent: Retrieves stored data via reference and creates visualizations.
+
+Authors:
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+"""
+
+import click
+import uvicorn
+from a2a.types import AgentCapabilities, AgentCard, AgentSkill
+from dotenv import load_dotenv
+
+from aip_agents.agent import LangGraphReactAgent
+from aip_agents.examples.tools.data_generator_tool import DataGeneratorTool
+from aip_agents.examples.tools.data_visualization_tool import DataVisualizerTool
+from aip_agents.storage.clients.minio_client import MinioConfig, MinioObjectStorage
+from aip_agents.storage.providers.object_storage import ObjectStorageProvider
+from aip_agents.utils.langgraph.tool_output_management import ToolOutputConfig, ToolOutputManager
+from aip_agents.utils.logger import get_logger
+
+load_dotenv()
+logger = get_logger(__name__)
+
+SERVER_AGENT_NAME = "MultiAgentDataVisualizationAgent"
+
+
+@click.command()
+@click.option("--host", default="localhost", help="Host to bind the server to")
+@click.option("--port", default=8886, help="Port to bind the server to")
+def main(host: str, port: int):
+    """Run the Multi-Agent Data Visualization A2A server.
+
+    Args:
+        host (str): Host to bind the server to.
+        port (int): Port to bind the server to.
+    """
+    logger.info(f"Starting {SERVER_AGENT_NAME} on http://{host}:{port}")
+
+    # 1. Setup Shared Tool Output Management
+    minio_config = MinioConfig.from_env()
+    minio_client = MinioObjectStorage(minio_config)
+    object_storage_provider = ObjectStorageProvider(
+        client=minio_client,
+        prefix="multi_agent_test",  # Unique prefix for this example
+    )
+    tool_output_config = ToolOutputConfig(
+        storage_provider=object_storage_provider,
+    )
+    tool_output_manager = ToolOutputManager(tool_output_config)
+
+    # 2. Create Specialized Agents
+    model_name = "openai/gpt-4.1"
+
+    # Generator Agent: Specializes in data generation
+    generator_agent = LangGraphReactAgent(
+        name="GeneratorAgent",
+        instruction="""You are a data generation specialist.
+Generate sample datasets (sales, scores, growth data) when requested.
+Always ensure your tool outputs are stored for other agents to use.""",
+        model=model_name,
+        tools=[DataGeneratorTool()],
+        tool_output_manager=tool_output_manager,
+    )
+
+    # Visualizer Agent: Specializes in data visualization
+    visualizer_agent = LangGraphReactAgent(
+        name="VisualizerAgent",
+        instruction="""You are a data visualization specialist.
+Create charts and visualizations from data references ($tool_output.call_id).
+Do not try to generate data yourself; use the data provided by the GeneratorAgent.""",
+        model=model_name,
+        tools=[DataVisualizerTool()],
+        tool_output_manager=tool_output_manager,
+    )
+
+    # 3. Create Coordinator Agent (The Main Entry Point)
+    coordinator_agent = LangGraphReactAgent(
+        name=SERVER_AGENT_NAME,
+        instruction="""You are a coordinator that manages data workflows.
+Delegate data generation tasks to the GeneratorAgent and visualization tasks to the VisualizerAgent.
+
+When you receive a request:
+1. Ask GeneratorAgent to generate the data.
+2. Pass the resulting tool output reference ($tool_output.call_id) to the VisualizerAgent to create the chart.
+
+Always use tool output references to avoid passing large amounts of data between agents.""",
+        model=model_name,
+        agents=[generator_agent, visualizer_agent],
+        tool_output_manager=tool_output_manager,
+    )
+
+    # 4. Define Agent Card for A2A
+    agent_card = AgentCard(
+        name=SERVER_AGENT_NAME,
+        description="Multi-agent system that generates and visualizes data using shared tool outputs",
+        url=f"http://{host}:{port}",
+        version="1.0.0",
+        default_input_modes=["text"],
+        default_output_modes=["text"],
+        capabilities=AgentCapabilities(streaming=True),
+        skills=[
+            AgentSkill(
+                id="coordinated_analysis",
+                name="Coordinated Data Analysis",
+                description="End-to-end data generation and visualization via multiple specialized agents",
+                examples=[
+                    "Generate sales data and create a bar chart",
+                    "Analyze student scores with a line chart",
+                ],
+                tags=["multi-agent", "data", "visualization"],
+            ),
+        ],
+    )
+
+    # 5. Create and Run A2A App
+    app = coordinator_agent.to_a2a(agent_card=agent_card)
+
+    logger.info("A2A application configured. Starting Uvicorn server...")
+    uvicorn.run(app, host=host, port=port)
+
+
+if __name__ == "__main__":
+    main()

aip_agents/examples/hello_world_pii_logger.py

@@ -0,0 +1,21 @@
+"""This example shows how to use the get_logger function to initialize a logger with PII logging enabled.
+
+Authors:
+    Saul Sayers (saul.sayers@gdplabs.id)
+"""
+
+import logging
+
+from aip_agents.utils.logger import get_logger
+
+logger = get_logger(__name__, logging.DEBUG)
+
+# Set up logging format
+sensitive_info = (
+    "contoh nomor ktp 3525011212941001\n"
+    "contoh email john.doe@example.com\n"
+    "contoh nomor telepon +628121729819 dan 0812898029384.\n"
+    "contoh npwp 01.123.456.7-891.234"
+)
+
+logger.info(f"Logging sensitive information for processing: \n{sensitive_info}")

aip_agents/examples/hello_world_ptc.py

@@ -0,0 +1,49 @@
+"""Minimal PTC hello world example.
+
+Required environment variables:
+- OPENAI_API_KEY
+- E2B_API_KEY
+"""
+
+import asyncio
+
+from aip_agents.agent import LangGraphReactAgent
+from aip_agents.ptc import PromptConfig, PTCSandboxConfig
+
+
+async def main() -> None:
+    """Run a hello-world PTC flow."""
+    instruction = (
+        "You are a helpful assistant with access to execute_ptc_code. "
+        "Use execute_ptc_code to run Python and print output. "
+        "The tool returns JSON with ok/stdout/stderr/exit_code."
+    )
+
+    agent = LangGraphReactAgent(
+        name="ptc_hello_world",
+        instruction=instruction,
+        model="openai/gpt-5.2",
+        ptc_config=PTCSandboxConfig(enabled=True, sandbox_timeout=180.0, prompt=PromptConfig(mode="index")),
+    )
+    agent.add_mcp_server(
+        {
+            "deepwiki": {
+                "transport": "streamable-http",
+                "url": "https://mcp.deepwiki.com/mcp",
+                "headers": {},
+                "timeout": 60.0,
+            }
+        }
+    )
+
+    try:
+        response = await agent.arun(
+            query="Use execute_ptc_code to print 'Hello, world!' and count the number of words in the output of deepwiki.read_wiki_structure('anthropics/claude-code')."
+        )
+        print("execute_ptc_code output:", response["output"])
+    finally:
+        await agent.cleanup()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

aip_agents/examples/hello_world_ptc_custom_tools.py

@@ -0,0 +1,83 @@
+"""Minimal PTC hello world example with custom tools.
+
+Author: Putu Ravindra Wiguna (putu.r.wiguna@gdplabs.id)
+
+Required environment variables:
+- OPENAI_API_KEY
+- E2B_API_KEY
+"""
+
+import asyncio
+import json
+from pathlib import Path
+
+from langchain_openai import ChatOpenAI
+
+from aip_agents.agent import LangGraphReactAgent
+from aip_agents.examples.tools.multiply_tool import MultiplyTool
+from aip_agents.ptc import PromptConfig, PTCCustomToolConfig, PTCSandboxConfig, file_tool, package_tool
+from aip_agents.tools.time_tool import TimeTool
+
+
+async def main() -> None:
+    """Run a hello-world PTC flow with custom tools."""
+    repo_root = Path.cwd()
+    multiply_tool_path = repo_root / "aip_agents/examples/tools/multiply_tool.py"
+
+    instruction = (
+        "You are a helpful assistant with access to execute_ptc_code. "
+        "Use execute_ptc_code to run Python and print output. "
+        "Custom tools are available under tools.custom (import with "
+        "'from tools.custom import <tool_name>')."
+    )
+
+    agent = LangGraphReactAgent(
+        name="ptc_custom_tools_hello_world",
+        instruction=instruction,
+        model=ChatOpenAI(model="gpt-5.2"),
+        tools=[TimeTool(), MultiplyTool()],
+        tool_configs={"multiply": {"offset": 20}},
+        ptc_config=PTCSandboxConfig(
+            enabled=True,
+            sandbox_timeout=180.0,
+            prompt=PromptConfig(mode="auto"),
+            custom_tools=PTCCustomToolConfig(
+                enabled=True,
+                bundle_roots=[str(repo_root)],
+                requirements=[],
+                tools=[
+                    package_tool(
+                        "time_tool",
+                        import_path="aip_agents.tools.time_tool",
+                        class_name="TimeTool",
+                    ),
+                    file_tool(
+                        "multiply",
+                        file_path=str(multiply_tool_path),
+                        class_name="MultiplyTool",
+                    ),
+                ],
+            ),
+        ),
+    )
+
+    try:
+        # Pass tool config at runtime via metadata
+        # The multiply tool will use offset=10, so multiply(a=6, b=7) returns 6*7+10=52
+        print("execute_ptc_code output: ", end="")
+        last_chunk = None
+        async for chunk in agent.arun_sse_stream(
+            query=("Use execute_ptc_code to import from tools.custom. Print time_tool() and multiply(a=6, b=7)."),
+            metadata={"tool_configs": {"multiply": {"offset": 10}}},
+        ):
+            last_chunk = chunk
+            print(json.dumps(chunk))
+            print("-" * 20)
+    finally:
+        await agent.cleanup()
+
+    print("execute_ptc_code output: ", last_chunk["content"])
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

aip_agents/examples/hello_world_sentry.py

@@ -0,0 +1,133 @@
+"""This is a simple FastAPI app to test Sentry with Open Telemetry from GL Connectors SDK.
+
+To run this example, make sure to set the following environment variables:
+    SENTRY_DSN
+    SENTRY_ENVIRONMENT
+    SENTRY_PROJECT
+    VERSION_NUMBER
+    BUILD_NUMBER
+    USE_OPENTELEMETRY
+
+Authors:
+    Saul Sayers (saul.sayers@gdplabs.id)
+"""
+
+import io
+import os
+import subprocess
+import sys
+import threading
+import time
+
+import uvicorn
+from fastapi import FastAPI
+from fastapi.responses import JSONResponse
+from fastapi.staticfiles import StaticFiles
+
+from aip_agents.examples.hello_world_langgraph import langgraph_example
+from aip_agents.sentry import setup_telemetry
+from aip_agents.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+BASE_URL = "http://localhost:8585"
+SENTRY_ENVIRONMENT = os.getenv("SENTRY_ENVIRONMENT", "development")
+USE_OPENTELEMETRY = os.getenv("USE_OPENTELEMETRY", "true").lower() == "true"
+
+
+def fetch_endpoints():
+    """Fetch all endpoints from the server."""
+    BASE_URL = "http://127.0.0.1:8585"
+    endpoints = [
+        "/",
+        "/langgraph-hello-world",
+        "/test-telemetry",
+        "/raise-error",
+    ]
+    for ep in endpoints:
+        url = BASE_URL + ep
+        try:
+            # Because using request.get() will trigger sentry, but the ep name is not saved.
+            # Instead of GET /langgraph-hello-world, sentry will save it as GET
+            url = f"http://127.0.0.1:8585{ep}"
+            result = subprocess.run(["curl", "-i", url], capture_output=True, text=True, check=False)
+            logger.info(result.stdout)
+        except Exception as e:
+            logger.error(f"Error fetching {ep}: {e}")
+
+
+def create_app() -> FastAPI:
+    """Create and configure the FastAPI application.
+
+    Returns:
+        FastAPI: The configured FastAPI application.
+    """
+    app = FastAPI(
+        title="GL Connectors SDK - Sentry with Open Telemetry",
+        description="This is a simple FastAPI app to test Sentry with Open Telemetry.",
+        version="0.0.1",
+        docs_url=None,
+        redoc_url="/docs",
+    )
+
+    if os.path.isdir("static"):
+        app.mount("/static", StaticFiles(directory="static"), name="static")
+    setup_telemetry(app)
+
+    @app.get("/", tags=["Root"])
+    async def index():
+        if USE_OPENTELEMETRY:
+            return {
+                "message": "Application running with Sentry + OpenTelemetry.",
+                "telemetry_mode": "Sentry with OpenTelemetry",
+                "environment": SENTRY_ENVIRONMENT,
+            }
+        else:
+            return {
+                "message": "Application running with Sentry only (no OpenTelemetry).",
+                "telemetry_mode": "Sentry only",
+                "environment": SENTRY_ENVIRONMENT,
+            }
+
+    @app.get("/langgraph-hello-world", tags=["LangGraph"])
+    async def langgraph_hello_world():
+        old_stdout = sys.stdout
+        sys.stdout = mystdout = io.StringIO()
+        try:
+            await langgraph_example()
+            output = mystdout.getvalue()
+        finally:
+            sys.stdout = old_stdout
+        return JSONResponse(content={"output": output})
+
+    @app.get("/test-telemetry", tags=["Root"])
+    async def test_telemetry():
+        return {
+            "message": "Telemetry test endpoint called.",
+            "using_opentelemetry": USE_OPENTELEMETRY,
+            "check": "Check your Sentry dashboard for traces.",
+        }
+
+    @app.get("/raise-error", tags=["Root"])
+    async def raise_error():
+        raise RuntimeError("This is a test error for Sentry!")
+
+    return app
+
+
+def run_server():
+    """Run the FastAPI server."""
+    uvicorn.run(
+        "aip_agents.examples.hello_world_sentry:create_app",
+        host="127.0.0.1",
+        port=8585,
+        factory=True,
+        log_level="info",
+    )
+
+
+if __name__ == "__main__":
+    server_thread = threading.Thread(target=run_server, daemon=True)
+    server_thread.start()
+    time.sleep(2)
+    fetch_endpoints()

aip_agents/examples/hello_world_step_limits.py

@@ -0,0 +1,273 @@
+"""Example demonstrating configurable step limits and delegation depth tracking.
+
+This example shows how to:
+1. Configure maximum steps for an agent
+2. Configure maximum delegation depth
+3. Handle step limit exceeded errors gracefully
+4. Track delegation chains across multi-agent hierarchies
+
+Authors:
+    Saul Sayers (saul.sayers@gdplabs.id)
+"""
+
+import asyncio
+import os
+
+from langchain_openai import ChatOpenAI
+
+from aip_agents.agent import LangGraphReactAgent
+from aip_agents.examples.tools.langchain_arithmetic_tools import add_numbers
+from aip_agents.schema.step_limit import MaxStepsExceededError, StepLimitConfig
+from aip_agents.utils.step_limit_manager import StepLimitManager
+
+
+def print_config_validation(config: StepLimitConfig | None, context: str):
+    """Print step limit configuration validation."""
+    print(f"\n{'=' * 60}")
+    print(f"Configuration Validation - {context}")
+    print(f"{'=' * 60}")
+    if config is None:
+        print("✓ Config: None (will use platform defaults)")
+        print("  Expected: max_steps=25, max_delegation_depth=5")
+    else:
+        print(f"✓ max_steps: {config.max_steps}")
+        print(f"✓ max_delegation_depth: {config.max_delegation_depth}")
+
+        # Validate ranges
+        if 1 <= config.max_steps <= 1000:
+            print("  ✓ max_steps is valid (1-1000)")
+        else:
+            print("  ✗ max_steps is INVALID (should be 1-1000)")
+
+        if 0 <= config.max_delegation_depth <= 10:
+            print("  ✓ max_delegation_depth is valid (0-10)")
+        else:
+            print("  ✗ max_delegation_depth is INVALID (should be 0-10)")
+    print(f"{'=' * 60}\n")
+
+
+async def test_case_1_success_no_limits():
+    """Test Case 1: Success - High limits, no warnings."""
+    print("\n" + "=" * 60)
+    print("TEST CASE 1: Success - High Limits (No Warnings)")
+    print("=" * 60)
+
+    model = ChatOpenAI(model="gpt-4o-mini", temperature=0)
+    tools = [add_numbers]
+
+    # Very high limits - should complete successfully
+    step_limit_config = StepLimitConfig(
+        max_steps=100,  # High limit
+        max_delegation_depth=5,  # High depth
+    )
+
+    print_config_validation(step_limit_config, "High Limits")
+
+    agent = LangGraphReactAgent(
+        name="SuccessAgent",
+        instruction="You are a helpful math assistant.",
+        model=model,
+        tools=tools,
+    )
+
+    query = "What is 5 + 3?"
+    print(f"Query: {query}")
+    print("Expected: Should complete successfully without warnings\n")
+
+    try:
+        response = await agent.arun(
+            query=query,
+            step_limit_config=step_limit_config,
+            configurable={"thread_id": "test_case_1"},
+        )
+        print(f"✅ SUCCESS: {response['output']}")
+        print("✅ Test passed: Agent completed without hitting limits\n")
+    except Exception as e:
+        print(f"❌ FAILED: {e}\n")
+
+
+async def test_case_2_parallel_tool_batch_accounting():
+    """Test Case 2: Demonstrate that parallel tool batches consume multiple steps."""
+    manager = StepLimitManager(StepLimitConfig(max_steps=6))
+    print("\n" + "=" * 60)
+    print("TEST CASE 2: Parallel Tool Batch Accounting")
+    print("=" * 60)
+    print("Simulating one agent reasoning step plus 5 parallel tool calls.\n")
+
+    print(f"Initial steps: {manager.context.current_step}, remaining budget: {manager.context.remaining_step_budget}")
+    manager.increment_step()  # Agent LLM call
+    print(
+        f"After agent turn -> steps: {manager.context.current_step}, remaining: {manager.context.remaining_step_budget}"
+    )
+
+    # Simulate a batch of 5 tool calls executed in parallel
+    manager.increment_step(count=5)
+    print("After 5 parallel tool calls (count=5):")
+    print(f"Steps used: {manager.context.current_step}, remaining: {manager.context.remaining_step_budget}")
+
+    # Ensure limit is enforced now
+    try:
+        manager.check_step_limit()
+    except MaxStepsExceededError as exc:
+        print(f"✅ Limit enforcement triggered immediately: {exc}")
+        return
+
+    print("❌ Expected the limit to be hit after consuming 6 steps, but it was not.")
+
+
+async def test_case_3_step_limit_exceeded():
+    """Test Case 3: Step Limit Exceeded - Only 2 steps allowed."""
+    print("\n" + "=" * 60)
+    print("TEST CASE 3: Step Limit Exceeded (max_steps=2)")
+    print("=" * 60)
+
+    model = ChatOpenAI(model="gpt-4o-mini", temperature=0)
+    tools = [add_numbers]
+
+    # Very low step limit - will hit limit
+    step_limit_config = StepLimitConfig(
+        max_steps=2,  # Only 2 steps: 1 for thinking, 1 for tool call
+        max_delegation_depth=0,
+    )
+
+    print_config_validation(step_limit_config, "Very Low Step Limit")
+
+    agent = LangGraphReactAgent(
+        name="LimitedAgent",
+        instruction="You are a helpful math assistant. Always use the add_numbers tool.",
+        model=model,
+        tools=tools,
+    )
+
+    query = "Use the add_numbers tool to calculate 7 + 8, then add 10 to the result"
+    print(f"Query: {query}")
+    print("Expected: Should hit step limit after 2 steps\n")
+    print("Step 0: Initial LLM call")
+    print("Step 1: Tool call (add_numbers)")
+    print("Step 2: Would be final response, but LIMIT HIT!\n")
+
+    try:
+        response = await agent.arun(
+            query=query,
+            step_limit_config=step_limit_config,
+            configurable={"thread_id": "test_case_3"},
+        )
+        output = response["output"]
+        print(f"Response: {output}\n")
+
+        # Check if the response indicates limit was hit
+        if "exceeded" in output.lower() or "limit" in output.lower():
+            print("✅ SUCCESS: Step limit was enforced!")
+            print("✅ Test passed: Agent terminated at limit\n")
+        else:
+            print("⚠️  Agent completed without hitting limit")
+            print("   (This might happen if task was very simple)\n")
+    except Exception as e:
+        print(f"Exception raised: {type(e).__name__}: {e}")
+        print("✅ Test passed: Step limit enforced via exception\n")
+
+
+async def test_case_4_delegation_depth_exceeded():
+    """Test Case 4: Delegation Depth Exceeded - Zero depth."""
+    print("\n" + "=" * 60)
+    print("TEST CASE 4: Delegation Depth Exceeded (depth=0)")
+    print("=" * 60)
+
+    model = ChatOpenAI(model="gpt-4o-mini", temperature=0)
+
+    # Create sub-agent
+    math_agent = LangGraphReactAgent(
+        name="MathAgent",
+        instruction="You are a math specialist. Use add_numbers tool for calculations.",
+        model=model,
+        tools=[add_numbers],
+    )
+
+    # Create coordinator
+    coordinator = LangGraphReactAgent(
+        name="Coordinator",
+        instruction="You coordinate tasks. You MUST delegate all math to MathAgent using the delegate_to_agent tool.",
+        model=model,
+        tools=[],
+    )
+    coordinator.register_delegation_agents([math_agent])
+
+    # Zero delegation depth - should block delegation
+    step_limit_config = StepLimitConfig(
+        max_steps=50,  # High steps
+        max_delegation_depth=0,  # NO delegation allowed!
+    )
+
+    print_config_validation(step_limit_config, "Zero Delegation Depth")
+
+    query = "Delegate to MathAgent to calculate 20 + 30"
+    print(f"Query: {query}")
+    print("Expected: Delegation should be BLOCKED (depth=0)\n")
+    print("The coordinator will try to delegate but should get an error\n")
+
+    try:
+        response = await coordinator.arun(
+            query=query,
+            step_limit_config=step_limit_config,
+            configurable={"thread_id": "test_case_4"},
+        )
+        output = response["output"]
+        print(f"Response: {output}\n")
+
+        # Check if delegation was blocked
+        if (
+            "cannot" in output.lower()
+            or "depth" in output.lower()
+            or "exceeded" in output.lower()
+            or "error" in output.lower()
+        ):
+            print("✅ SUCCESS: Delegation depth limit enforced!")
+            print("✅ Test passed: Delegation was blocked\n")
+        else:
+            print("⚠️  Agent responded without delegating")
+            print("   (Coordinator may have answered directly instead)\n")
+    except Exception as e:
+        print(f"Exception raised: {type(e).__name__}: {e}")
+        if "delegation" in str(e).lower() or "depth" in str(e).lower():
+            print("✅ Test passed: Delegation depth enforced via exception\n")
+        else:
+            print("⚠️  Different error occurred\n")
+
+
+async def main():
+    """Run all test cases."""
+    print("=" * 60)
+    print("Step Limit Configuration - Test Suite")
+    print("=" * 60)
+    print("\nRunning 4 test cases:")
+    print("1. Success with high limits")
+    print("2. Parallel tool batch accounting demo")
+    print("3. Step limit exceeded")
+    print("4. Delegation depth exceeded")
+    print("\nNOTE: Some limits are enforced silently via the agent's")
+    print("      internal logic. Check for error messages in responses.")
+
+    await test_case_1_success_no_limits()
+    await test_case_2_parallel_tool_batch_accounting()
+    await test_case_3_step_limit_exceeded()
+    await test_case_4_delegation_depth_exceeded()
+
+    print("\n" + "=" * 60)
+    print("All test cases completed!")
+    print("=" * 60)
+    print("\n📝 Summary:")
+    print("- Test 1: Should show successful completion")
+    print("- Test 2: Shows that parallel tool batches consume multiple steps at once")
+    print("- Test 3: Should show step limit enforcement")
+    print("- Test 4: Should show delegation blocking")
+
+
+if __name__ == "__main__":
+    # Check for API key
+    if not os.getenv("OPENAI_API_KEY"):
+        print("ERROR: OPENAI_API_KEY environment variable not set!")
+        print("Please set it before running:")
+        print('export OPENAI_API_KEY="your-key-here"')
+        exit(1)
+
+    asyncio.run(main())