LLMTornadoModelProvider client = new(ChatModel.OpenAi.Gpt41.V41Mini,
                        [new ProviderAuthentication(LLmProviders.OpenAi, 
                        Environment.GetEnvironmentVariable("OPENAI_API_KEY")!),]);
Agent agent = new Agent(client, "Assistant", "Have fun");
RunResult result = await Runner.RunAsync(agent, "Hello World!");

[Description("Steps to complete problem")]
public struct math_step
{
    public string explanation { get; set; }
    public string output { get; set; }
}
Agent agent = new Agent(client,  _output_schema:typeof(math_step));
RunResult result = await Runner.RunAsync(agent, "How can I solve 8x + 7 = -23?");
//Helper function to extract json from last message
math_step mathResult = result.ParseJson<math_step>();

void async Task Run()
{
    Agent agent = new Agent(
        client
        _tools : [GetCurrentWeather]);
    RunResult result = await Runner.RunAsync(agent, "What is the weather in boston?");
    Console.WriteLine(result.Text);
}
[Tool( Description = "Get the current weather in a given location",
       In_parameters_description = [
        "The city and state, e.g. Boston, MA",
        "The temperature unit to use. Infer this from the specified location."
        ])]
public string GetCurrentWeather(string location, Unit unit = Unit.celsius)
{
    // Call the weather API here.
    return $"31 C";
} 

class ReportingState : AgentState<string, ReportData>
{
    public ReportingState(StateMachine stateMachine) : base(stateMachine){}
    public override Agent InitilizeStateAgent()
    {
        return new Agent(
            client: new OpenAIModelClient("gpt-4o-mini"), 
            _name: "Reporting agent",
            _instructions: """
                You are a senior researcher tasked with writing a cohesive report for a research query.
                You will be provided with the original query, and some initial research done by a research assistant.
                Generate a detailed report in markdown format.
                """, 
            _output_schema: typeof(ReportData)
        );
    }
    public override async Task<ReportData> Invoke(string input)
    {
        return await BeginRunnerAsync<ReportData>(input);
    }
}

public class ResearchAgent : AgentStateMachine<string, ReportData>
{
    public ResearchAgent(LombdaAgent lombdaAgent) : base(lombdaAgent) { }
    public override void InitilizeStates()
    {
        // Setup states
        ResearchState researchState = new ResearchState(this);
        ReportingState reportingState = new ReportingState(this){ IsDeadEnd = true };
        // Setup transitions between states
        researchState.AddTransition(reportingState);
        // Set entry and output states
        SetEntryState(researchState);
        SetOutputState(reportingState);
    }
}
// Use the state machine
var agent = new ResearchAgent(new LombdaAgent());
var result = await agent.RunAsync("Research quantum computing");

class ConvertStringToIntState : BaseState<string, int>
{
    public override async Task<int> Invoke(string input)
    {
        return int.Parse(this.Input)
    }
}

//Where string is Input and int is Output
StateMachine<string, int> stateMachine = new();
//Set start state with string Input
stateMachine.SetEntryState(inputState);
//Set state where output is
stateMachine.SetOutputState(resultState);
//Return list of Output objects from State 
//List because machine might generate more than 1 output depending on flow
List<int> stateResults = await stateMachine.Run("3");---
### Allow states to transition to other states in a parallel workflow 
//AllowsParallelTransitions = true Allows state Outputs to transition to all states that meet the criteria
ConvertStringToIntState inputState = new() { AllowsParallelTransitions = true };
IntPlus3State state3 = new();
IntPlus4State state4 = new();
//CombineInput = true only does 1 execution reguardless of # of Inputs
//Handle all of the Inputs
SummingState summingState = new() { CombineInput = true };
ConvertIntToStringState resultState = new();
//should happen in parallel and get result
inputState.AddTransition(state3);
inputState.AddTransition(state4);
//summing State will get both results next tick
state3.AddTransition(summingState);
state4.AddTransition(summingState);
//Will sum all inputs 
summingState.AddTransition(resultState);
//Convert result and End the State Machine 
resultState.AddTransition(new ExitState());
//Create Input & Output State Machine
StateMachine<string, string> stateMachine = new();
//Define Entry and Output States
stateMachine.SetEntryState(inputState);
stateMachine.SetOutputState(resultState);
//Run the StateMachine
List<string?> stateResults = await stateMachine.Run("3");

ConvertStringToIntState inputState = new();
ConvertStringToIntState resultState = new();
//Input State will convert string to int
inputState.AddTransition((result) => result.ToString(), resultState);
resultState.AddTransition(new ExitState());
StateMachine<string, int?> stateMachine = new();
stateMachine.SetEntryState(inputState);
stateMachine.SetOutputState(resultState);
var stateResults = await stateMachine.Run(["3","2","4"]);
Console.WriteLine($"State Results: {string.Join(", ", stateResults.Select(r => string.Join(", ", r)))}");
Assert.IsTrue(stateResults[0].Contains(3));

// Create a LombdaAgent instance
LombdaAgent lombdaAgent = new LombdaAgent();
// Create and run a stateful agent workflow
ResearchAgent researchAgent = new ResearchAgent(lombdaAgent);
ReportData result = await researchAgent.RunAsync("Research quantum computing applications in medicine");
// Monitor events and get logs
lombdaAgent.VerboseCallback += (message) => Console.WriteLine($"[VERBOSE] {message}");
lombdaAgent.StreamingCallback += (update) => Console.WriteLine($"[STREAM] {update}");

// Subscribe to verbose logs
lombdaAgent.RunningVerboseCallback += (message) => {
    Debug.WriteLine($"[VERBOSE]: {message}");
};
// Subscribe to streaming updates
lombdaAgent.RunningStreamingCallback += (update) => {
    UI.UpdateStreamingPanel(update);
};