from dcaf.core import Agent, serve
from dcaf.tools import tool

# Define tools with the @tool decorator
@tool(description="List Kubernetes pods")
def list_pods(namespace: str = "default") -> str:
    """List pods in a namespace."""
    return f"Pods in {namespace}: nginx, redis, api"

@tool(requires_approval=True, description="Delete a pod")
def delete_pod(name: str, namespace: str = "default") -> str:
    """Delete a pod. Requires user approval."""
    return f"Deleted pod {name} from {namespace}"

# Create the agent
agent = Agent(
    tools=[list_pods, delete_pod],
    system_prompt="You are a helpful Kubernetes assistant.",
)

# Start the server
serve(agent)  # Running at http://0.0.0.0:8000

from dcaf.tools import tool

@tool(description="Get current weather")
def get_weather(city: str) -> str:
    """Get weather for a city."""
    return f"Weather in {city}: 72°F, sunny"

@tool(requires_approval=True, description="Send an email")
def send_email(to: str, subject: str, body: str) -> str:
    """Send an email. Requires approval because it's an external action."""
    # Email sending logic here
    return f"Email sent to {to}"

response = agent.run(messages=[
    {"role": "user", "content": "Delete the nginx pod"}
])

if response.needs_approval:
    print("Pending approvals:")
    for tool in response.pending_tools:
        print(f"  - {tool.name}: {tool.input}")
    
    # Approve and continue
    response = response.approve_all()

print(response.text)

from dcaf.core import Agent, LLMRequest, LLMResponse, InterceptorError

# Add context before sending to LLM
def add_tenant_context(request: LLMRequest) -> LLMRequest:
    tenant = request.context.get("tenant_name", "unknown")
    request.add_system_context(f"User's tenant: {tenant}")
    return request

# Block suspicious input
def validate_input(request: LLMRequest) -> LLMRequest:
    if "ignore instructions" in request.get_latest_user_message().lower():
        raise InterceptorError("I can't process this request.")
    return request

# Clean up responses
def redact_secrets(response: LLMResponse) -> LLMResponse:
    response.text = response.text.replace("sk-secret", "[REDACTED]")
    return response

agent = Agent(
    tools=[...],
    request_interceptors=[validate_input, add_tenant_context],
    response_interceptors=redact_secrets,
)

for event in agent.run_stream(messages=[...]):
    if isinstance(event, TextDeltaEvent):
        print(event.text, end="", flush=True)

from dcaf.core import Agent, load_agent_config

config = load_agent_config()  # Loads from environment
agent = Agent(tools=[my_tool], **config)

agent = Agent(
    provider="bedrock",
    model="anthropic.claude-3-sonnet-20240229-v1:0",
    aws_profile="my-profile"
)

# AWS Bedrock (default)
agent = Agent(provider="bedrock", aws_profile="my-profile")

# Google Vertex AI (auto-detects project/location on GCP)
agent = Agent(provider="google", model="gemini-2.5-pro")

# Anthropic Direct
agent = Agent(provider="anthropic", model="claude-3-sonnet-20240229", api_key=os.getenv("ANTHROPIC_API_KEY"))

from dcaf.llm import BedrockLLM

llm = BedrockLLM(region_name="us-east-1")

response = llm.invoke(
    messages=[{"role": "user", "content": "Hello"}],
    model_id="us.anthropic.claude-3-5-sonnet-20240620-v1:0",
    max_tokens=1000,
    tools=[...],  # Optional tool schemas
)

from dcaf.llm import BedrockLLM
from dcaf.agents import ToolCallingAgent
from dcaf.tools import tool
from dcaf.agent_server import create_chat_app
import uvicorn

# Create tools with full schema
@tool(
    schema={
        "name": "get_weather",
        "description": "Get weather for a location",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {"type": "string", "description": "City name"}
            },
            "required": ["city"]
        }
    },
    requires_approval=False
)
def get_weather(city: str) -> str:
    return f"Weather in {city}: 72°F, sunny"

# Create LLM and agent separately
llm = BedrockLLM(region_name="us-east-1")
agent = ToolCallingAgent(
    llm=llm,
    tools=[get_weather],
    system_prompt="You are a helpful assistant.",
    model_id="us.anthropic.claude-3-5-sonnet-20240620-v1:0",
    max_iterations=10,
    enable_terminal_cmds=True,
)

# Create and run server
app = create_chat_app(agent)

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

@tool(
    schema={
        "name": "delete_file",
        "description": "Delete a file",
        "input_schema": {
            "type": "object",
            "properties": {
                "path": {"type": "string", "description": "File path"}
            },
            "required": ["path"]
        }
    },
    requires_approval=True
)
def delete_file(path: str) -> str:
    return f"Deleted {path}"

@tool(requires_approval=True, description="Delete a file")
def delete_file(path: str) -> str:
    """Delete a file at the given path."""
    return f"Deleted {path}"