Response Types

from lyzr import Studio

studio = Studio(api_key="your-api-key")
agent = studio.create_agent(
    name="Assistant",
    provider="gpt-4o"
)

# AgentResponse
response = agent.run("Hello!")
print(response.response)
print(response.session_id)

# AgentStream (streaming)
for chunk in agent.run("Tell a story", stream=True):
    print(chunk.content, end="")

class AgentResponse:
    response: str                           # The agent's text response
    session_id: str                         # Session identifier
    message_id: str | None                  # Unique message ID
    metadata: dict | None                   # Additional metadata
    tool_calls: List[dict] | None           # Tool calls made
    raw_response: dict | None               # Raw API response
    artifact_files: List[Artifact] | None   # Generated files

has_files() -> bool

if response.has_files():
    print(f"Generated {len(response.files)} file(s)")

files -> List[Artifact]

for artifact in response.files:
    print(f"{artifact.name}: {artifact.format_type}")

to_dict() -> dict

data = response.to_dict()
print(data["response"])

response = agent.run("Create a summary")

# Access response text
print(response.response)

# Check session
print(f"Session: {response.session_id}")

# Access metadata
if response.metadata:
    print(f"Tokens: {response.metadata.get('tokens')}")

# Check for files
if response.has_files():
    for artifact in response.files:
        artifact.download(f"./downloads/{artifact.name}")

class AgentStream:
    content: str                            # Accumulated content
    delta: str | None                       # New content in this chunk
    done: bool                              # Is this the final chunk?
    session_id: str | None                  # Session identifier
    metadata: dict | None                   # Chunk metadata
    chunk_index: int | None                 # Chunk number
    structured_data: BaseModel | None       # Parsed response (final chunk)
    artifact_files: List[Artifact] | None   # Generated files (final chunk)

has_files() -> bool

files -> List[Artifact]

to_dict() -> dict

# Basic streaming
for chunk in agent.run("Tell me a story", stream=True):
    # Print new content
    if chunk.delta:
        print(chunk.delta, end="", flush=True)

    # Handle final chunk
    if chunk.done:
        print(f"\n\nSession: {chunk.session_id}")

        # Check for structured data
        if chunk.structured_data:
            result = chunk.structured_data
            print(f"Parsed: {result}")

        # Check for files
        if chunk.has_files():
            for artifact in chunk.files:
                print(f"Generated: {artifact.name}")

import sys

total_chars = 0

for chunk in agent.run("Generate a report", stream=True):
    if chunk.delta:
        sys.stdout.write(chunk.delta)
        sys.stdout.flush()
        total_chars += len(chunk.delta)

    if chunk.done:
        print(f"\n\nTotal characters: {total_chars}")

class Artifact:
    name: str               # File name
    url: str                # Download URL
    format_type: str        # File format (pdf, docx, png, etc.)
    artifact_id: str | None # Unique artifact ID

download(save_path: str) -> None

artifact.download("./reports/sales_report.pdf")

# Enable file output
agent = studio.create_agent(
    name="Report Generator",
    provider="gpt-4o",
    file_output=True
)

response = agent.run("Create a PDF report about Q1 sales")

# Download generated files
if response.has_files():
    for artifact in response.files:
        print(f"File: {artifact.name}")
        print(f"Format: {artifact.format_type}")
        print(f"URL: {artifact.url}")

        # Download to local file
        artifact.download(f"./downloads/{artifact.name}")
        print(f"Downloaded to ./downloads/{artifact.name}")

class TaskResponse:
    task_id: str            # Unique task identifier
    status: str             # Task status (pending, running, completed, failed)
    session_id: str | None  # Associated session ID
    created_at: str | None  # Creation timestamp

class TaskStatus:
    task_id: str                    # Task identifier
    status: str                     # Status (pending, running, completed, failed)
    result: AgentResponse | None    # Result if completed
    error: str | None               # Error message if failed
    progress: float | None          # Progress percentage (0-100)
    metadata: dict | None           # Task metadata

is_complete() -> bool

is_successful() -> bool

from pydantic import BaseModel

class Analysis(BaseModel):
    sentiment: str
    confidence: float
    keywords: list[str]

agent = studio.create_agent(
    name="Analyzer",
    provider="gpt-4o",
    response_model=Analysis
)

# Returns Analysis, not AgentResponse
result: Analysis = agent.run("Analyze this text")
print(result.sentiment)
print(result.confidence)

for chunk in agent.run("Analyze this", stream=True):
    print(chunk.content, end="")

    if chunk.done and chunk.structured_data:
        result: Analysis = chunk.structured_data
        print(f"\nSentiment: {result.sentiment}")

import os

response = agent.run("Generate reports")

if response.has_files():
    os.makedirs("./output", exist_ok=True)

    for artifact in response.files:
        path = f"./output/{artifact.name}"
        artifact.download(path)
        print(f"Saved: {path}")

with open("output.txt", "w") as f:
    for chunk in agent.run("Write an article", stream=True):
        if chunk.delta:
            f.write(chunk.delta)

def process_response(response):
    """Handle any response type"""

    if isinstance(response, AgentResponse):
        print(f"Text: {response.response}")

    elif isinstance(response, BaseModel):
        # Structured response
        print(f"Structured: {response}")

    # Check for files in either case
    if hasattr(response, 'has_files') and response.has_files():
        for artifact in response.files:
            artifact.download(f"./downloads/{artifact.name}")