# LLM Client (HuggingFace or OpenAI-compatible)
alias CodeAgentEx.LLM.Client

Client.chat_completion(
  model,
  messages,
  response_schema,
  api_key: "hf_your_token_here"
)

# Start an IEx session
iex -S mix

# Run a simple calculation
alias CodeAgentEx.{CodeAgent, AgentConfig}

config = AgentConfig.new(
  model: "Qwen/Qwen3-Coder-30B-A3B-Instruct",
  max_steps: 5
)

{:ok, result, _state} = CodeAgent.run(
  "Calculate the factorial of 10 and format it nicely",
  config
)

# In IEx
alias CodeAgentEx.IexTest

# Run all tests
IexTest.test_all()

# Run individual tests
IexTest.test1()
IexTest.test11()  # Reusable orchestrator pattern

# Custom task
IexTest.run("Calculate the sum of squares from 1 to 100")

config = AgentConfig.new(max_steps: 3)

CodeAgent.run(
  "Calculate 25 * 4, then add 10 to the result",
  config
)
# => {:ok, "110", state}

alias CodeAgentEx.Tool

# Option 1: Using Tool struct (explicit)
user_data_tool = %Tool{
  name: :get_user_data,
  description: "Returns a map with user information including name, age, and test scores",
  inputs: %{},
  output_type: "map",
  function: fn ->
    %{
      name: "Alice",
      age: 30,
      scores: [85, 92, 78, 95, 88]
    }
  end
}

# Option 2: Using plain map (auto-converted)
# This is the format used by external tool packages like code_agent_ex_tools
weather_tool = %{
  name: :get_weather,
  description: "Returns the current weather for a city",
  inputs: %{"city" => %{type: "string", description: "Name of the city"}},
  output_type: "string",
  function: fn city -> "Weather in #{city}: Sunny, 22°C" end
}

config = AgentConfig.new(
  tools: [user_data_tool, weather_tool],  # Mix structs and maps
  max_steps: 5
)

CodeAgent.run(
  "Get the user data and calculate their average test score. Also check the weather in Paris.",
  config
)

alias CodeAgentEx.{AgentConfig, Tool}

# Create a specialized data processor agent
processor = AgentConfig.new(
  name: :data_processor,
  instructions: "Specialized agent for processing and analyzing data",
  tools: [],
  max_steps: 3
)

# Main agent can delegate to the processor
config = AgentConfig.new(
  managed_agents: [processor],
  max_steps: 8
)

CodeAgent.run(
  "Use the data_processor to analyze a list of numbers and find statistics",
  config
)

alias CodeAgentEx.{AgentConfig, AgentOrchestrator}

# Define configuration once
config = AgentConfig.new(
  name: :assistant,
  instructions: "You are a helpful data analyst",
  tools: [my_data_tool],
  max_steps: 8
)

# Start orchestrator once and reuse for multiple tasks
with {:ok, orch} <- AgentOrchestrator.start_link(config),
     {:ok, answer1} <- AgentOrchestrator.run_task(orch, "What is the average salary?"),
     {:ok, answer2} <- AgentOrchestrator.run_task(orch, "How many employees in Engineering?"),
     {:ok, answer3} <- AgentOrchestrator.run_task(orch, "Who has the highest salary?") do

  IO.puts("1. #{answer1}")
  IO.puts("2. #{answer2}")
  IO.puts("3. #{answer3}")

  AgentOrchestrator.stop(orch)
end

alias CodeAgentEx.Tool

temperature_tool = %Tool{
  name: :get_temperature,
  description: "Returns the current temperature in Celsius for a city. Call with: get_temperature.(city_name)",
  inputs: %{
    "city_name" => %{type: "string", description: "Name of the city"}
  },
  output_type: "number",
  function: fn city ->
    # Your implementation here
    # Could call an API, database, etc.
    case city do
      "Paris" -> 15.5
      "Tokyo" -> 22.0
      _ -> 20.0
    end
  end
}

config = AgentConfig.new(
  tools: [temperature_tool],
  max_steps: 3
)

CodeAgent.run("What's the temperature in Paris?", config)

alias CodeAgentEx.Tool

%Tool{
  name: :my_tool,
  description: "Description of what the tool does",
  inputs: %{"param" => %{type: "string", description: "Parameter description"}},
  output_type: "string",
  function: fn param -> "result" end
}

AgentConfig.new(
  # Agent identity
  name: :my_agent,                    # Agent name (atom)

  # Behavior
  instructions: "Custom instructions", # How agent should behave

  # Tools and delegation
  tools: [tool1, tool2],               # Available tools
  managed_agents: [agent1, agent2],    # Sub-agents for delegation

  # LLM settings
  model: "Qwen/Qwen3-Coder-30B-A3B-Instruct",  # Model to use
  adapter: InstructorLite.Adapters.ChatCompletionsCompatible,  # InstructorLite adapter
  llm_opts: [                          # Additional LLM options
    temperature: 0.7,
    max_tokens: 4000,
    tool_choice: "none"
  ],

  # Execution limits
  max_steps: 10,                       # Maximum iterations

  # Advanced
  listener_pid: self(),                # Event listener
  response_schema: MyCustomSchema      # Custom Ecto schema for final response
)

{:instructor_lite, "~> 1.1.2"}  # Structured LLM outputs with Ecto schemas
{:req, "~> 0.5"}                # HTTP client
{:jason, "~> 1.2"}              # JSON encoding/decoding