AI / Core OpenAI Codex Application Fundamentals Interview Questions

# Responses API - Python
from openai import OpenAI
client = OpenAI()

result = client.responses.create(
    model="gpt-5.5",
    input="Find the null pointer exception: ...your code here...",
    reasoning={"effort": "high"},
)
print(result.output_text)

# Chaining turns with previous_response_id:
followup = client.responses.create(
    model="gpt-5.5",
    input="Now fix it.",
    previous_response_id=result.id,
)

# Using web_search in the Responses API:
from openai import OpenAI
client = OpenAI()

response = client.responses.create(
    model="gpt-5.5",
    tools=[{"type": "web_search_preview"}],
    input="What are the latest changes to Python's asyncio in 3.12?",
)
print(response.output_text)

# Using multiple tools together:
response = client.responses.create(
    model="gpt-5.5",
    tools=[
        {"type": "web_search_preview"},
        {"type": "file_search", "vector_store_ids": ["vs_abc123"]}
    ],
    input="Summarise our internal Q3 report and compare it with industry trends.",
)

from agents import Agent, Runner

# Define an agent
coding_agent = Agent(
    name="CodingAgent",
    instructions="You are an expert Python developer. Write clean, tested code.",
    tools=[web_search_tool, code_interpreter_tool],
    model="gpt-5.5",
)

# Run the agent
import asyncio
result = asyncio.run(Runner.run(
    coding_agent,
    "Write a Python function that parses JWT tokens and validates expiry.",
))
print(result.final_output)

# Installation
npm install -g @openai/codex

# Basic usage - interactive session
codex

# Run with a specific model
codex --model gpt-5.5

# Execute a single task non-interactively
codex exec "Add comprehensive docstrings to all public functions in src/"

# Exec with specific model
codex exec --model gpt-5.4-mini "Fix all linting errors in utils.py"

# Change model during an active thread:
# /model gpt-5.5

# Specify model in config.toml:
# [codex]
# model = "gpt-5.5"

from openai import OpenAI
client = OpenAI()

# Classic Chat Completions call
response = client.chat.completions.create(
    model="gpt-5.5",
    messages=[
        {"role": "system", "content": "You are an expert Python developer."},
        {"role": "user", "content": "Explain asyncio.gather() with an example."},
    ],
    temperature=0.2,
    max_tokens=1024,
)
print(response.choices[0].message.content)

# Chat Completions - function calling
from openai import OpenAI
import json

client = OpenAI()

# 1. Define functions as tools
tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get current weather for a city",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {"type": "string", "description": "City name"},
                "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
            },
            "required": ["city"]
        }
    }
}]

# 2. First call - model decides to call a function
response = client.chat.completions.create(
    model="gpt-5.5",
    messages=[{"role": "user", "content": "What's the weather in Tokyo?"}],
    tools=tools,
    tool_choice="auto",  # "auto" | "required" | {"type":"function","function":{"name":"..."}}
)

# 3. Extract the function call
message = response.choices[0].message
tool_call = message.tool_calls[0]
function_args = json.loads(tool_call.function.arguments)

# 4. Execute your function
weather_result = get_weather(**function_args)  # your actual implementation

# 5. Second call - send function result back
response2 = client.chat.completions.create(
    model="gpt-5.5",
    messages=[
        {"role": "user", "content": "What's the weather in Tokyo?"},
        message,  # assistant turn with tool_calls
        {"role": "tool", "content": json.dumps(weather_result), "tool_call_id": tool_call.id}
    ],
    tools=tools,
)

from openai import OpenAI
from pydantic import BaseModel

client = OpenAI()

# Method 1: Pydantic model (Python SDK - simplest approach)
class CodeReview(BaseModel):
    issues: list[str]
    severity: str  # "low" | "medium" | "high"
    suggested_fix: str
    confidence_score: float

# Responses API with structured output
response = client.responses.create(
    model="gpt-5.5",
    input="Review this Python function for bugs: def add(a, b): return a - b",
    text={
        "format": {
            "type": "json_schema",
            "json_schema": {
                "name": "code_review",
                "schema": CodeReview.model_json_schema(),
                "strict": True
            }
        }
    }
)
review = CodeReview.model_validate_json(response.output_text)
print(f"Severity: {review.severity}")
print(f"Issues: {review.issues}")

# Chat Completions with parse() helper (beta):
completion = client.beta.chat.completions.parse(
    model="gpt-5.5",
    messages=[{"role": "user", "content": "Extract: Alice is 30, is an engineer."}],
    response_format=CodeReview,
)
result = completion.choices[0].message.parsed

# The cache works automatically - no special API call needed.
# Maximise cache hits by:
# 1. Keeping system prompts identical across calls
# 2. Placing stable content (instructions, tool definitions) at the START
# 3. Placing variable content (user query, session data) at the END

# Example: maximise caching for a code review assistant
response = client.responses.create(
    model="gpt-5.5",
    instructions="""You are an expert Python code reviewer.
    Follow PEP 8, identify security issues, and suggest improvements.
    [... 2000 token system prompt stays identical across all calls ...]
    """,  # This large stable prefix gets cached after first call
    input=f"Review this PR: {variable_code_diff}",  # This varies per call
)

# codex-mini-latest: 75% prompt caching discount
# $1.50/1M -> $0.375/1M on cache hits

from openai import OpenAI
client = OpenAI()

# Responses API with reasoning effort
result = client.responses.create(
    model="gpt-5.5",
    input="Design a thread-safe cache with LRU eviction in Python.",
    reasoning={"effort": "high"},   # "low" | "medium" | "high"
)
print(result.output_text)

# "low"  - faster, cheaper; suitable for simple code Q&A
# "medium" - balanced; good default for most coding tasks
# "high" - maximum reasoning; for complex architecture, hard bugs

# Encrypted reasoning (reasoning without exposing thinking tokens):
result = client.responses.create(
    model="gpt-5.5",
    input="Find all race conditions in this concurrent code: ...",
    reasoning={"effort": "high", "summary": "auto"},  # get reasoning summary
)

import os
from openai import OpenAI

# 1. NEVER hardcode API keys - use environment variables
client = OpenAI(
    api_key=os.environ.get("OPENAI_API_KEY"),   # required
    organization=os.environ.get("OPENAI_ORG_ID"),  # optional
    project=os.environ.get("OPENAI_PROJECT_ID"),   # optional
)

# 2. Project API keys (recommended over user keys)
# Create per-project keys at: platform.openai.com/api-keys
# Scoped to a specific project - limits blast radius on leak

# 3. Organisation structure for teams:
# Organisation > Projects > API keys (per project)
# Rate limits and costs tracked per project

# 4. Service accounts (enterprise)
# Use service account keys for production, not personal user keys

# 5. IP allowlists (available in API settings)
# Restrict which IPs can use an API key

# 6. Codex CLI authentication options:
# a) API key: OPENAI_API_KEY env var
# b) ChatGPT sign-in: codex auth  (auto-generates key for ChatGPT subscribers)

import time
import openai
from openai import OpenAI

client = OpenAI()

# 1. Exponential backoff with jitter - handle 429 errors gracefully
def call_with_retry(prompt: str, max_retries: int = 5):
    for attempt in range(max_retries):
        try:
            return client.responses.create(
                model="gpt-5.5",
                input=prompt,
            )
        except openai.RateLimitError as e:
            if attempt == max_retries - 1:
                raise
            wait = (2 ** attempt) + (0.1 * attempt)  # exponential + jitter
            print(f"Rate limited. Waiting {wait:.1f}s...")
            time.sleep(wait)

# 2. The Python SDK retries automatically by default
# Configure retry behaviour:
client = OpenAI(
    max_retries=3,       # default is 2
    timeout=60.0,        # request timeout in seconds
)

# 3. Use the Batch API for large non-time-sensitive workloads
# Batch processing: ~50% cost reduction, no rate limit impact
response = client.batches.create(
    input_file_id="file-abc123",
    endpoint="/v1/responses",
    completion_window="24h",
)

from openai import OpenAI
import jsonlines

client = OpenAI()

# 1. Create a JSONL file with requests
batch_requests = [
    {
        "custom_id": "review-001",
        "method": "POST",
        "url": "/v1/responses",
        "body": {
            "model": "gpt-5.5",
            "input": "Review: def fib(n): return fib(n-1) + fib(n-2)",
            "max_output_tokens": 500,
        }
    },
    # ... thousands more requests
]

# Write JSONL
with open("batch_input.jsonl", "w") as f:
    for req in batch_requests:
        f.write(json.dumps(req) + "\n")

# 2. Upload the file
batch_file = client.files.create(
    file=open("batch_input.jsonl", "rb"),
    purpose="batch"
)

# 3. Create the batch
batch = client.batches.create(
    input_file_id=batch_file.id,
    endpoint="/v1/responses",
    completion_window="24h",
)
print(f"Batch ID: {batch.id}")

# 4. Poll for completion (or use webhooks)
batch_status = client.batches.retrieve(batch.id)
if batch_status.status == "completed":
    results = client.files.content(batch_status.output_file_id)
    # Parse JSONL results

from openai import OpenAI

client = OpenAI()

# Chat Completions streaming
with client.chat.completions.stream(
    model="gpt-5.5",
    messages=[{"role": "user", "content": "Write a Python web scraper."}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)
    # Access final complete response:
    final = stream.get_final_completion()

# Responses API streaming
with client.responses.stream(
    model="gpt-5.5",
    input="Explain async/await in Python with examples.",
) as stream:
    for event in stream:
        # Events: response.created, response.in_progress,
        # response.output_item.added, response.content_part.delta,
        # response.completed, etc.
        if event.type == "response.output_text.delta":
            print(event.delta, end="", flush=True)
    final_response = stream.get_final_response()

# Async streaming for FastAPI/async applications:
async def stream_response():
    async with client.responses.stream(
        model="gpt-5.5",
        input="Review this code: ...",
    ) as stream:
        async for text in stream.text_stream:
            yield text  # SSE to browser

# Automations can be configured to:
# - Monitor GitHub issue queues and triage new issues
# - Watch CI/CD pipelines and fix recurring failures
# - Respond to monitoring alerts and attempt automated remediation
# - Run scheduled code quality reviews

# Skills examples:
# - "Our team uses pytest with the Arrange-Act-Assert pattern"
# - "All new API endpoints need OpenAPI docstrings following our schema"
# - "Refactoring should preserve backward compatibility per our versioning policy"

# These are configured in the Codex App UI, not via the API directly

# Using a remote MCP server in the Responses API:
response = client.responses.create(
    model="gpt-5.5",
    tools=[
        {
            "type": "mcp",
            "server_url": "https://mcp.example.com/tools",
            "server_label": "my-internal-tools",
            "require_approval": "never",  # auto-approve tool calls
        }
    ],
    input="Query the production database for user count by region.",
)

# Secure MCP Tunnel (enterprise - for private servers):
# 1. Deploy tunnel-client on your internal network
# 2. Register tunnel in OpenAI platform
# 3. Reference as a remote MCP without exposing server publicly

# In Codex CLI during an active session:
# /mcp  - shows available MCP servers
# /mcp connect https://my-mcp-server.example.com/sse

from openai import OpenAI
client = OpenAI()

# 1. Prepare training data (JSONL format)
# Each line: {"messages": [{"role": "system", "content": "..."}, ...]}
# Save as training.jsonl

# 2. Upload training file
training_file = client.files.create(
    file=open("training.jsonl", "rb"),
    purpose="fine-tune"
)

# 3. Create fine-tuning job
job = client.fine_tuning.jobs.create(
    training_file=training_file.id,
    model="gpt-4.1-mini-2025-04-14",   # supported base models
    # model="gpt-4.1-2025-04-14",
    hyperparameters={
        "n_epochs": 3,
    }
)

# 4. Monitor job
job_status = client.fine_tuning.jobs.retrieve(job.id)
print(f"Status: {job_status.status}")

# 5. Use fine-tuned model
response = client.chat.completions.create(
    model=job_status.fine_tuned_model,  # e.g. ft:gpt-4.1-mini:my-org::abc123
    messages=[{"role": "user", "content": "..."}],
)

from openai import OpenAI
import numpy as np

client = OpenAI()

# Generate embeddings
response = client.embeddings.create(
    model="text-embedding-3-large",    # 3072 dimensions
    # model="text-embedding-3-small",  # 1536 dimensions, cheaper
    input=[
        "OpenAI Codex is an agentic coding assistant.",
        "GitHub Copilot helps developers write code.",
        "The stock market rose 2% today.",
    ]
)

# Extract vectors
vectors = [item.embedding for item in response.data]

# Semantic similarity via cosine similarity
def cosine_similarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

sim_coding = cosine_similarity(vectors[0], vectors[1])  # high - both about coding AI
sim_unrelated = cosine_similarity(vectors[0], vectors[2])  # low - different topic
print(f"Coding similarity: {sim_coding:.3f}")    # e.g. 0.89
print(f"Unrelated similarity: {sim_unrelated:.3f}")  # e.g. 0.21

# Dimension reduction (for storage/speed tradeoff):
response = client.embeddings.create(
    model="text-embedding-3-large",
    input="example text",
    dimensions=512,  # reduce from 3072 to 512
)

from openai import OpenAI
client = OpenAI()

# Standalone moderation check
response = client.moderations.create(
    model="omni-moderation-latest",
    input="I want to hurt someone.",
)

result = response.results[0]
if result.flagged:
    print("Content flagged!")
    for category, flagged in result.categories.__dict__.items():
        if flagged:
            print(f"  - {category}: score {getattr(result.category_scores, category):.3f}")

# Image moderation (omni-moderation-latest supports images):
response = client.moderations.create(
    model="omni-moderation-latest",
    input=[
        {"type": "text", "text": "Check this text"},
        {"type": "image_url", "image_url": {"url": "https://example.com/image.jpg"}}
    ]
)

# Inline moderation with Responses API (2026 feature):
response = client.responses.create(
    model="gpt-5.5",
    input="User message here",
    moderation={},    # get moderation scores inline with the response
)

from openai import OpenAI
import base64

client = OpenAI()

# Generate an image (gpt-image-2)
response = client.images.generate(
    model="gpt-image-2",
    prompt="A Python snake debugging code on a computer, photorealistic",
    size="1024x1024",
    quality="high",
    n=1,
    response_format="b64_json",   # or "url"
)
image_data = base64.b64decode(response.data[0].b64_json)

# Image editing (inpainting)
response = client.images.edit(
    model="gpt-image-2",
    image=open("original.png", "rb"),
    mask=open("mask.png", "rb"),   # transparent area = area to edit
    prompt="Replace the background with a futuristic city skyline",
)

# Via Responses API (gpt-image-1 as a tool):
response = client.responses.create(
    model="gpt-5.5",
    input="Create a diagram of a microservices architecture.",
    tools=[{"type": "image_generation"}],
)

import asyncio
import websockets
import json

# Realtime API uses WebSocket connection:
async def realtime_session():
    url = "wss://api.openai.com/v1/realtime?model=gpt-realtime-2"
    headers = {
        "Authorization": f"Bearer {OPENAI_API_KEY}",
        "OpenAI-Beta": "realtime=v1"
    }
    async with websockets.connect(url, extra_headers=headers) as ws:
        # Configure session
        await ws.send(json.dumps({
            "type": "session.update",
            "session": {
                "modalities": ["text", "audio"],
                "voice": "alloy",
                "instructions": "You are a helpful coding assistant.",
                "input_audio_format": "pcm16",
                "output_audio_format": "pcm16",
            }
        }))
        # Stream audio input
        await ws.send(json.dumps({
            "type": "input_audio_buffer.append",
            "audio": base64_pcm16_audio_chunk,
        }))
        # Commit and request response
        await ws.send(json.dumps({"type": "input_audio_buffer.commit"}))
        await ws.send(json.dumps({"type": "response.create"}))

from openai import OpenAI

client = OpenAI()

# ---- FULL RAG PIPELINE ----

# Step 1: Embed and index your documents (do this once)
def embed_documents(texts: list[str]) -> list[list[float]]:
    response = client.embeddings.create(
        model="text-embedding-3-large",
        input=texts,
    )
    return [item.embedding for item in response.data]

docs = [
    "Our refund policy: returns accepted within 30 days with receipt.",
    "API rate limits: 3500 RPM for Tier 2 customers.",
    "Python 3.12 introduced GIL opt-out via Py_GIL_DISABLED=1.",
]
doc_embeddings = embed_documents(docs)
# Store doc_embeddings + docs in a vector database (Pinecone, Weaviate, pgvector...)

# Step 2: At query time, retrieve relevant chunks
user_query = "Can I return a product after 2 months?"
query_embedding = embed_documents([user_query])[0]
# similarity_search(query_embedding) -> returns top-k relevant docs
relevant_docs = ["Our refund policy: returns accepted within 30 days with receipt."]

# Step 3: Generate with context
response = client.responses.create(
    model="gpt-5.5",
    instructions="Answer based only on the provided context. If unsure, say so.",
    input=f"Context:\n{chr(10).join(relevant_docs)}\n\nQuestion: {user_query}",
)
print(response.output_text)
# "Based on our policy, returns are only accepted within 30 days with a receipt,
# so a return after 2 months would not be eligible."

import tiktoken

# Count tokens before sending (avoid surprises)
encoding = tiktoken.encoding_for_model("gpt-5.5")

def count_tokens(text: str, model: str = "gpt-5.5") -> int:
    enc = tiktoken.encoding_for_model(model)
    return len(enc.encode(text))

# Count tokens for a Chat Completions messages array:
def count_message_tokens(messages: list, model: str = "gpt-5.5") -> int:
    enc = tiktoken.encoding_for_model(model)
    total = 3  # reply overhead
    for msg in messages:
        total += 4  # per-message overhead
        for key, value in msg.items():
            total += len(enc.encode(str(value)))
    return total

# Example:
tokens = count_tokens("Write a Python function that sorts a list using quicksort.")
print(f"Prompt tokens: {tokens}")  # ~15 tokens

# Via API (most accurate, no tiktoken required):
response = client.responses.create(
    model="gpt-5.5",
    input="Explain recursion.",
)
print(f"Input tokens: {response.usage.input_tokens}")
print(f"Output tokens: {response.usage.output_tokens}")
print(f"Total: {response.usage.total_tokens}")

from agents import Agent, Runner, GuardrailFunctionOutput, InputGuardrail
from pydantic import BaseModel

# Define a guardrail that validates math homework requests
class HomeworkCheck(BaseModel):
    is_homework_question: bool
    reasoning: str

guardrail_agent = Agent(
    name="HomeworkGuardrail",
    instructions="Check if the user is asking for homework help.",
    output_type=HomeworkCheck,
)

async def homework_guardrail(ctx, agent, input):
    result = await Runner.run(guardrail_agent, input, context=ctx.context)
    if result.final_output.is_homework_question:
        raise GuardrailFunctionOutput(
            output_info=result.final_output,
            tripwire_triggered=True,  # block the request
        )
    return GuardrailFunctionOutput(output_info=result.final_output)

# Attach guardrail to the main agent:
main_agent = Agent(
    name="TutorAgent",
    instructions="Help students learn programming concepts.",
    input_guardrails=[InputGuardrail(guardrail_function=homework_guardrail)],
)

# For irreversible agent actions - require human approval:
def confirm_database_write(action_description: str) -> bool:
    print(f"Agent wants to: {action_description}")
    return input("Approve? (y/n): ").lower() == "y"

from openai import OpenAI
client = OpenAI()

# 1. Upload a file
with open("technical-docs.pdf", "rb") as f:
    uploaded = client.files.create(
        file=f,
        purpose="assistants"  # or "fine-tune", "batch", "vision"
    )
file_id = uploaded.id  # e.g. "file-abc123"
print(f"Uploaded: {file_id}, size: {uploaded.bytes} bytes")

# 2. List files
files = client.files.list(purpose="assistants")
for f in files.data:
    print(f.id, f.filename, f.created_at)

# 3. Use file in a Vector Store for file_search:
vector_store = client.vector_stores.create(name="TechDocs")
client.vector_stores.files.create(
    vector_store_id=vector_store.id,
    file_id=file_id
)

# 4. Use vector store with file_search tool:
response = client.responses.create(
    model="gpt-5.5",
    tools=[{
        "type": "file_search",
        "vector_store_ids": [vector_store.id]
    }],
    input="What is the maximum API request size?"
)
print(response.output_text)

# 5. Delete file when done:
client.files.delete(file_id)

from agents import Agent, Runner, handoff
import asyncio

# Define specialised agents:
code_agent = Agent(
    name="CodeWriter",
    instructions="Write clean, well-documented Python code. Focus on correctness.",
    model="gpt-5.5",
)

review_agent = Agent(
    name="CodeReviewer",
    instructions="Review code for bugs, security issues, and performance problems.",
    model="gpt-5.5",
)

doc_agent = Agent(
    name="DocWriter",
    instructions="Write clear docstrings and README documentation.",
    model="gpt-5.4-mini",  # cheaper model for docs
)

# Orchestrator agent with handoffs:
orchestrator = Agent(
    name="Orchestrator",
    instructions="""Manage the coding workflow:
    1. Use CodeWriter to implement features
    2. Use CodeReviewer to review and fix issues
    3. Use DocWriter to document the final code
    """,
    handoffs=[
        handoff(code_agent),
        handoff(review_agent),
        handoff(doc_agent),
    ],
    model="gpt-5.5",
)

async def run_pipeline(task: str):
    result = await Runner.run(
        orchestrator,
        task,
        max_turns=20,  # prevent infinite loops
    )
    return result.final_output

# Run:
output = asyncio.run(run_pipeline(
    "Implement a thread-safe LRU cache class with comprehensive tests"
))
print(output)

from openai import OpenAI
client = OpenAI()

# Using the Evals API:
# 1. Create a dataset for evaluation:
dataset = client.evals.datasets.create(
    name="code-review-eval",
    items=[
        {"input": "Review: def add(a,b): return a-b", "expected": "Bug: subtraction used instead of addition"},
        {"input": "Review: import os; os.system(user_input)", "expected": "Security: OS injection vulnerability"},
    ]
)

# 2. Create and run an eval:
eval_run = client.evals.runs.create(
    name="code-reviewer-v2-test",
    model="gpt-5.5",
    data_source={"type": "dataset", "id": dataset.id},
    grader_config={
        "type": "llm_as_judge",
        "model": "gpt-5.4-mini",  # fast/cheap grader
        "criteria": "Does the review correctly identify all bugs and security issues?"
    }
)
print(f"Score: {eval_run.result.score}")

# Open-source evals (run locally):
# pip install evals
# oaieval gpt-5.5 my-code-review-eval
# Compare two models:
# oaieval gpt-5.5 my-eval
# oaieval gpt-5.4 my-eval

import openai
from openai import OpenAI
import time

client = OpenAI()

def robust_api_call(prompt: str) -> str:
    """Production-ready API call with comprehensive error handling."""
    try:
        response = client.responses.create(
            model="gpt-5.5",
            input=prompt,
            timeout=30.0,
        )
        return response.output_text

    except openai.AuthenticationError as e:
        # 401 - Invalid API key
        raise ValueError("Invalid API key. Check OPENAI_API_KEY.") from e

    except openai.PermissionDeniedError as e:
        # 403 - Access denied to model or feature
        raise PermissionError(f"Permission denied: {e.message}") from e

    except openai.RateLimitError as e:
        # 429 - Rate limited: implement exponential backoff
        for attempt in range(5):
            wait = (2 ** attempt) + 0.1
            time.sleep(wait)
            try:
                return client.responses.create(model="gpt-5.5", input=prompt).output_text
            except openai.RateLimitError:
                continue
        raise

    except openai.BadRequestError as e:
        # 400 - Invalid request (bad parameters, context overflow)
        if "context_length_exceeded" in str(e):
            raise ValueError("Prompt too long - reduce input size.") from e
        raise

    except openai.InternalServerError as e:
        # 500 - OpenAI server error: retry with backoff
        time.sleep(5)
        return client.responses.create(model="gpt-5.5", input=prompt).output_text

    except openai.APIConnectionError as e:
        # Network error: check connectivity
        raise ConnectionError("Network error connecting to OpenAI API.") from e

    except openai.APITimeoutError as e:
        # Request timed out
        raise TimeoutError("API request timed out.") from e

# Interacting with Codex programmatically (Responses API):
from openai import OpenAI
client = OpenAI()

# Create a software engineering task via API:
response = client.responses.create(
    model="gpt-5.3-codex",   # or gpt-5.5 for API use
    instructions="""You are a senior Python engineer.
    Follow the team conventions in CONTRIBUTING.md.
    Write tests before implementation (TDD).
    Use type hints throughout.
    """,
    input="Add rate limiting middleware to our FastAPI app. Limit to 100 req/min per IP.",
    tools=[
        {"type": "code_interpreter"},   # execute and test code
        {"type": "file_search", "vector_store_ids": ["vs_codebase123"]},
    ],
    reasoning={"effort": "high"},
)

# Legacy o-series (still supported but not recommended for new projects):
response = client.chat.completions.create(
    model="o4-mini",
    messages=[{"role": "user", "content": "Find all bugs in this code: ..."}],
    reasoning_effort="medium",
)

# Modern GPT-5.x with integrated reasoning (recommended):
response = client.responses.create(
    model="gpt-5.5",
    input="Find all bugs in this code: ...",
    reasoning={"effort": "high"},   # same concept, unified API
)

# gpt-5.3-codex: reasoning + coding fused in one model
# No separate "thinking phase" - adapts dynamically
response = client.responses.create(
    model="gpt-5.3-codex",
    input="Architect a microservices system for a real-time trading platform.",
    reasoning={"effort": "high"},
)

# Example .codex/config.toml (shared with CLI):
[codex]
model = "gpt-5.5"
approval_mode = "auto"    # auto, manual, or strict

[context]
max_file_tokens = 50000   # limit context per file
exclude_patterns = [      # files to exclude from context
    "node_modules/**",
    "*.lock",
    "dist/**",
]

[coding]
preferred_language = "python"
style_guide = "pep8"
test_framework = "pytest"

# Keyboard shortcuts (VS Code):
# Ctrl+Shift+A  - Open Codex chat panel
# Ctrl+Shift+G  - Generate code for selection
# Ctrl+Shift+E  - Explain selection
# Ctrl+Shift+T  - Generate tests for selection

# Production patterns:

# 1. Never use -latest model aliases in production
# BAD:
client.responses.create(model="gpt-5-latest", ...)  # behaviour changes without notice
# GOOD:
client.responses.create(model="gpt-5.5", ...)  # stable, predictable

# 2. Set both usage limits AND per-request caps:
client.responses.create(
    model="gpt-5.5",
    input=user_message,
    max_output_tokens=2048,   # prevent runaway outputs
    timeout=30.0,             # prevent hanging requests
)

# 3. Log everything for debugging:
import logging
logger = logging.getLogger("openai-app")

response = client.responses.create(model="gpt-5.5", input=prompt)
logger.info({
    "model": "gpt-5.5",
    "input_tokens": response.usage.input_tokens,
    "output_tokens": response.usage.output_tokens,
    "response_id": response.id,
})

# Cost estimation example:

# Scenario: Code review agent processes 100 PRs/day
# Average PR: 2000 input tokens + 500 output tokens = 2500 tokens

daily_prs = 100
avg_input_tokens = 2000
avg_output_tokens = 500

# Using gpt-5.5 at standard pricing:
input_cost_per_million = 5.00
output_cost_per_million = 20.00

daily_input_cost = (daily_prs * avg_input_tokens / 1_000_000) * input_cost_per_million
daily_output_cost = (daily_prs * avg_output_tokens / 1_000_000) * output_cost_per_million
daily_total = daily_input_cost + daily_output_cost
monthly_total = daily_total * 30

print(f"Daily cost: ${daily_total:.2f}")
print(f"Monthly cost: ${monthly_total:.2f}")

# With Batch API (50% discount):
batch_monthly = monthly_total * 0.5
print(f"Monthly cost (Batch API): ${batch_monthly:.2f}")

# With prompt caching (40% cache hit rate, 75% discount on cached):
# Effective input cost reduction ~30%
# + Batch API = significant overall saving

# Computer use via the Responses API:
response = client.responses.create(
    model="gpt-5.4",    # gpt-5.4 has strong computer use support
    tools=[{
        "type": "computer_use_preview",
        "display_width": 1280,
        "display_height": 800,
        "environment": "browser",   # or "desktop", "linux", "windows"
    }],
    input="Go to github.com/openai/codex, find all open issues labelled bug, and return a summary.",
    truncation="auto",
)

# In Codex CLI - computer use is built into the tool automatically:
# codex
# > Open the browser and check if our staging deployment is up at staging.example.com
# Codex will: open browser, navigate to URL, read the page, report status

# Safety considerations:
# 1. Sandbox environments recommended
# 2. Require approval for form submissions, purchases, account changes
# 3. Log all actions taken by the computer use agent

from openai import OpenAI
client = OpenAI()

# 1. Code generation with constraints:
generated = client.responses.create(
    model="gpt-5.5",
    instructions="""You are a senior Python engineer. Always:
    - Add type hints
    - Write docstrings (Google style)
    - Include basic error handling
    - Add a usage example in if __name__ == "__main__"
    """,
    input="Write a function to parse a CSV file and return a list of dicts.",
    reasoning={"effort": "medium"},
)

# 2. Code review with structured output:
from pydantic import BaseModel
class Review(BaseModel):
    summary: str
    bugs: list[str]
    security_issues: list[str]
    performance_issues: list[str]
    suggested_improvements: list[str]
    severity: str  # "clean" | "low" | "medium" | "high" | "critical"

review = client.responses.create(
    model="gpt-5.5",
    input=f"Review this code:\n\n```python\n{code_to_review}\n```",
    text={"format": {"type": "json_schema",
                     "json_schema": {"name": "review", "schema": Review.model_json_schema(), "strict": True}}},
)
result = Review.model_validate_json(review.output_text)

# 3. Debugging:
debug_response = client.responses.create(
    model="gpt-5.5",
    input=f"""Debug this code. I get this error:\n\n{error_traceback}\n\nCode:\n{code}\n\nExplain the root cause and provide a fix.""",
    reasoning={"effort": "high"},
)

# 4. Unit test generation:
tests = client.responses.create(
    model="gpt-5.5",
    instructions="Generate comprehensive pytest tests. Include edge cases, error cases, and typical usage.",
    input=f"Generate tests for:\n\n{function_code}",
    tools=[{"type": "code_interpreter"}],  # run tests to verify they pass
)

# Chat Completions system prompt:
response = client.chat.completions.create(
    model="gpt-5.5",
    messages=[
        {
            "role": "system",
            "content": "You are an expert Python engineer...",  # system message
        },
        {"role": "user", "content": "Write a web scraper."},
    ]
)

# Responses API instructions:
response = client.responses.create(
    model="gpt-5.5",
    instructions="You are an expert Python engineer...",  # top-level parameter
    input="Write a web scraper.",
)

# Effective system prompt patterns:
EFFECTIVE_SYSTEM_PROMPT = """
Role: You are an expert Python engineer at a fintech startup.

Constraints:
- Always use type hints and write Google-style docstrings
- Prefer standard library over third-party when possible
- Financial calculations must use Decimal, never float
- Every function must have at least 2 unit tests

Output format:
- First, explain your approach in 2-3 sentences
- Then provide the complete implementation
- Finally, provide usage examples

Do not:
- Generate code you cannot verify is correct
- Suggest experimental or deprecated libraries
- Skip error handling for edge cases
"""

from openai import OpenAI
import tiktoken

client = OpenAI()
enc = tiktoken.encoding_for_model("gpt-5.5")

# Context window strategy 1: Sliding window
# Keep the most recent N turns, discarding the oldest
def sliding_window(messages: list, max_tokens: int = 100_000) -> list:
    total = sum(len(enc.encode(str(m["content"]))) for m in messages)
    while total > max_tokens and len(messages) > 2:
        # Remove oldest user+assistant pair (keep system message)
        removed = messages.pop(1)
        total -= len(enc.encode(str(removed["content"])))
    return messages

# Context window strategy 2: Summarisation
# Summarise old conversation instead of dropping it entirely
async def summarise_history(messages: list[dict]) -> str:
    summary = await client.responses.create(
        model="gpt-5.4-mini",  # cheap model for summarisation
        input=f"Summarise this conversation concisely:\n{messages}",
    )
    return summary.output_text

# Strategy 3: Responses API state management (avoids manual history)
# Use previous_response_id - OpenAI manages the context server-side
first = client.responses.create(model="gpt-5.5", input="Hello!", store=True)
second = client.responses.create(
    model="gpt-5.5",
    input="What did I just say?",
    previous_response_id=first.id,  # server retrieves context automatically
)

# Strategy 4: use file_search for large static documents
# Instead of pasting 100k-token documents into every prompt:
# Upload once to a vector store, retrieve only relevant chunks
vector_store_id = "vs_abc123"
response = client.responses.create(
    model="gpt-5.5",
    tools=[{"type": "file_search", "vector_store_ids": [vector_store_id]}],
    input="What does section 4.2 of our API spec say about authentication?",
    # Only the relevant section is retrieved, not the entire doc
)