Reading agent state

<Tabs groupId="language_microsoft-agent-framework_agent" items={['.NET', 'Python']} persist>
  <Tab value=".NET">
    ```csharp title="agent/Program.cs (excerpt)"
    public class AgentStateSnapshot
    {
        public string Language { get; set; } = "english";
    }
    ```
  </Tab>
  <Tab value="Python">
    ```python title="main.py"
    from __future__ import annotations
    import os
    import uvicorn
    from agent_framework import Agent, tool, SupportsChatGetResponse
    from agent_framework.openai import OpenAIChatClient
    from agent_framework.ag_ui import add_agent_framework_fastapi_endpoint
    from agent_framework.ag_ui import AgentFrameworkAgent
    from dotenv import load_dotenv
    from fastapi import FastAPI
    from typing import Annotated
    from pydantic import BaseModel, Field

    load_dotenv()

    class SearchItem(BaseModel):
        query: str
        done: bool
        
    STATE_SCHEMA: dict[str, object] = {
        "language": {
            "type": "string",
            "enum": ["english", "spanish"],
            "description": "Preferred language.",
        }
    }
    PREDICT_STATE_CONFIG: dict[str, dict[str, str]] = {
        "language": {"tool": "update_language", "tool_argument": "language"}
    }

    @tool
    def update_language(
        language: Annotated[str, Field(description="Preferred language: 'english' or 'spanish'")],
    ) -> str:
        normalized = (language or "").strip().lower()
        if normalized not in ("english", "spanish"):
            return "Language unchanged. Use 'english' or 'spanish'."
        return f"Language updated to {normalized}."


    def _build_chat_client():
        if os.getenv("AZURE_OPENAI_ENDPOINT"):
            return OpenAIChatClient(
                model=os.getenv("AZURE_OPENAI_CHAT_DEPLOYMENT_NAME", "gpt-4o-mini"),
                api_key=os.getenv("AZURE_OPENAI_API_KEY"),
                azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"),
            )
        if os.getenv("OPENAI_API_KEY"):
            return OpenAIChatClient(
                model=os.getenv("OPENAI_CHAT_MODEL_ID", "gpt-4o-mini"),
                api_key=os.getenv("OPENAI_API_KEY"),
            )
        raise RuntimeError(
            "Set either AZURE_OPENAI_ENDPOINT + AZURE_OPENAI_API_KEY, or OPENAI_API_KEY."
        )



    def create_agent(chat_client: SupportsChatGetResponse) -> AgentFrameworkAgent:
        base_agent = Agent(
            name="sample_agent",
            instructions="You are a helpful assistant.",
            client=chat_client,
            tools=[update_language],   
        )
        return AgentFrameworkAgent(
            agent=base_agent,
            name="CopilotKitMicrosoftAgentFrameworkAgent",
            description="Assistant that tracks a simple language state.",
            state_schema=STATE_SCHEMA,               
            predict_state_config=PREDICT_STATE_CONFIG, 
            require_confirmation=False,
        )
        

    chat_client = _build_chat_client()

    agent = create_agent(chat_client)

    app = FastAPI(title="Microsoft Agent Framework - Quickstart")
    add_agent_framework_fastapi_endpoint(app=app, agent=agent, path="/")

    if __name__ == "__main__":
        uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True)
    ```
  </Tab>
</Tabs>

```ts title="ui/app/page.tsx"
type AgentState = {
  language: "english" | "spanish";
}
```

```tsx title="ui/app/page.tsx"
import { useAgent } from "@copilotkit/react-core/v2"; // [!code highlight]

// Define the agent state type, should match the actual state of your agent
type AgentState = {
  language: "english" | "spanish";
}

function YourMainContent() {
  // [!code highlight:4]
  const { agent } = useAgent({
    agentId: "sample_agent",
    initialState: { language: "english" }  // optionally provide an initial state
  });

  // ...

  return (
    // style excluded for brevity
    <div>
      <h1>Your main content</h1>
      <p>Language: {agent.state?.language}</p>
    </div>
  );
}
```
<Callout type="info">
  The `agent.state` in `useAgent` is reactive and will automatically update when the agent's state changes.
</Callout>

<Frame>
  <ImageZoom src="https://cdn.copilotkit.ai/docs/copilotkit/images/microsoft-agent-framework/read-agent-state.png" alt="read agent state" width={1000} height={1000} className="my-0"/>
</Frame>

<Callout type="info">
  Pictured above is the [agent starter](https://github.com/copilotkit/copilotkit/tree/main/examples/agents-starter) with
  the implementation section applied!
</Callout>

import { useAgent } from "@copilotkit/react-core/v2"; // [!code highlight]

// Define the agent state type, should match the actual state of your agent
type AgentState = {
  language: "english" | "spanish";
}

function YourMainContent() {
  // ...
  // [!code highlight:7]
  useAgent({
    agentId: "sample_agent",
    render: ({ state }) => {
      if (!state.language) return null;
      return <div>Language: {state.language}</div>;
    },
  });
  // ...
}