aip-agents-binary 0.5.20__py3-none-manylinux_2_31_x86_64.whl

aip_agents/examples/hello_world_multi_agent_langchain.pyi

@@ -0,0 +1,5 @@
+from aip_agents.agent import LangChainAgent as LangChainAgent
+from aip_agents.examples.tools.langchain_arithmetic_tools import add_numbers as add_numbers
+
+async def main() -> None:
+    """Main function demonstrating the multi-agent setup with LangChainAgent."""

aip_agents/examples/hello_world_multi_agent_langgraph.py

@@ -0,0 +1,66 @@
+"""Example demonstrating a multi-agent setup with a CoordinatorAgent.
+
+This example showcases:
+1. How to define multiple specialized agents (WeatherAgent, MathAgent).
+2. How to set up a CoordinatorAgent that can delegate to these specialized agents.
+3. How the CoordinatorAgent uses dynamically created tools to call sub-agents.
+4. How the CoordinatorAgent can delegate tasks to the appropriate sub-agents.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+    Putu Ravindra Wiguna (putu.r.wiguna@gdplabs.id)
+"""
+
+import asyncio
+
+from langchain_openai import ChatOpenAI
+
+from aip_agents.agent import LangGraphAgent
+from aip_agents.examples.tools import weather_tool_langchain as weather_tool
+from aip_agents.examples.tools.langchain_arithmetic_tools import add_numbers
+
+
+async def main():
+    """Main function demonstrating the multi-agent setup with LangGraphAgent."""
+    llm = ChatOpenAI(model="gpt-4.1", temperature=0)
+
+    # --- Agent Definitions (tools and sub_agents inlined) ---
+    weather_agent = LangGraphAgent(
+        name="WeatherAgent",
+        instruction="You are a weather expert. You must use the get_weather tool to find weather information.",
+        model=llm,
+        tools=[weather_tool],
+    )
+
+    math_agent = LangGraphAgent(
+        name="MathAgent",
+        instruction=(
+            "You are a math expert. You must use the 'add_numbers' tool to perform addition. "
+            "The tool takes two integer arguments: 'a' and 'b'.\n"
+            "For example, to add 5 and 7, you would call add_numbers(a=5, b=7)."
+        ),
+        model=llm,
+        tools=[add_numbers],
+    )
+
+    coordinator_agent = LangGraphAgent(
+        name="CoordinatorAgent",
+        instruction=(
+            "You are a coordinator agent. Your primary role is to delegate tasks to specialized agents. "
+            "Based on the user's query, decide which agent (WeatherAgent or MathAgent) is best suited. "
+            "If a query involves multiple aspects, delegate accordingly. Synthesize their responses."
+        ),
+        model=llm,
+        agents=[weather_agent, math_agent],
+    )
+
+    print("--- Agents Initialized ---")
+
+    query = "What is the weather in Tokyo and what is 5 + 7?"
+    print(f"\n--- Running query: {query} ---")
+    response = await coordinator_agent.arun(query=query)
+    print(f"Response: {response.get('output')}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

aip_agents/examples/hello_world_multi_agent_langgraph.pyi

@@ -0,0 +1,5 @@
+from aip_agents.agent import LangGraphAgent as LangGraphAgent
+from aip_agents.examples.tools.langchain_arithmetic_tools import add_numbers as add_numbers
+
+async def main() -> None:
+    """Main function demonstrating the multi-agent setup with LangGraphAgent."""

aip_agents/examples/hello_world_multi_agent_langgraph_lm_invoker.py

@@ -0,0 +1,69 @@
+"""Example demonstrating a multi-agent setup with a CoordinatorAgent.
+
+This example showcases:
+1. How to define multiple specialized agents (WeatherAgent, MathAgent).
+2. How to set up a CoordinatorAgent that can delegate to these specialized agents.
+3. How the CoordinatorAgent uses dynamically created tools to call sub-agents.
+4. How the CoordinatorAgent can delegate tasks to the appropriate sub-agents.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+    Putu Ravindra Wiguna (putu.r.wiguna@gdplabs.id)
+"""
+
+import asyncio
+
+from dotenv import load_dotenv
+
+from aip_agents.agent import LangGraphAgent
+from aip_agents.examples.tools import weather_tool_langchain as weather_tool
+from aip_agents.examples.tools.langchain_arithmetic_tools import add_numbers
+
+load_dotenv(override=True)
+
+
+async def main():
+    """Main function demonstrating the multi-agent setup with Lang."""
+    # llm = ChatOpenAI(model="gpt-4.1", temperature=0)
+    llm = "openai/gpt-4o"
+
+    # --- Agent Definitions (tools and sub_agents inlined) ---
+    weather_agent = LangGraphAgent(
+        name="WeatherAgent",
+        instruction="You are a weather expert. You must use the get_weather tool to find weather information.",
+        model=llm,
+        tools=[weather_tool],
+    )
+
+    math_agent = LangGraphAgent(
+        name="MathAgent",
+        instruction=(
+            "You are a math expert. You must use the 'add_numbers' tool to perform addition. "
+            "The tool takes two integer arguments: 'a' and 'b'.\n"
+            "For example, to add 5 and 7, you would call add_numbers(a=5, b=7)."
+        ),
+        model=llm,
+        tools=[add_numbers],
+    )
+
+    coordinator_agent = LangGraphAgent(
+        name="CoordinatorAgent",
+        instruction=(
+            "You are a coordinator agent. Your primary role is to delegate tasks to specialized agents. "
+            "Based on the user's query, decide which agent (WeatherAgent or MathAgent) is best suited. "
+            "If a query involves multiple aspects, delegate accordingly. Synthesize their responses."
+        ),
+        model=llm,
+        agents=[weather_agent, math_agent],
+    )
+
+    print("--- Agents Initialized ---")
+
+    query = "What is the weather in Tokyo and what is 5 + 7?"
+    print(f"\n--- Running query: {query} ---")
+    response = await coordinator_agent.arun(query=query)
+    print(f"Response: {response.get('output')}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

aip_agents/examples/hello_world_multi_agent_langgraph_lm_invoker.pyi

@@ -0,0 +1,5 @@
+from aip_agents.agent import LangGraphAgent as LangGraphAgent
+from aip_agents.examples.tools.langchain_arithmetic_tools import add_numbers as add_numbers
+
+async def main() -> None:
+    """Main function demonstrating the multi-agent setup with Lang."""

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_pii_logger.pyi

@@ -0,0 +1,5 @@
+from _typeshed import Incomplete
+from aip_agents.utils.logger import get_logger as get_logger
+
+logger: Incomplete
+sensitive_info: str

aip_agents/examples/hello_world_sentry.py

@@ -0,0 +1,133 @@
+"""This is a simple FastAPI app to test Sentry with Open Telemetry from BOSA 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="Bosa 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_sentry.pyi

@@ -0,0 +1,21 @@
+from _typeshed import Incomplete
+from aip_agents.examples.hello_world_langgraph import langgraph_example as langgraph_example
+from aip_agents.sentry import setup_telemetry as setup_telemetry
+from aip_agents.utils.logger import get_logger as get_logger
+from fastapi import FastAPI
+
+logger: Incomplete
+BASE_URL: str
+SENTRY_ENVIRONMENT: Incomplete
+USE_OPENTELEMETRY: Incomplete
+
+def fetch_endpoints() -> None:
+    """Fetch all endpoints from the server."""
+def create_app() -> FastAPI:
+    """Create and configure the FastAPI application.
+
+    Returns:
+        FastAPI: The configured FastAPI application.
+    """
+def run_server() -> None:
+    """Run the FastAPI server."""

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())

aip_agents/examples/hello_world_step_limits.pyi

@@ -0,0 +1,17 @@
+from aip_agents.agent import LangGraphReactAgent as LangGraphReactAgent
+from aip_agents.examples.tools.langchain_arithmetic_tools import add_numbers as add_numbers
+from aip_agents.schema.step_limit import MaxStepsExceededError as MaxStepsExceededError, StepLimitConfig as StepLimitConfig
+from aip_agents.utils.step_limit_manager import StepLimitManager as StepLimitManager
+
+def print_config_validation(config: StepLimitConfig | None, context: str):
+    """Print step limit configuration validation."""
+async def test_case_1_success_no_limits() -> None:
+    """Test Case 1: Success - High limits, no warnings."""
+async def test_case_2_parallel_tool_batch_accounting() -> None:
+    """Test Case 2: Demonstrate that parallel tool batches consume multiple steps."""
+async def test_case_3_step_limit_exceeded() -> None:
+    """Test Case 3: Step Limit Exceeded - Only 2 steps allowed."""
+async def test_case_4_delegation_depth_exceeded() -> None:
+    """Test Case 4: Delegation Depth Exceeded - Zero depth."""
+async def main() -> None:
+    """Run all test cases."""