AgentInput

def my_basic_agent(input_data: galtea.AgentInput) -> galtea.AgentResponse:
    # Get the last user message content
    user_message = input_data.last_user_message_str()

    # Access session and context
    session_id = input_data.session_id
    context = input_data.context_data  # e.g. {"customer_tier": "premium"}

    return galtea.AgentResponse(content=f"Response to: {user_message}")

def my_structured_agent(input_data: AgentInput) -> AgentResponse:
    # Get the last user message as a ConversationMessage object
    last_msg = input_data.last_user_message()
    if last_msg is None:
        return AgentResponse(content="No user message received.")

    # The message content (the user_message field from structured input)
    user_message = last_msg.content  # e.g. "hello"

    # Structured fields from the test case are in the first user message's metadata
    first_user_msg = input_data.messages[0] if input_data.messages else None
    if first_user_msg and first_user_msg.metadata:
        chat_type = first_user_msg.metadata.get("chat_type")  # e.g. "support"
        priority = first_user_msg.metadata.get("priority")  # e.g. "high"
    else:
        chat_type = None
        priority = None

    # Use structured fields to customize behavior
    if chat_type == "support":
        response = f"Support response (priority={priority}): {user_message}"
    else:
        response = f"General response: {user_message}"

    return AgentResponse(content=response)

def my_context_agent(input_data: AgentInput) -> AgentResponse:
    user_message = input_data.last_user_message_str()

    # context_data comes from the test case's context field
    if input_data.context_data:
        customer_tier = input_data.context_data.get("customer_tier", "standard")
    else:
        customer_tier = "standard"

    return AgentResponse(content=f"[{customer_tier}] Response to: {user_message}")

def my_document_agent(input_data: AgentInput) -> AgentResponse:
    # Each InputFile has the same uri, filename and mime_type as test_case.input_files.
    document_paths = [
        galtea_client.storage.download(attached, output_directory="./.temp/agent-inputs")
        for attached in input_data.input_files
    ]

    # Empty string for a test case that carries only a document and no text.
    question = input_data.last_user_message_str() or ""

    return AgentResponse(content=f"Answer to {question!r} from {len(document_paths)} file(s)")

def my_multimodal_agent(input_data: AgentInput) -> AgentResponse:
    # read() keeps the bytes in memory, for a model that takes the document inline.
    parts = [
        {
            "type": "document",
            "media_type": attached.mime_type,
            "data": base64.b64encode(galtea_client.storage.read(attached)).decode(),
        }
        for attached in input_data.input_files
    ]

    question = input_data.last_user_message_str() or ""

    return AgentResponse(content=f"Answer to {question!r} from {len(parts)} inline document(s)")

def my_multi_turn_agent(input_data: AgentInput) -> AgentResponse:
    # Each user message carries its own files, so an earlier turn's document is still reachable.
    every_attachment = [
        attached for message in input_data.messages if message.role == "user" for attached in message.input_files
    ]
    # input_data.input_files is the shortcut for the current turn only.
    this_turn = input_data.input_files

    return AgentResponse(content=f"{len(this_turn)} file(s) on this turn, {len(every_attachment)} in the conversation")

# After running generate() or in a test loop, access the full structured input:
galtea_client = Galtea(api_key="YOUR_API_KEY")
test_case = galtea_client.test_cases.get(test_case_id=test_case_id)

# .input gives the user_message as a plain string
print(test_case.input)  # "hello"

# .input_data gives the full structured dict
print(test_case.input_data)  # {"user_message": "hello", "chat_type": "support"}

# Same pattern for traces (input side):
trace = galtea_client.traces.get(trace_id=trace_id)
print(trace.input)  # "hello"
print(trace.input_data)  # {"user_message": "hello", "chat_type": "support"}

# Output side — symmetric pair:
print(trace.actual_output)  # "the answer is 42" (plain string for text; transcript for voice)
print(trace.actual_output_data)  # None for plain text; {"assistant_message": "...", "content": [...]} for voice