from agenticai_core.designtime.models.app import App, OrchestratorType
from agenticai_core.designtime.models.agent import Agent
from agenticai_core.designtime.models.llm_model import LlmModel
from agenticai_core.designtime.models.tool import Tool

app = App(
    name="My Assistant",
    orchestrationType=OrchestratorType.CUSTOM_SUPERVISOR,
    agents=[
        Agent(
            name="HelperAgent",
            llm_model=LlmModel(model="gpt-4o-mini", provider="Open AI", connection_name="Default Connection"),
            tools=[Tool(name="MyTool", type="MCP")]
        )
    ]
)

from agenticai_core.designtime.models.tool import Tool
from agenticai_core.runtime.sessions.request_context import RequestContext, Logger

@Tool.register(name="MyTool", description="Example tool")
async def my_tool():
    ctx = RequestContext()
    logger = Logger('MyTool')

    await logger.info("Tool executed")
    return {"success": True}

python run.py package -o my-app
python run.py config -u prod
python run.py deploy -f bin/my-app/application.kar

from agenticai_core.designtime.models.app import AppBuilder

app_dict = AppBuilder() \
    .set_name("My Banking App") \
    .set_description("Comprehensive banking services") \
    .set_orchestrator_type(OrchestratorType.CUSTOM_SUPERVISOR) \
    .set_agents([agent1, agent2]) \
    .set_memory_stores([memory_store]) \
    .build()

app = App(**app_dict)

app = App(
    name="Customer Service",
    orchestrationType=OrchestratorType.CUSTOM_SUPERVISOR,
    agents=[
        Agent(name="RoutingAgent", role=AgentRole.SUPERVISOR),
        Agent(name="SupportAgent", role=AgentRole.WORKER),
        Agent(name="BillingAgent", role=AgentRole.WORKER)
    ]
)

from agenticai_core.designtime.models.agent import Agent, AgentRole, AgentSubType, AgentType
from agenticai_core.designtime.models.llm_model import LlmModel, LlmModelConfig
from agenticai_core.designtime.models.prompt import Prompt
from agenticai_core.designtime.models.tool import Tool

agent = Agent(
    name="FinanceAssist",
    description="Banking assistant for account management",
    role=AgentRole.WORKER,
    sub_type=AgentSubType.REACT,
    type=AgentType.AUTONOMOUS,
    llm_model=LlmModel(
        model="gpt-4o",
        provider="Open AI",
        connection_name="Default Connection",
        modelConfig=LlmModelConfig(temperature=0.7, max_tokens=1600)
    ),
    prompt=Prompt(
        system="You are a helpful banking assistant.",
        custom="Assist with account inquiries and transactions."
    ),
    tools=[Tool(name="Get_Balance", type="MCP")]
)

from agenticai_core.designtime.models.agent import AgentBuilder

agent_dict = AgentBuilder() \
    .set_name("CustomerService") \
    .set_description("Customer service agent") \
    .set_role(AgentRole.WORKER) \
    .set_sub_type(AgentSubType.REACT) \
    .set_type(AgentType.AUTONOMOUS) \
    .set_llm_model(llm_model) \
    .set_prompt(prompt) \
    .set_tools([tool1, tool2]) \
    .build()

agent = Agent(**agent_dict)

@Tool.register(name="tool_name", description="What this tool does")
async def tool_function(param1: str, param2: int):
    # Implementation
    return result

from agenticai_core.designtime.models.tool import Tool

@Tool.register(name="get_weather", description="Get current weather for a location")
def get_weather(location: str):
    return {"temp": 72, "condition": "sunny"}

tool = Tool(
    name="Get_AccountInfo",
    description="Gets the account information for the user",
    type="inlineTool",
    code_type="javascript",
    func="""
    const account = await fetchAccount(userId);
    return account;
    """,
    return_direct=False
)

tool = Tool(
    name="Transfer_Funds",
    description="Transfers funds between accounts",
    type="toolLibrary",
    properties=[
        {"property": "from_account", "type": "string", "required": True, "description": "Source account ID"},
        {"property": "to_account", "type": "string", "required": True, "description": "Destination account ID"},
        {"property": "amount", "type": "number", "required": True, "description": "Amount to transfer"}
    ]
)

from agenticai_core.designtime.models.tool import ToolBuilder

tool_dict = ToolBuilder() \
    .set_name("Get_AccountInfo") \
    .set_description("Gets account information") \
    .set_type("inlineTool") \
    .set_code_type("javascript") \
    .set_func("return await getAccount();") \
    .set_return_direct(False) \
    .build()

tool = Tool(**tool_dict)

from agenticai_core.designtime.models.llm_model import LlmModel, LlmModelConfig

llm = LlmModel(
    model="gpt-4o",
    provider="Open AI",
    connection_name="OpenAI Connection",
    modelConfig=LlmModelConfig(temperature=0.7, max_tokens=1600, top_p=1.0)
)

llm = LlmModel(
    model="claude-3-5-sonnet-20240620",
    provider="Anthropic",
    connection_name="Anthropic Connection",
    modelConfig=LlmModelConfig(temperature=1.0, max_tokens=1024, top_p=0.7, top_k=5)
)

llm = LlmModel(
    model="gpt-4",
    provider="Azure OpenAI",
    connection_name="Azure Connection",
    modelConfig=LlmModelConfig(temperature=0.8, max_tokens=2048)
)

from agenticai_core.designtime.models.llm_model import LlmModelBuilder, LlmModelConfigBuilder, LlmModelConfig

config_dict = LlmModelConfigBuilder() \
    .set_temperature(0.7) \
    .set_max_tokens(1600) \
    .set_top_p(0.9) \
    .build()

llm_dict = LlmModelBuilder() \
    .set_model("gpt-4o") \
    .set_provider("Open AI") \
    .set_connection_name("Default Connection") \
    .set_model_config(LlmModelConfig(**config_dict)) \
    .build()

llm = LlmModel(**llm_dict)

from agenticai_core.designtime.models.prompt import Prompt

prompt = Prompt(
    system="You are a helpful assistant.",
    custom="You assist users with banking operations."
)

prompt = Prompt(
    system="You are a banking assistant.",
    custom="You help customers manage accounts and transactions.",
    instructions=[
        "Never ask for passwords or PINs.",
        "Always confirm transaction amounts.",
        "Be professional and courteous."
    ]
)

prompt = Prompt(
    system="You are a helpful assistant.",
    custom="""You are an intelligent banking assistant.

    The customer's account information:
    {{memory.accountInfo.accounts}}

    Use this to answer account queries without invoking tools.
    """,
    instructions=[
        "Never ask for or store passwords, PINs, CVV numbers, or OTPs.",
        "Keep responses concise and provide key information first."
    ]
)

supervisor_prompt = Prompt(
    system="You are a helpful assistant.",
    custom="""You are acting as an AI Supervisor for "{{app_name}}".

    {{app_description}}

    ### Rules:
    1. Small-talk: Respond directly to the user.
    2. Direct routing: Match requests to workers by expertise.
    3. Multi-intent: Break into individual requests and route each.
    """
)

from agenticai_core.designtime.models.memory_store import (
    MemoryStore, Namespace, NamespaceType,
    RetentionPolicy, RetentionPeriod, Scope
)

memory_store = MemoryStore(
    name="Account Information",
    technical_name="accountInfo",
    type="hotpath",
    description="Stores user account balances and details",
    schema_definition={
        "type": "object",
        "properties": {
            "accounts": {
                "type": "array",
                "items": {
                    "type": "object",
                    "properties": {
                        "account_id": {"type": "string"},
                        "balance": {"type": "number"},
                        "currency": {"type": "string"}
                    }
                }
            }
        }
    },
    strict_schema=False,
    namespaces=[
        Namespace(name="session_id", type=NamespaceType.DYNAMIC, value="{session_id}")
    ],
    scope=Scope.SESSION_LEVEL,
    retention_policy=RetentionPolicy(type=RetentionPeriod.SESSION, value=1)
)

user_preferences = MemoryStore(
    name="User Preferences",
    technical_name="userPrefs",
    type="persistent",
    description="User preference and settings",
    schema_definition={
        "type": "object",
        "properties": {
            "theme": {"type": "string"},
            "language": {"type": "string"},
            "notifications": {"type": "boolean"}
        }
    },
    strict_schema=True,
    namespaces=[
        Namespace(name="user_id", type=NamespaceType.DYNAMIC, value="{user_id}")
    ],
    scope=Scope.USER_SPECIFIC,
    retention_policy=RetentionPolicy(type=RetentionPeriod.MONTH, value=6)
)

from agenticai_core.designtime.models.app_configuration import (
    AppConfigurations, FillerMessages, FillerMessageMode, StaticConfig
)

filler = FillerMessages(
    enabled=True,
    initial_delay=1000,
    interval_duration=2000,
    max_message_count=4,
    mode=FillerMessageMode.STATIC,
    static_config=StaticConfig(
        messages=[
            {"type": "text", "value": "Processing your request..."},
            {"type": "text", "value": "Almost there..."}
        ]
    )
)

config = AppConfigurations(streaming=True, filler_messages=filler)

from agenticai_core.designtime.models.app_configuration import (
    FillerMessages, FillerMessageMode, DynamicConfig
)
from agenticai_core.designtime.models.llm_model import LlmModel, LlmModelConfig

filler = FillerMessages(
    enabled=True,
    initial_delay=1000,
    interval_duration=2000,
    max_message_count=4,
    mode=FillerMessageMode.DYNAMIC,
    dynamic_config=DynamicConfig(
        llm_model=LlmModel(
            provider="Anthropic",
            model="claude-3-5-sonnet-20240620",
            connection_name="Default Connection",
            modelConfig=LlmModelConfig(temperature=1.0, top_p=0.7, top_k=5, max_tokens=1024)
        ),
        llm_timeout="1s",
        context_window=50
    )
)

from agenticai_core.designtime.models.app_namespace import AppNamespace

namespaces = [
    AppNamespace(name="default", description="Common application variables"),
    AppNamespace(name="authentication", description="User authentication and authorization"),
    AppNamespace(name="database", description="Database connections and queries"),
    AppNamespace(name="api_service", description="External API integrations")
]

from agenticai_core.designtime.models.icon import Icon

# Avatar for an agent
agent_icon = Icon(name="avatar1", color="#B2CCFF", type="human")

# Logo with gradient
app_logo = Icon(
    name="logo18",
    color="linear-gradient(45deg, #528BFF 0%, #004EEB 100%)",
    type="logo"
)

# Action icon for a tool
tool_icon = Icon(name="calendar-check-01", color="#32D583", type="icon")

from agenticai_core.runtime.sessions.request_context import RequestContext

@Tool.register(name="demo_tool", description="RequestContext demo")
async def demo_tool():
    ctx = RequestContext()

    user_id = ctx.context.get('userId')
    session_id = ctx.context.get('sessionId')
    app_id = ctx.context.get('appId')

    env = await ctx.get_environment_variables()
    memory = ctx.get_memory()

    return {"user_id": user_id, "session_id": session_id}

@Tool.register(name="config_tool", description="Access environment variables")
async def config_tool():
    ctx = RequestContext()
    env = await ctx.get_environment_variables()

    # Direct access (raises AttributeError if missing)
    api_url = env.API_BASE_URL

    # Safe access with default
    timeout = int(env.get('TIMEOUT', '30'))
    retry_count = int(env.get('RETRY_COUNT', '3'))

    # Existence check
    debug_enabled = env.DEBUG_MODE.lower() == 'true' if 'DEBUG_MODE' in env else False

    return {"api_url": api_url, "timeout": timeout}

config = {
    "api_url": env.get('API_URL', 'https://api.example.com'),
    "port": int(env.get('PORT', '8080')),
    "debug": env.get('DEBUG', 'false').lower() == 'true',
    "allowed_hosts": env.get('ALLOWED_HOSTS', 'localhost').split(',')
}

@Tool.register(name="UserProfileManager", description="Manage user profile data")
async def manage_user_profile(action: str, data: dict = None):
    ctx = RequestContext()
    memory = ctx.get_memory()

    if action == "get_profile":
        result = await memory.get_content('user_preferences', {
            'firstname': 1, 'lastname': 1, 'email': 1
        })
        return {"profile": result.data} if result.success else {"profile": None}

    elif action == "update_profile":
        result = await memory.set_content('user_preferences', data)
        return {"success": result.success}

    elif action == "delete_profile":
        result = await memory.delete_content('user_preferences')
        return {"success": result.success}

@Tool.register(name="UserDataManager", description="Manage user data")
async def user_data_manager(data: dict = None):
    ctx = RequestContext()

    async with ctx.get_memory_store_manager('user_data') as store:
        if data:
            result = await store.set(data)
            return {"success": True}
        else:
            result = await store.get({'profile': 1, 'preferences': 1})
            return {"data": result}

@Tool.register(name="ShoppingCartManager", description="Manage cart and preferences")
async def manage_shopping_data():
    ctx = RequestContext()

    async with ctx.get_memory_store_manager('user_preferences') as prefs_store, \
               ctx.get_memory_store_manager('shopping_cart') as cart_store:

        prefs = await prefs_store.get({'preferred_currency': 1})
        currency = prefs.get('preferred_currency', 'USD') if prefs else 'USD'

        cart_data = await cart_store.get({'items': 1, 'total': 1})
        if cart_data:
            cart_data['currency'] = currency
            await cart_store.set(cart_data)

    return {"currency": currency}

# Include specific fields only
user_basic = await memory.get_content('user_profile', {
    'firstname': 1, 'lastname': 1, 'email': 1
})

# Exclude sensitive fields
user_safe = await memory.get_content('user_profile', {
    'password_hash': 0, 'ssn': 0
})

# Nested fields
user_address = await memory.get_content('user_profile', {
    'address.street': 1, 'address.city': 1
})

from agenticai_core.runtime.sessions.request_context import Logger
from agenticai_core.designtime.models.tool import Tool

@Tool.register(name="my_tool", description="Tool with logging")
async def my_tool(operation: str):
    logger = Logger('MyTool')

    await logger.info(f"Starting operation: {operation}")

    try:
        result = {"success": True, "data": "processed"}
        await logger.info("Operation completed successfully")
        return result
    except Exception as e:
        await logger.error(f"Operation failed: {str(e)}")
        raise

from agenticai_core.runtime.sessions.request_context import RequestContext, Logger

@Tool.register(name="integrated_tool", description="Tool with shared context")
async def integrated_tool():
    ctx = RequestContext()
    logger = Logger('IntegratedTool', request_context=ctx)

    env = await ctx.get_environment_variables()
    memory = ctx.get_memory()

    await logger.info("Tool execution completed")
    return {"success": True}

# Pass a RequestContext instance when creating the logger
ctx = RequestContext()
logger = Logger('MyTool', request_context=ctx)

await logger.info("Message")  # Correct — always await
logger.info("Message")        # Wrong — missing await

# Avoid expensive operations in log messages
if debug_enabled:
    await logger.debug(expensive_debug_info())

from agenticai_core.runtime.trace._langfuse_tracer import Tracer
from agenticai_core.designtime.models.tool import Tool

tracer = Tracer()

@Tool.register(name="get_balance", description="Get account balance")
@tracer.observe(span_name="Tool:get_balance", kind="Tool")
async def get_balance(account_id: str) -> dict:
    balance = await fetch_balance_from_db(account_id)
    return {"account_id": account_id, "balance": balance, "currency": "USD"}

from agenticai_core.runtime.agents.abstract_orchestrator import AbstractOrchestrator

class BankingOrchestrator(AbstractOrchestrator):

    def __init__(self, agents, **kwargs):
        super().__init__(name="BankingOrchestrator", agents=agents, **kwargs)
        self.tracer = Tracer()

    @tracer.observe(span_name="Orchestrator:handle_message", kind="Orchestrator")
    async def _handle_message(self, conversation):
        last_message = conversation[-1]
        response = await self.route_to_agent(last_message)
        return response

@tracer.observe(
    span_name="Tool:process_payment",
    kind="Tool",
    metadata={"payment_method": "credit_card", "merchant": "acme_corp"}
)
async def process_payment(amount: float):
    ...

# Verify environment variables are set
python -c "import os; print(os.getenv('TRACING_ENABLED'), os.getenv('LANGFUSE_HOST'))"