1
<task>Write a PostgreSQL query to find all users who haven't logged in for 90 days</task>
2

3
<schema>The users table has columns: id (UUID), email (text), last_login (timestamp), created_at (timestamp)</schema>
4

5
<constraints>
6
- Use parameterized queries to prevent SQL injection
7
- Return only user_id and email
8
- Order by last_login ascending
9
</constraints>
10

11
<output_format>Return ONLY the SQL query. No explanation.</output_format>

1
<problem>
2
Debug why the payment service returns 503 errors after midnight UTC.
3
Relevant logs are in the MCP logging server.
4
</problem>
5

6
<thoughts>
7
1. Find the error pattern in logs
8
2. Identify the recurring job that runs at midnight
9
3. Check if the job conflicts with payment processing
10
4. Propose a fix
11
</thoughts>
12

13
<output>
14
Return your findings as:
15
<root_cause>one sentence</root_cause>
16
<evidence>relevant log lines</evidence>
17
<fix>concrete steps to implement</fix>
18
</output>

1
schema = {
2
    "type": "object",
3
    "properties": {
4
        "severity": {
5
            "type": "string",
6
            "enum": ["critical", "high", "medium", "low"],
7
            "description": "Impact severity"
8
        },
9
        "affected_services": {
10
            "type": "array",
11
            "items": {"type": "string"},
12
            "description": "List of affected service names"
13
        },
14
        "root_cause": {
15
            "type": "string",
16
            "description": "One-sentence root cause"
17
        },
18
        "action_items": {
19
            "type": "array",
20
            "items": {
21
                "type": "object",
22
                "properties": {
23
                    "priority": {"type": "number"},
24
                    "description": {"type": "string"},
25
                    "owner": {"type": "string"}
26
                }
27
            }
28
        }
29
    },
30
    "required": ["severity", "root_cause", "action_items"]
31
}
32

33
prompt = f"""Analyze this incident report and return a structured analysis.
34
You MUST return valid JSON matching this schema:
35
{json.dumps(schema, indent=2)}
36

37
Incident: {incident_text}"""

1
# OpenAI Agents SDK — native Pydantic
2
from pydantic import BaseModel
3
from agents import Agent
4

5
class IncidentReport(BaseModel):
6
    severity: str
7
    root_cause: str
8
    action_items: list[str]
9

10
agent = Agent(
11
    name="incident_analyzer",
12
    instructions="Analyze incidents and produce structured reports",
13
    output_type=IncidentReport  # Agent MUST output this shape
14
)
15

16
# Claude Agent SDK — content blocks
17
response = agent.generate(
18
    messages=[{"role": "user", "content": incident_text}],
19
    tools=[{
20
        "name": "submit_incident",
21
        "input_schema": {
22
            "type": "object",
23
            "properties": {
24
                "severity": {"type": "string"},
25
                "summary": {"type": "string"}
26
            },
27
            "required": ["severity", "summary"]
28
        }
29
    }],
30
    tool_choice={"type": "tool", "name": "submit_incident"}
31
)
32
# The agent outputs structured data through tool calls

1
from pydantic import BaseModel, Field
2
from typing import Literal
3

4
class CodeReview(BaseModel):
5
    file_path: str = Field(description="Path to the reviewed file")
6
    issues: list[dict] = Field(description="List of issues found")
7
    score: int = Field(ge=1, le=10, description="Code quality score 1-10")
8
    verdict: Literal["approve", "changes_requested", "blocked"]
9

10
prompt = f"""Review the following code changes and return a structured review.
11
Your output MUST conform to this schema:
12
{CodeReview.model_json_schema()}
13

14
The score must be between 1 and 10.
15
The verdict must be exactly one of: approve, changes_requested, blocked.
16
"""

1
import { z } from "zod";
2

3
const CodeReviewSchema = z.object({
4
  filePath: z.string(),
5
  issues: z.array(z.object({
6
    line: z.number(),
7
    severity: z.enum(["error", "warning", "suggestion"]),
8
    message: z.string(),
9
  })),
10
  score: z.number().min(1).max(10),
11
  verdict: z.enum(["approve", "changes_requested", "blocked"]),
12
});
13

14
const prompt = `
15
Review the following code and return a JSON object matching:
16
${JSON.stringify(CodeReviewSchema, null, 2)}
17

18
Parse the response with:
19
const result = CodeReviewSchema.parse(JSON.parse(response));
20
`;

1
prompt = """Solve this problem step by step, then output the answer in JSON.
2

3
Problem: A payment of $156.78 was made. The fee is 2.9% + $0.30.
4
What is the net amount received?
5

6
Think step by step:
7
1. Calculate the percentage fee: $156.78 × 0.029 = $4.55
8
2. Add the fixed fee: $4.55 + $0.30 = $4.85
9
3. Subtract from total: $156.78 - $4.85 = $151.93
10

11
Now output JSON:
12
{
13
    "gross_amount": 156.78,
14
    "percentage_fee": 4.55,
15
    "fixed_fee": 0.30,
16
    "total_fee": 4.85,
17
    "net_amount": 151.93
18
}
19
"""
20

21
# The model learns the pattern and applies it to the actual problem.

1
# Claude Agent SDK — extended thinking
2
agent = Agent(
3
    model="claude-sonnet-4",
4
    thinking_budget=16000,  # Tokens for reasoning
5
)
6

7
result = await agent.run_with_thinking(
8
    "Analyze this deployment failure and produce a structured incident report",
9
    stream_thinking=True  # See the reasoning before the structured output
10
)
11
# The thinking trace shows the chain-of-thought.
12
# The final output is structured JSON.

1
# Bad — JSON inside XML inside YAML
2
<output>
3
{
4
  items: [
5
    - name: "thing"  # Mixed JSON and YAML
6
  ]
7
}

1
# Bad — too many constraints
2
prompt = """Return JSON with fields:
3
- field1: string (max 10 chars)
4
- field2: number (0-100, must be integer)
5
- field3: array (min 1, max 5 items)
6
- field4: object with nested field4a (required), field4b (optional)
7
- field5: enum ["a", "b", "c"] but only when field2 > 50
8
... 20 more fields
9
"""

1
# Bad — assumes model always returns valid JSON
2
data = json.loads(response)  # Crashes if model adds commentary
3

4
# Good — resilient parsing
5
try:
6
    data = json.loads(response)
7
except json.JSONDecodeError:
8
    # Attempt to extract JSON from markdown code block
9
    import re
10
    match = re.search(r'```(?:json)?\n(.*?)\n```', response, re.DOTALL)
11
    if match:
12
        data = json.loads(match.group(1))
13
    else:
14
        data = {"error": "parse_failed", "raw": response}