diff --git a/examples/claude-promptlayer-nextjs/.env.example b/examples/claude-promptlayer-nextjs/.env.example
new file mode 100644
index 0000000..d6754b7
--- /dev/null
+++ b/examples/claude-promptlayer-nextjs/.env.example
@@ -0,0 +1,8 @@
+# Required for Claude API calls.
+ANTHROPIC_API_KEY=
+
+# Required for PromptLayer tracing.
+PROMPTLAYER_API_KEY=
+
+# Optional. Defaults to 3333.
+PORT=3333
diff --git a/examples/claude-promptlayer-nextjs/.gitignore b/examples/claude-promptlayer-nextjs/.gitignore
new file mode 100644
index 0000000..10adbb1
--- /dev/null
+++ b/examples/claude-promptlayer-nextjs/.gitignore
@@ -0,0 +1,30 @@
+# Dependencies
+node_modules/
+
+# Environment
+.env
+.env*.local
+
+# Next.js
+.next/
+out/
+next-env.d.ts
+
+# Production/build output
+dist/
+build/
+
+# TypeScript
+tsconfig.tsbuildinfo
+
+# Logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+
+# OS/editor
+.DS_Store
+.vscode/
+.idea/
diff --git a/examples/claude-promptlayer-nextjs/README.md b/examples/claude-promptlayer-nextjs/README.md
new file mode 100644
index 0000000..02f3fda
--- /dev/null
+++ b/examples/claude-promptlayer-nextjs/README.md
@@ -0,0 +1,20 @@
+# Claude PromptLayer Next App
+
+Tiny Next.js app for manually testing PromptLayer's Claude Agent SDK integration.
+
+## Setup
+
+```bash
+cp .env.example .env.local
+npm install
+npm run dev
+```
+
+Open the local URL printed by Next.js.
+
+## Environment
+
+- `ANTHROPIC_API_KEY` runs Claude.
+- `PROMPTLAYER_API_KEY` enables PromptLayer tracing through `getClaudeConfig()`.
+
+The development server uses port `3333` by default.
diff --git a/examples/claude-promptlayer-nextjs/app/api/run/route.ts b/examples/claude-promptlayer-nextjs/app/api/run/route.ts
new file mode 100644
index 0000000..30432bb
--- /dev/null
+++ b/examples/claude-promptlayer-nextjs/app/api/run/route.ts
@@ -0,0 +1,90 @@
+import { NextResponse } from "next/server";
+import { createSdkMcpServer, query, tool, type Options } from "@anthropic-ai/claude-agent-sdk";
+import { getClaudeConfig } from "promptlayer/claude-agents";
+
+export const runtime = "nodejs";
+
+export async function POST(request: Request) {
+  try {
+    const body = await request.json();
+    const prompt = String(body.prompt || "").trim();
+    const model = String(body.model || "sonnet").trim();
+
+    if (!prompt) {
+      return NextResponse.json({ error: "Prompt is required." }, { status: 400 });
+    }
+
+    const anthropicKey = requiredEnv("ANTHROPIC_API_KEY");
+    const promptLayerKey = requiredEnv("PROMPTLAYER_API_KEY");
+    const promptLayer = getClaudeConfig({ apiKey: promptLayerKey });
+    const labTools = createSdkMcpServer({
+      name: "lab-tools",
+      version: "0.1.0",
+      alwaysLoad: true,
+      tools: [
+        tool("random_number", "Generate a random integer from 1 to 100.", {}, async () => {
+          const value = Math.floor(Math.random() * 100) + 1;
+          return {
+            content: [{ type: "text", text: String(value) }],
+            structuredContent: { value }
+          };
+        })
+      ]
+    });
+
+    const options: Options = {
+      cwd: process.cwd(),
+      model,
+      maxTurns: 3,
+      plugins: [promptLayer.plugin],
+      mcpServers: {
+        "lab-tools": labTools
+      },
+      allowedTools: ["mcp__lab-tools__random_number"],
+      env: {
+        ...process.env,
+        ANTHROPIC_API_KEY: anthropicKey,
+        ...promptLayer.env
+      }
+    };
+
+    const messages: unknown[] = [];
+    for await (const message of query({ prompt, options })) {
+      messages.push(message);
+    }
+
+    return NextResponse.json({
+      text: extractText(messages),
+      messages
+    });
+  } catch (error) {
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : String(error) },
+      { status: 500 }
+    );
+  }
+}
+
+function requiredEnv(name: "ANTHROPIC_API_KEY" | "PROMPTLAYER_API_KEY") {
+  const value = process.env[name]?.trim();
+  if (!value) throw new Error(`Missing ${name}. Add it to .env and restart npm run dev.`);
+  return value;
+}
+
+function extractText(value: unknown) {
+  const parts: string[] = [];
+  visit(value);
+  return parts.join("\n");
+
+  function visit(item: unknown) {
+    if (Array.isArray(item)) {
+      item.forEach(visit);
+      return;
+    }
+    if (!item || typeof item !== "object") return;
+
+    const record = item as Record<string, unknown>;
+    if (typeof record.text === "string") parts.push(record.text);
+    Object.values(record).forEach(visit);
+  }
+}
diff --git a/examples/claude-promptlayer-nextjs/app/globals.css b/examples/claude-promptlayer-nextjs/app/globals.css
new file mode 100644
index 0000000..ba88091
--- /dev/null
+++ b/examples/claude-promptlayer-nextjs/app/globals.css
@@ -0,0 +1,132 @@
+* {
+  box-sizing: border-box;
+}
+
+body {
+  margin: 0;
+  background: #f6f7f8;
+  color: #172026;
+  font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+}
+
+button,
+input,
+textarea {
+  font: inherit;
+}
+
+button {
+  min-height: 38px;
+  border: 1px solid #d6dde2;
+  border-radius: 6px;
+  background: #fff;
+  padding: 0 14px;
+  cursor: pointer;
+}
+
+button:disabled {
+  cursor: wait;
+  opacity: 0.7;
+}
+
+.shell {
+  width: min(900px, calc(100vw - 32px));
+  margin: 0 auto;
+  padding: 28px 0 40px;
+}
+
+.panelHead {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 16px;
+}
+
+h1,
+h2,
+p {
+  margin: 0;
+}
+
+h1 {
+  font-size: 28px;
+}
+
+h2 {
+  font-size: 18px;
+}
+
+p,
+label {
+  color: #5d6b76;
+}
+
+p {
+  margin-top: 6px;
+}
+
+.panel,
+.output {
+  border: 1px solid #d6dde2;
+  border-radius: 8px;
+  background: #fff;
+}
+
+.panel,
+.output {
+  margin-top: 18px;
+  padding: 18px;
+}
+
+label {
+  display: grid;
+  gap: 6px;
+  margin-top: 14px;
+  font-size: 13px;
+}
+
+label:first-child {
+  margin-top: 0;
+}
+
+input,
+textarea {
+  width: 100%;
+  border: 1px solid #d6dde2;
+  border-radius: 6px;
+  padding: 9px 10px;
+}
+
+textarea {
+  min-height: 140px;
+  resize: vertical;
+}
+
+.primary {
+  width: fit-content;
+  margin-top: 16px;
+  border-color: #0f766e;
+  background: #0f766e;
+  color: #fff;
+}
+
+pre {
+  min-height: 260px;
+  max-height: 560px;
+  overflow: auto;
+  margin: 14px 0 0;
+  padding: 14px;
+  border-radius: 6px;
+  background: #101820;
+  color: #d7f7ef;
+  font-size: 13px;
+  line-height: 1.5;
+  white-space: pre-wrap;
+}
+
+@media (max-width: 720px) {
+  .panelHead {
+    display: grid;
+    grid-template-columns: 1fr;
+  }
+}
diff --git a/examples/claude-promptlayer-nextjs/app/layout.tsx b/examples/claude-promptlayer-nextjs/app/layout.tsx
new file mode 100644
index 0000000..dec73ab
--- /dev/null
+++ b/examples/claude-promptlayer-nextjs/app/layout.tsx
@@ -0,0 +1,15 @@
+import type { Metadata } from "next";
+import "./globals.css";
+
+export const metadata: Metadata = {
+  title: "Claude PromptLayer Next App",
+  description: "Local manual tester for Claude Agent SDK plus PromptLayer."
+};
+
+export default function RootLayout({ children }: { children: React.ReactNode }) {
+  return (
+    <html lang="en">
+      <body>{children}</body>
+    </html>
+  );
+}
diff --git a/examples/claude-promptlayer-nextjs/app/page.tsx b/examples/claude-promptlayer-nextjs/app/page.tsx
new file mode 100644
index 0000000..349de43
--- /dev/null
+++ b/examples/claude-promptlayer-nextjs/app/page.tsx
@@ -0,0 +1,65 @@
+"use client";
+
+import { useState } from "react";
+
+const defaultPrompt = "Use the random_number tool, then tell me the number it returned.";
+
+export default function Home() {
+  const [model, setModel] = useState("sonnet");
+  const [prompt, setPrompt] = useState(defaultPrompt);
+  const [output, setOutput] = useState("Ready.");
+  const [running, setRunning] = useState(false);
+
+  async function runPrompt() {
+    setRunning(true);
+    setOutput("Running...");
+
+    try {
+      const response = await fetch("/api/run", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ model, prompt })
+      });
+      const data = await response.json();
+
+      setOutput(JSON.stringify(data, null, 2));
+    } catch (error) {
+      setOutput(JSON.stringify({ error: error instanceof Error ? error.message : String(error) }, null, 2));
+    } finally {
+      setRunning(false);
+    }
+  }
+
+  return (
+    <main className="shell">
+      <header>
+        <h1>Claude PromptLayer Lab</h1>
+        <p>One route, one SDK call, PromptLayer tracing enabled through code.</p>
+      </header>
+
+      <section className="panel">
+        <label>
+          Model
+          <input value={model} onChange={(event) => setModel(event.target.value)} />
+        </label>
+
+        <label>
+          Prompt
+          <textarea value={prompt} onChange={(event) => setPrompt(event.target.value)} />
+        </label>
+
+        <button className="primary" onClick={runPrompt} disabled={running || !prompt.trim()}>
+          {running ? "Running..." : "Run"}
+        </button>
+      </section>
+
+      <section className="output">
+        <div className="panelHead">
+          <h2>Output</h2>
+          <button onClick={() => setOutput("Ready.")}>Clear</button>
+        </div>
+        <pre>{output}</pre>
+      </section>
+    </main>
+  );
+}
diff --git a/examples/claude-promptlayer-nextjs/next.config.ts b/examples/claude-promptlayer-nextjs/next.config.ts
new file mode 100644
index 0000000..ee33dd6
--- /dev/null
+++ b/examples/claude-promptlayer-nextjs/next.config.ts
@@ -0,0 +1,11 @@
+import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {
+  // Keep the app straightforward while testing SDK behavior locally.
+  reactStrictMode: true,
+  // These SDKs are Node-only here. Externalizing them prevents Next from trying
+  // to bundle PromptLayer's optional provider integrations into the app route.
+  serverExternalPackages: ["promptlayer", "@anthropic-ai/claude-agent-sdk"]
+};
+
+export default nextConfig;
diff --git a/examples/claude-promptlayer-nextjs/package.json b/examples/claude-promptlayer-nextjs/package.json
new file mode 100644
index 0000000..da2ed96
--- /dev/null
+++ b/examples/claude-promptlayer-nextjs/package.json
@@ -0,0 +1,25 @@
+{
+  "name": "claude-promptlayer-nextjs",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "next dev -p 3333",
+    "build": "next build",
+    "start": "next start -p 3333",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "latest",
+    "next": "latest",
+    "promptlayer": "latest",
+    "react": "latest",
+    "react-dom": "latest"
+  },
+  "devDependencies": {
+    "@types/node": "latest",
+    "@types/react": "latest",
+    "@types/react-dom": "latest",
+    "typescript": "latest"
+  }
+}
diff --git a/examples/claude-promptlayer-nextjs/tsconfig.json b/examples/claude-promptlayer-nextjs/tsconfig.json
new file mode 100644
index 0000000..34b6982
--- /dev/null
+++ b/examples/claude-promptlayer-nextjs/tsconfig.json
@@ -0,0 +1,37 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
+    "allowJs": false,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}
diff --git a/examples/claude-promptlayer-python/.env.example b/examples/claude-promptlayer-python/.env.example
new file mode 100644
index 0000000..74a29f2
--- /dev/null
+++ b/examples/claude-promptlayer-python/.env.example
@@ -0,0 +1,5 @@
+# Required for Claude API calls.
+ANTHROPIC_API_KEY=
+
+# Required for PromptLayer tracing.
+PROMPTLAYER_API_KEY=
diff --git a/examples/claude-promptlayer-python/.gitignore b/examples/claude-promptlayer-python/.gitignore
new file mode 100644
index 0000000..1310d4f
--- /dev/null
+++ b/examples/claude-promptlayer-python/.gitignore
@@ -0,0 +1,46 @@
+# Environment and secrets
+.env
+.env.*
+!.env.example
+
+# Python bytecode and caches
+__pycache__/
+*.py[cod]
+*$py.class
+.pycache/
+
+# Virtual environments
+.venv/
+venv/
+env/
+ENV/
+
+# Build and package output
+build/
+dist/
+*.egg-info/
+*.egg
+uv.lock
+
+# Test, coverage, and tool caches
+.coverage
+.coverage.*
+htmlcov/
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.pyre/
+.tox/
+.nox/
+
+# Local editor and OS files
+.DS_Store
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Local logs and scratch output
+*.log
+tmp/
+temp/
diff --git a/examples/claude-promptlayer-python/README.md b/examples/claude-promptlayer-python/README.md
new file mode 100644
index 0000000..f7c967b
--- /dev/null
+++ b/examples/claude-promptlayer-python/README.md
@@ -0,0 +1,41 @@
+# Claude PromptLayer Python Lab
+
+Tiny Python CLI for manually testing PromptLayer's Claude Agent SDK integration.
+
+It runs one Claude Agent SDK query, enables PromptLayer tracing through `get_claude_config()`, and exposes one in-process MCP tool named `random_number` in the model's default tool set.
+
+## Setup
+
+```bash
+cp .env.example .env
+uv sync
+```
+
+Or with pip:
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -e .
+python -m claude_promptlayer_python_lab.main
+```
+
+## Environment
+
+- `ANTHROPIC_API_KEY` runs Claude.
+- `PROMPTLAYER_API_KEY` enables PromptLayer tracing through `get_claude_config()`.
+
+## Usage
+
+CLI:
+
+```bash
+uv run claude-promptlayer-python \
+  "Use the random_number tool, then tell me the number it returned."
+```
+
+Optional flags:
+
+```bash
+uv run claude-promptlayer-python --model sonnet --max-turns 3
+```
diff --git a/examples/claude-promptlayer-python/pyproject.toml b/examples/claude-promptlayer-python/pyproject.toml
new file mode 100644
index 0000000..83d678a
--- /dev/null
+++ b/examples/claude-promptlayer-python/pyproject.toml
@@ -0,0 +1,18 @@
+[project]
+name = "claude-promptlayer-python"
+version = "0.1.0"
+description = "Tiny Python lab for PromptLayer tracing with the Claude Agent SDK."
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "claude-agent-sdk",
+    "promptlayer[claude-agents]",
+    "python-dotenv",
+]
+
+[project.scripts]
+claude-promptlayer-python = "claude_promptlayer_python_lab.main:cli"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
diff --git a/examples/claude-promptlayer-python/src/claude_promptlayer_python_lab/__init__.py b/examples/claude-promptlayer-python/src/claude_promptlayer_python_lab/__init__.py
new file mode 100644
index 0000000..1964423
--- /dev/null
+++ b/examples/claude-promptlayer-python/src/claude_promptlayer_python_lab/__init__.py
@@ -0,0 +1 @@
+"""Minimal Claude Agent SDK + PromptLayer Python lab."""
diff --git a/examples/claude-promptlayer-python/src/claude_promptlayer_python_lab/main.py b/examples/claude-promptlayer-python/src/claude_promptlayer_python_lab/main.py
new file mode 100644
index 0000000..c339a8f
--- /dev/null
+++ b/examples/claude-promptlayer-python/src/claude_promptlayer_python_lab/main.py
@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import argparse
+import asyncio
+import os
+import random
+from dataclasses import asdict, is_dataclass
+from pathlib import Path
+from typing import Any, TypedDict
+
+from claude_agent_sdk import (
+    AssistantMessage,
+    ClaudeAgentOptions,
+    ResultMessage,
+    TextBlock,
+    ToolUseBlock,
+    create_sdk_mcp_server,
+    query,
+    tool,
+)
+from dotenv import load_dotenv
+from promptlayer.integrations.claude_agents import get_claude_config
+
+DEFAULT_PROMPT = "Use the random_number tool, then tell me the number it returned."
+RANDOM_NUMBER_TOOL = "mcp__lab-tools__random_number"
+
+
+class AgentResult(TypedDict):
+    text: str
+    messages: list[Any]
+
+
+@tool("random_number", "Generate a random integer from 1 to 100.", {})
+async def random_number(args: dict[str, Any]) -> dict[str, Any]:
+    value = random.randint(1, 100)
+    return {
+        "content": [{"type": "text", "text": str(value)}],
+        "structuredContent": {"value": value},
+    }
+
+
+async def run_agent(prompt: str, model: str, max_turns: int) -> AgentResult:
+    required_env("ANTHROPIC_API_KEY")
+    promptlayer_key = required_env("PROMPTLAYER_API_KEY")
+
+    pl_claude_config = get_claude_config(api_key=promptlayer_key)
+    lab_tools = create_sdk_mcp_server(
+        name="lab-tools",
+        version="0.1.0",
+        tools=[random_number],
+    )
+    options = ClaudeAgentOptions(
+        cwd=Path.cwd(),
+        model=model,
+        max_turns=max_turns,
+        tools=[RANDOM_NUMBER_TOOL],
+        plugins=[pl_claude_config.plugin],
+        mcp_servers={"lab-tools": lab_tools},
+        allowed_tools=[RANDOM_NUMBER_TOOL],
+        env={**os.environ, **pl_claude_config.env},
+    )
+
+    messages: list[Any] = []
+    text_parts: list[str] = []
+    async for message in query(prompt=prompt, options=options):
+        messages.append(serialize_message(message))
+        text_parts.extend(extract_text(message))
+
+    return {
+        "text": "\n".join(text_parts),
+        "messages": messages,
+    }
+
+
+async def run(prompt: str, model: str, max_turns: int) -> None:
+    result = await run_agent(prompt, model, max_turns)
+    for message in result["messages"]:
+        print_message(message)
+
+
+def print_message(message: Any) -> None:
+    if isinstance(message, dict):
+        if message.get("type") == "assistant":
+            for block in message.get("content", []):
+                if block.get("type") == "text":
+                    print(block.get("text", ""))
+                elif block.get("type") == "tool_use":
+                    print(f"[tool] {block.get('name', '')}")
+        elif message.get("type") == "result" and message.get("result"):
+            print(f"\n[result]\n{message['result']}")
+        else:
+            print(message)
+        return
+
+    print_message(serialize_message(message))
+
+
+def extract_text(message: Any) -> list[str]:
+    parts: list[str] = []
+
+    if isinstance(message, AssistantMessage):
+        for block in message.content:
+            if isinstance(block, TextBlock):
+                parts.append(block.text)
+            elif isinstance(block, ToolUseBlock):
+                parts.append(f"[tool] {block.name}")
+    elif isinstance(message, ResultMessage) and message.result:
+        parts.append(message.result)
+
+    return parts
+
+
+def serialize_message(message: Any) -> Any:
+    if is_dataclass(message):
+        return asdict(message)
+    return message
+
+
+def required_env(name: str) -> str:
+    value = os.environ.get(name, "").strip()
+    if not value:
+        raise RuntimeError(f"Missing {name}. Add it to .env or export it before running.")
+    return value
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Run Claude with PromptLayer tracing enabled.")
+    parser.add_argument("prompt", nargs="?", default=DEFAULT_PROMPT)
+    parser.add_argument("--model", default="sonnet")
+    parser.add_argument("--max-turns", type=int, default=3)
+    return parser.parse_args()
+
+
+def cli() -> None:
+    load_dotenv()
+    args = parse_args()
+    asyncio.run(run(args.prompt, args.model, args.max_turns))
+
+
+if __name__ == "__main__":
+    cli()
diff --git a/examples/langchain-itinerary/.env.example b/examples/langchain-itinerary/.env.example
new file mode 100644
index 0000000..6c2e832
--- /dev/null
+++ b/examples/langchain-itinerary/.env.example
@@ -0,0 +1,27 @@
+# Required for LangChain/OpenAI calls.
+OPENAI_API_KEY=
+
+# Required for LangChain/Anthropic calls when LANGCHAIN_MODEL_PROVIDER=anthropic.
+ANTHROPIC_API_KEY=
+
+# Optional provider/model overrides.
+# LANGCHAIN_MODEL_PROVIDER=openai
+# OPENAI_MODEL=gpt-4o-mini
+# ANTHROPIC_MODEL=claude-sonnet-4-6
+
+# Optional Anthropic effort. When set, the app enables adaptive thinking and
+# passes this value directly to ChatAnthropic outputConfig.effort.
+# Valid values: low, medium, high, xhigh, max.
+ANTHROPIC_THINKING=medium
+
+# Required for LangChain to emit spans automatically.
+LANGSMITH_TRACING=true
+LANGSMITH_TRACING_MODE=otel
+
+# Recommended so spans flush before server action completion.
+LANGCHAIN_CALLBACKS_BACKGROUND=false
+
+# Optional: enable OTEL export to PromptLayer.
+# If OTEL_EXPORTER_OTLP_ENDPOINT is not set, trace export is disabled.
+OTEL_EXPORTER_OTLP_ENDPOINT=https://api.promptlayer.com/v1/traces
+OTEL_EXPORTER_OTLP_HEADERS=X-API-KEY=<PROMPTLAYER_API_KEY>
diff --git a/examples/langchain-itinerary/.gitignore b/examples/langchain-itinerary/.gitignore
new file mode 100644
index 0000000..79eb408
--- /dev/null
+++ b/examples/langchain-itinerary/.gitignore
@@ -0,0 +1,43 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+/.pnp
+.pnp.*
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/versions
+
+# testing
+/coverage
+
+# next.js
+/.next/
+/out/
+
+# production
+/build
+
+# misc
+.DS_Store
+*.pem
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.pnpm-debug.log*
+
+# env files
+.env*
+.env
+!.env.example
+
+# vercel
+.vercel
+
+# typescript
+*.tsbuildinfo
+next-env.d.ts
diff --git a/examples/langchain-itinerary/README.md b/examples/langchain-itinerary/README.md
new file mode 100644
index 0000000..966de95
--- /dev/null
+++ b/examples/langchain-itinerary/README.md
@@ -0,0 +1,84 @@
+# Pocket Trip Pal
+
+A small Next.js chat app that demonstrates a traced LangChain itinerary assistant.
+
+The frontend keeps chat history in local React state. The `/api/chat` route runs OpenAI or Anthropic through LangChain, forces a mocked `lookup_destination_highlights` tool call, and can export OpenTelemetry spans for the route, LLM calls, and tool execution.
+
+## Setup
+
+Install dependencies:
+
+```bash
+npm install
+```
+
+Create `.env`:
+
+```bash
+cp .env.example .env
+```
+
+Set at least:
+
+```bash
+OPENAI_API_KEY=
+```
+
+To use Anthropic instead:
+
+```bash
+LANGCHAIN_MODEL_PROVIDER=anthropic
+ANTHROPIC_API_KEY=
+ANTHROPIC_MODEL=claude-sonnet-4-6
+ANTHROPIC_THINKING=medium
+```
+
+Start the development server:
+
+```bash
+npm run dev
+```
+
+## Environment Variables
+
+- `LANGCHAIN_MODEL_PROVIDER`: optional, `openai` or `anthropic`; defaults to `openai`.
+- `OPENAI_API_KEY`: required server-side OpenAI key when using OpenAI.
+- `OPENAI_MODEL`: optional, defaults to `gpt-4o-mini`.
+- `ANTHROPIC_API_KEY`: required server-side Anthropic key when using Anthropic.
+- `ANTHROPIC_MODEL`: optional, defaults to `claude-sonnet-4-6`.
+- `ANTHROPIC_THINKING`: optional Anthropic effort value. When set, the app enables adaptive thinking and passes the value to `ChatAnthropic` as `outputConfig.effort`.
+- `LANGSMITH_TRACING`, `LANGSMITH_TRACING_MODE`, `LANGCHAIN_CALLBACKS_BACKGROUND`: enable LangChain OTEL tracing mode.
+- `OTEL_EXPORTER_OTLP_ENDPOINT`: PromptLayer OTLP endpoint, `https://api.promptlayer.com/v1/traces`.
+- `OTEL_EXPORTER_OTLP_HEADERS`: PromptLayer OTLP API key header, `X-API-KEY=<PROMPTLAYER_API_KEY>`.
+
+## Scripts
+
+- `npm run dev`: run the local dev server.
+- `npm run build`: create a production build.
+- `npm run start`: serve the production build.
+- `npm run lint`: run ESLint.
+
+## Project Structure
+
+```text
+src/app/page.tsx          Main page shell
+src/app/chat-client.tsx   Client-side chat UI and fetch logic
+src/app/api/chat/route.ts API route validation, tracing, and response handling
+src/app/itinerary.ts      LangChain prompt, tool definition, and LLM orchestration
+src/instrumentation.ts    OpenTelemetry and LangSmith setup
+instrumentation.ts        Next.js root instrumentation export
+```
+
+## Request Flow
+
+1. The user sends a message from the chat UI.
+2. The client posts `{ input }` to `/api/chat`.
+3. The API route validates the request and opens an `itinerary.request` span.
+4. `runItineraryPrompt` creates a LangChain chat model for the configured provider with the mocked destination tool bound.
+5. The first model call is forced to call `lookup_destination_highlights`.
+6. The tool result is added back into the message history.
+7. A follow-up model call returns the final user-facing itinerary response.
+
+## Notes
+
+Chat history is not persisted. Destination data is mocked in `getDestinationHighlights` inside `src/app/itinerary.ts`. `.env` is ignored by git.
diff --git a/examples/langchain-itinerary/eslint.config.mjs b/examples/langchain-itinerary/eslint.config.mjs
new file mode 100644
index 0000000..05e726d
--- /dev/null
+++ b/examples/langchain-itinerary/eslint.config.mjs
@@ -0,0 +1,18 @@
+import { defineConfig, globalIgnores } from "eslint/config";
+import nextVitals from "eslint-config-next/core-web-vitals";
+import nextTs from "eslint-config-next/typescript";
+
+const eslintConfig = defineConfig([
+  ...nextVitals,
+  ...nextTs,
+  // Override default ignores of eslint-config-next.
+  globalIgnores([
+    // Default ignores of eslint-config-next:
+    ".next/**",
+    "out/**",
+    "build/**",
+    "next-env.d.ts",
+  ]),
+]);
+
+export default eslintConfig;
diff --git a/examples/langchain-itinerary/instrumentation.ts b/examples/langchain-itinerary/instrumentation.ts
new file mode 100644
index 0000000..17324ef
--- /dev/null
+++ b/examples/langchain-itinerary/instrumentation.ts
@@ -0,0 +1,2 @@
+// Keep Next's required root instrumentation file thin; the real setup lives in src/instrumentation.ts.
+export { register } from "./src/instrumentation";
diff --git a/examples/langchain-itinerary/next.config.ts b/examples/langchain-itinerary/next.config.ts
new file mode 100644
index 0000000..45575eb
--- /dev/null
+++ b/examples/langchain-itinerary/next.config.ts
@@ -0,0 +1,10 @@
+import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {
+  logging: {
+    // Keep local logs readable while inspecting OTEL spans for each API request.
+    serverFunctions: false,
+  },
+};
+
+export default nextConfig;
diff --git a/examples/langchain-itinerary/package.json b/examples/langchain-itinerary/package.json
new file mode 100644
index 0000000..100151a
--- /dev/null
+++ b/examples/langchain-itinerary/package.json
@@ -0,0 +1,33 @@
+{
+  "name": "langchain-itinerary",
+  "version": "0.1.0",
+  "private": true,
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "lint": "eslint"
+  },
+  "dependencies": {
+    "@langchain/anthropic": "^1.3.29",
+    "@langchain/core": "^1.1.41",
+    "@langchain/openai": "^1.4.4",
+    "@opentelemetry/api": "^1.9.1",
+    "@opentelemetry/context-async-hooks": "^2.7.0",
+    "@opentelemetry/exporter-trace-otlp-proto": "^0.205.0",
+    "@opentelemetry/sdk-trace-base": "^2.7.0",
+    "next": "^16.2.4",
+    "react": "19.2.4",
+    "react-dom": "19.2.4",
+    "react-markdown": "^10.1.0",
+    "remark-gfm": "^4.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "eslint": "^9",
+    "eslint-config-next": "16.2.4",
+    "typescript": "^5"
+  }
+}
diff --git a/examples/langchain-itinerary/src/app/api/chat/route.ts b/examples/langchain-itinerary/src/app/api/chat/route.ts
new file mode 100644
index 0000000..021ab8b
--- /dev/null
+++ b/examples/langchain-itinerary/src/app/api/chat/route.ts
@@ -0,0 +1,46 @@
+import { NextResponse } from "next/server";
+import { trace, type Span } from "@opentelemetry/api";
+
+import { runItineraryPrompt } from "../../itinerary";
+
+// LangChain/OpenAI and OTEL context management need the Node runtime, not the Edge runtime.
+export const runtime = "nodejs";
+// Always execute the route on demand so each chat turn creates fresh spans.
+export const dynamic = "force-dynamic";
+
+type ChatRequestBody = {
+  input?: unknown;
+};
+
+async function withSpan<T>(name: string, fn: (span: Span) => Promise<T>): Promise<T> {
+  return trace.getTracer("langchain-itinerary-app").startActiveSpan(name, async (span) => {
+    try {
+      return await fn(span);
+    } finally {
+      span.end();
+    }
+  });
+}
+
+export async function POST(request: Request) {
+  let body: ChatRequestBody;
+
+  try {
+    // The client sends exactly one field: { input }, which becomes the human message.
+    body = await request.json();
+  } catch {
+    return NextResponse.json({ error: "Request body must be valid JSON." }, { status: 400 });
+  }
+
+  const input = typeof body.input === "string" ? body.input.trim() : "";
+  if (!input) {
+    return NextResponse.json({ error: "Message is required." }, { status: 400 });
+  }
+
+  const reply = await withSpan("itinerary.request", (span) => {
+    span.setAttribute("langsmith.span.kind", "chain");
+    return runItineraryPrompt(input);
+  });
+
+  return NextResponse.json({ reply });
+}
diff --git a/examples/langchain-itinerary/src/app/chat-client.tsx b/examples/langchain-itinerary/src/app/chat-client.tsx
new file mode 100644
index 0000000..37dd553
--- /dev/null
+++ b/examples/langchain-itinerary/src/app/chat-client.tsx
@@ -0,0 +1,138 @@
+"use client";
+
+import { useState } from "react";
+import ReactMarkdown from "react-markdown";
+import remarkGfm from "remark-gfm";
+
+type Message = {
+  id: number;
+  sender: "user" | "bot";
+  text: string;
+};
+
+type SubmitEventLike = {
+  preventDefault: () => void;
+};
+
+export function ChatClient() {
+  const [messages, setMessages] = useState<Message[]>([]);
+  const [draft, setDraft] = useState("");
+  const [isSending, setIsSending] = useState(false);
+
+  function appendMessage(sender: Message["sender"], text: string) {
+    // Local-only chat history keeps the demo focused on server tracing, not persistence.
+    setMessages((current) => [
+      ...current,
+      { id: current.length + 1, sender, text },
+    ]);
+  }
+
+  async function sendMessage(userText: string) {
+    if (isSending) {
+      return;
+    }
+
+    appendMessage("user", userText);
+    setDraft("");
+    setIsSending(true);
+
+    try {
+      // The API route owns validation, OpenAI access, LangChain orchestration, and OTEL spans.
+      const response = await fetch("/api/chat", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          input: userText,
+        }),
+      });
+
+      const data = (await response.json()) as { reply?: string; error?: string };
+      if (!response.ok) {
+        throw new Error(data.error || "The server could not complete the request.");
+      }
+
+      const reply = data.reply ?? "";
+      appendMessage("bot", reply);
+    } catch (error) {
+      const message =
+        error instanceof Error ? error.message : "I hit a server-side issue. Try again.";
+      appendMessage("bot", message);
+    } finally {
+      setIsSending(false);
+    }
+  }
+
+  async function handleSubmit(event: SubmitEventLike) {
+    event.preventDefault();
+
+    // Trim on submit so empty or whitespace-only messages never reach the traced API route.
+    const userText = draft.trim();
+    if (!userText || isSending) {
+      return;
+    }
+
+    await sendMessage(userText);
+  }
+
+  return (
+    <>
+      <div className="chat">
+        {messages.length === 0 ? (
+          <div className="emptyState">
+            <div className="emptyCard">
+              <span className="badge">starter note</span>
+              <p>Nothing here yet. Submit a question below to get started.</p>
+            </div>
+          </div>
+        ) : (
+          messages.map((message) => (
+            <article
+              key={message.id}
+              className={message.sender === "bot" ? "botBubble" : "userBubble"}
+            >
+              <span className="badge">{message.sender === "bot" ? "pal" : "you"}</span>
+              {/* Render model/user text as markdown at the UI edge; tracing still records the raw string. */}
+              <div className="markdown">
+                <ReactMarkdown remarkPlugins={[remarkGfm]}>
+                  {message.text}
+                </ReactMarkdown>
+              </div>
+            </article>
+          ))
+        )}
+
+        {isSending ? (
+          <article className="loadingBubble">
+            <span className="badge">pal</span>
+            <div className="loadingDots" aria-label="Agent is thinking">
+              <span />
+              <span />
+              <span />
+            </div>
+          </article>
+        ) : null}
+      </div>
+
+      <form className="composer" onSubmit={handleSubmit}>
+        <label className="composerLabel" htmlFor="trip-draft">
+          Tell me the mood, city, or snack priority
+        </label>
+        <div className="composerRow">
+          <input
+            id="trip-draft"
+            className="input"
+            onChange={(event) => setDraft(event.target.value)}
+            placeholder="A cozy three-day escape with maximal pastries..."
+            value={draft}
+            disabled={isSending}
+          />
+          <button className="sendButton" type="submit" disabled={isSending}>
+            {isSending ? "Planning..." : "Send"}
+          </button>
+        </div>
+      </form>
+    </>
+  );
+}
diff --git a/examples/langchain-itinerary/src/app/globals.css b/examples/langchain-itinerary/src/app/globals.css
new file mode 100644
index 0000000..9072c11
--- /dev/null
+++ b/examples/langchain-itinerary/src/app/globals.css
@@ -0,0 +1,389 @@
+:root {
+  --background: #fff9ef;
+  --foreground: #2c1f19;
+  --font-fredoka: "Avenir Next", "Segoe UI", sans-serif;
+  --font-ibm-plex-mono: "SFMono-Regular", Menlo, Monaco, Consolas, monospace;
+}
+
+html {
+  height: 100%;
+}
+
+html,
+body {
+  max-width: 100vw;
+  overflow-x: hidden;
+}
+
+body {
+  min-height: 100%;
+  display: flex;
+  flex-direction: column;
+  color: var(--foreground);
+  background: var(--background);
+  font-family: var(--font-fredoka), sans-serif;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+* {
+  box-sizing: border-box;
+  padding: 0;
+  margin: 0;
+}
+
+a {
+  color: inherit;
+  text-decoration: none;
+}
+
+.page {
+  position: relative;
+  display: grid;
+  min-height: 100vh;
+  place-items: center;
+  overflow: hidden;
+  padding: 32px 20px;
+  background:
+    radial-gradient(circle at top left, #ffd98e 0, transparent 28%),
+    radial-gradient(circle at top right, #ffb6d1 0, transparent 24%),
+    radial-gradient(circle at bottom left, #b6d8ff 0, transparent 22%),
+    linear-gradient(180deg, #fff8ed 0%, #ffeecf 100%);
+}
+
+.shell {
+  position: relative;
+  z-index: 1;
+  width: min(100%, 760px);
+  border: 3px solid #2c1f19;
+  border-radius: 36px;
+  background: rgba(255, 252, 246, 0.92);
+  box-shadow:
+    0 18px 0 #2c1f19,
+    0 28px 90px rgba(92, 53, 37, 0.2);
+  padding: 28px;
+}
+
+.header {
+  display: flex;
+  align-items: baseline;
+  justify-content: flex-start;
+  flex-wrap: wrap;
+  gap: 16px;
+}
+
+.eyebrow {
+  color: #9d4c28;
+  font-family: var(--font-ibm-plex-mono), monospace;
+  font-size: 12px;
+  letter-spacing: 0.12em;
+  text-transform: uppercase;
+}
+
+.header h1 {
+  font-size: clamp(2rem, 4vw, 3.2rem);
+  line-height: 0.95;
+}
+
+.subtitle {
+  margin-top: 12px;
+  max-width: 56ch;
+  color: #5e4b43;
+  font-size: 1rem;
+  line-height: 1.5;
+}
+
+.chat {
+  display: flex;
+  flex-direction: column;
+  gap: 14px;
+  margin-top: 24px;
+  min-height: 360px;
+  border: 2px dashed #d8b27d;
+  border-radius: 28px;
+  background:
+    linear-gradient(180deg, rgba(255, 255, 255, 0.8), rgba(255, 245, 223, 0.9));
+  padding: 18px;
+}
+
+.emptyState {
+  flex: 1;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  min-height: 320px;
+}
+
+.emptyCard {
+  max-width: 320px;
+  border: 2px solid #2c1f19;
+  border-radius: 24px;
+  background: rgba(255, 255, 255, 0.92);
+  padding: 18px 20px;
+  text-align: center;
+  box-shadow: 0 8px 0 rgba(44, 31, 25, 0.12);
+}
+
+.emptyCard p {
+  color: #5e4b43;
+  line-height: 1.5;
+}
+
+.botBubble,
+.userBubble,
+.loadingBubble {
+  max-width: 85%;
+  border: 2px solid #2c1f19;
+  border-radius: 24px;
+  padding: 14px 16px;
+  box-shadow: 0 6px 0 rgba(44, 31, 25, 0.12);
+}
+
+.botBubble {
+  align-self: flex-start;
+  background: #fff;
+}
+
+.loadingBubble {
+  align-self: flex-start;
+  background: #fff7e8;
+}
+
+.userBubble {
+  align-self: flex-end;
+  background: #ffddb1;
+}
+
+.badge {
+  display: inline-block;
+  margin-bottom: 8px;
+  font-family: var(--font-ibm-plex-mono), monospace;
+  font-size: 11px;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+  color: #9d4c28;
+}
+
+.botBubble p,
+.userBubble p {
+  line-height: 1.45;
+}
+
+.markdown {
+  line-height: 1.5;
+}
+
+.markdown p + p,
+.markdown ul,
+.markdown ol,
+.markdown pre,
+.markdown blockquote {
+  margin-top: 12px;
+}
+
+.markdown ul,
+.markdown ol {
+  padding-left: 20px;
+}
+
+.markdown li + li {
+  margin-top: 6px;
+}
+
+.markdown code {
+  border-radius: 8px;
+  background: #f6ead2;
+  padding: 2px 6px;
+  font-family: var(--font-ibm-plex-mono), monospace;
+  font-size: 0.92em;
+}
+
+.markdown pre {
+  overflow-x: auto;
+  border-radius: 16px;
+  background: #2c1f19;
+  padding: 14px;
+  color: #fff7e8;
+}
+
+.markdown pre code {
+  background: transparent;
+  padding: 0;
+  color: inherit;
+}
+
+.markdown a {
+  text-decoration: underline;
+  text-decoration-thickness: 2px;
+}
+
+.markdown strong {
+  font-weight: 700;
+}
+
+.markdown blockquote {
+  border-left: 4px solid #ffb36b;
+  padding-left: 12px;
+  color: #6d584b;
+}
+
+.loadingDots {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  min-height: 24px;
+}
+
+.loadingDots span {
+  width: 10px;
+  height: 10px;
+  border-radius: 999px;
+  background: #ff8f6b;
+  animation: bounce 1.1s infinite ease-in-out;
+}
+
+.loadingDots span:nth-child(2) {
+  animation-delay: 0.15s;
+}
+
+.loadingDots span:nth-child(3) {
+  animation-delay: 0.3s;
+}
+
+.composer {
+  margin-top: 18px;
+}
+
+.composerLabel {
+  display: block;
+  margin-bottom: 10px;
+  color: #5e4b43;
+  font-size: 0.95rem;
+}
+
+.composerRow {
+  display: flex;
+  gap: 12px;
+}
+
+.input {
+  flex: 1;
+  min-width: 0;
+  border: 2px solid #2c1f19;
+  border-radius: 18px;
+  background: #fff;
+  padding: 16px 18px;
+  color: #2c1f19;
+  font: inherit;
+  outline: none;
+}
+
+.input::placeholder {
+  color: #9b8274;
+}
+
+.input:focus {
+  box-shadow: 0 0 0 4px rgba(255, 166, 92, 0.35);
+}
+
+.sendButton {
+  border: 2px solid #2c1f19;
+  border-radius: 18px;
+  background: #ff8f6b;
+  padding: 16px 22px;
+  color: #2c1f19;
+  font: inherit;
+  font-weight: 600;
+  cursor: pointer;
+  transition:
+    transform 120ms ease,
+    box-shadow 120ms ease,
+    background 120ms ease;
+}
+
+.sendButton:hover {
+  transform: translateY(-2px);
+  background: #ff7d56;
+  box-shadow: 0 6px 0 #2c1f19;
+}
+
+.orbit,
+.spark {
+  position: absolute;
+  border-radius: 999px;
+  pointer-events: none;
+}
+
+.orbit {
+  top: 8%;
+  left: 8%;
+  width: 220px;
+  height: 220px;
+  border: 3px dashed rgba(44, 31, 25, 0.14);
+}
+
+.orbitTwo {
+  right: 6%;
+  bottom: 12%;
+  left: auto;
+  width: 140px;
+  height: 140px;
+}
+
+.spark {
+  top: 14%;
+  right: 14%;
+  width: 26px;
+  height: 26px;
+  background: #ff7fb2;
+  box-shadow:
+    0 0 0 8px rgba(255, 127, 178, 0.22),
+    -440px 420px 0 4px #7bc6ff,
+    -380px 390px 0 12px rgba(123, 198, 255, 0.2);
+}
+
+@keyframes bounce {
+  0%,
+  80%,
+  100% {
+    transform: translateY(0);
+    opacity: 0.45;
+  }
+
+  40% {
+    transform: translateY(-6px);
+    opacity: 1;
+  }
+}
+
+@media (max-width: 720px) {
+  .shell {
+    padding: 22px 18px;
+    border-radius: 28px;
+  }
+
+  .header {
+    align-items: flex-start;
+  }
+
+  .header h1 {
+    max-width: none;
+  }
+
+  .chat {
+    padding: 14px;
+  }
+
+  .botBubble,
+  .userBubble {
+    max-width: 100%;
+  }
+
+  .composerRow {
+    flex-direction: column;
+  }
+
+  .sendButton {
+    width: 100%;
+  }
+}
diff --git a/examples/langchain-itinerary/src/app/itinerary.ts b/examples/langchain-itinerary/src/app/itinerary.ts
new file mode 100644
index 0000000..53e074f
--- /dev/null
+++ b/examples/langchain-itinerary/src/app/itinerary.ts
@@ -0,0 +1,325 @@
+import {
+  type AIMessage,
+  HumanMessage,
+  SystemMessage,
+  ToolMessage,
+  type ToolCall,
+} from "@langchain/core/messages";
+import { tool } from "@langchain/core/tools";
+import { ChatAnthropic } from "@langchain/anthropic";
+import { ChatOpenAI } from "@langchain/openai";
+import { trace, type Span } from "@opentelemetry/api";
+
+const SYSTEM_PROMPT =
+  "You are a helpful travel assistant. Use lookup_destination_highlights before giving destination recommendations.";
+
+const TOOL_NAME = "lookup_destination_highlights";
+const WIKIVOYAGE_API_URL = "https://en.wikivoyage.org/w/api.php";
+
+type ModelProvider = "anthropic" | "openai";
+type DestinationLookupArgs = {
+  destination: string;
+  interests?: string[];
+  trip_length_days?: number;
+};
+
+type WikivoyageSearchPage = {
+  pageid: number;
+  title: string;
+  extract?: string;
+  fullurl?: string;
+};
+
+type WikivoyageSearchResponse = {
+  query?: {
+    pages?: Record<string, WikivoyageSearchPage>;
+  };
+};
+
+function compactText(value: string, maxLength: number): string {
+  const compacted = value.replace(/\s+/g, " ").trim();
+  return compacted.length > maxLength ? `${compacted.slice(0, maxLength - 1).trim()}...` : compacted;
+}
+
+function searchQuery(destination: string, interests: string[]): string {
+  const interestText = interests.length > 0 ? ` ${interests.join(" ")}` : "";
+  return `${destination}${interestText} travel`;
+}
+
+async function fetchWikivoyagePages(
+  destination: string,
+  interests: string[]
+): Promise<WikivoyageSearchPage[]> {
+  const params = new URLSearchParams({
+    action: "query",
+    format: "json",
+    origin: "*",
+    generator: "search",
+    gsrsearch: searchQuery(destination, interests),
+    gsrlimit: "3",
+    prop: "extracts|info",
+    exintro: "1",
+    explaintext: "1",
+    inprop: "url",
+  });
+
+  const response = await fetch(`${WIKIVOYAGE_API_URL}?${params}`, {
+    signal: AbortSignal.timeout(5000),
+  });
+  if (!response.ok) {
+    throw new Error(`Wikivoyage returned ${response.status}`);
+  }
+
+  const data = (await response.json()) as WikivoyageSearchResponse;
+  return Object.values(data.query?.pages ?? {})
+    .filter((page) => page.extract)
+    .map((page) => ({
+      ...page,
+      extract: compactText(page.extract ?? "", 520),
+    }));
+}
+
+function localTravelContext(destination: string, interests: string[], tripLengthDays: number) {
+  const normalizedInterests = interests.length > 0 ? interests : ["food", "walkable neighborhoods", "local culture"];
+  const beerFocused = normalizedInterests.some((interest) =>
+    ["beer", "brewery", "breweries", "craft beer", "pubs"].some((term) =>
+      interest.toLowerCase().includes(term)
+    )
+  );
+
+  return {
+    planning_notes: [
+      `Plan ${destination} around compact neighborhood clusters instead of one-off sights.`,
+      `For ${tripLengthDays} day${tripLengthDays === 1 ? "" : "s"}, keep each day to one anchor area plus one flexible evening plan.`,
+      "Check opening days before locking the itinerary; small venues and museums often close early-week.",
+    ],
+    interest_angles: normalizedInterests.map((interest) => ({
+      interest,
+      angle: `${destination} works best when ${interest} stops are grouped near food, transit, or evening options.`,
+    })),
+    suggested_day_shape: [
+      "Late morning: one anchor sight or neighborhood walk.",
+      "Afternoon: food market, museum, waterfront, or park depending on weather.",
+      beerFocused
+        ? "Evening: two breweries or beer bars in the same district, with dinner between them."
+        : "Evening: dinner near the final stop so transit back is simple.",
+    ],
+    cautions: [
+      "Avoid over-planning cross-town hops.",
+      "Keep a backup indoor stop for bad weather.",
+      "Book destination restaurants, tours, and popular tasting rooms ahead when dates are fixed.",
+    ],
+  };
+}
+
+async function getDestinationHighlights({
+  destination,
+  interests = [],
+  trip_length_days,
+}: DestinationLookupArgs): Promise<string> {
+  const normalizedDestination = destination.trim() || "the requested destination";
+  const normalizedInterests = interests.map((interest) => interest.trim()).filter(Boolean);
+  const tripLengthDays = Math.max(1, Math.min(14, Math.round(trip_length_days ?? 3)));
+  let wikivoyagePages: WikivoyageSearchPage[] = [];
+  let sourceStatus = "live Wikivoyage lookup succeeded";
+
+  try {
+    wikivoyagePages = await fetchWikivoyagePages(normalizedDestination, normalizedInterests);
+  } catch (error) {
+    sourceStatus = `live Wikivoyage lookup failed: ${error instanceof Error ? error.message : String(error)}`;
+  }
+
+  return JSON.stringify({
+    destination: normalizedDestination,
+    interests: normalizedInterests,
+    trip_length_days: tripLengthDays,
+    source_status: sourceStatus,
+    external_sources: wikivoyagePages.map((page) => ({
+      title: page.title,
+      summary: page.extract,
+      url: page.fullurl,
+    })),
+    local_context: localTravelContext(normalizedDestination, normalizedInterests, tripLengthDays),
+  });
+}
+
+const lookupDestinationHighlights = tool(
+  async (args: DestinationLookupArgs) =>
+    getDestinationHighlights(args),
+  {
+    // The model sees this schema and decides the arguments for the tool call.
+    name: TOOL_NAME,
+    description:
+      "Look up destination context, travel planning angles, and source-backed highlights before making itinerary recommendations.",
+    schema: {
+      type: "object",
+      properties: {
+        destination: {
+          type: "string",
+          description:
+            "The destination city, region, country, or travel theme the user is asking about.",
+        },
+        interests: {
+          type: "array",
+          items: { type: "string" },
+          description:
+            "User interests to prioritize, such as beer, museums, food, hiking, nightlife, or budget travel.",
+        },
+        trip_length_days: {
+          type: "number",
+          description: "Approximate trip length in days when the user gives one.",
+        },
+      },
+      required: ["destination"],
+    },
+  }
+);
+
+function stringifyMessageContent(content: AIMessage["content"]) {
+  // Chat models can return plain text or structured content blocks; the UI only needs display text.
+  return typeof content === "string"
+    ? content
+    : content
+        .map((part) =>
+          part.type === "text" && "text" in part ? part.text ?? "" : ""
+        )
+        .join("")
+        .trim();
+}
+
+function stringifyToolMessageContent(content: ToolMessage["content"]): string {
+  return typeof content === "string" ? content : JSON.stringify(content);
+}
+
+async function withSpan<T>(name: string, fn: (span: Span) => Promise<T>): Promise<T> {
+  return trace.getTracer("langchain-itinerary-app").startActiveSpan(name, async (span) => {
+    try {
+      return await fn(span);
+    } finally {
+      span.end();
+    }
+  });
+}
+
+function selectedProvider(): ModelProvider {
+  const provider = (process.env.LANGCHAIN_MODEL_PROVIDER ?? "openai").toLowerCase();
+  if (provider === "openai" || provider === "anthropic") {
+    return provider;
+  }
+
+  throw new Error("LANGCHAIN_MODEL_PROVIDER must be either 'openai' or 'anthropic'.");
+}
+
+function requiredEnv(name: string): string {
+  const value = process.env[name]?.trim();
+  if (!value) {
+    throw new Error(`Missing ${name}. Add it to .env or export it before starting the app.`);
+  }
+  return value;
+}
+
+function selectedModel(provider: ModelProvider): string {
+  if (provider === "anthropic") {
+    return process.env.ANTHROPIC_MODEL ?? "claude-sonnet-4-6";
+  }
+
+  return process.env.OPENAI_MODEL ?? "gpt-4o-mini";
+}
+
+function anthropicThinkingEffort(): string | undefined {
+  return process.env.ANTHROPIC_THINKING?.trim() || undefined;
+}
+
+function createAnthropicChatModel(model: string) {
+  const thinking = anthropicThinkingEffort();
+  // @ts-expect-error Keep env values as provider pass-through; LangChain/Anthropic validates them.
+  return new ChatAnthropic({
+    apiKey: requiredEnv("ANTHROPIC_API_KEY"),
+    model,
+    ...(thinking
+      ? {
+          thinking: { type: "adaptive", display: "summarized" },
+          outputConfig: {
+            effort: thinking,
+          },
+        }
+      : {}),
+  });
+}
+
+function createOpenAIChatModel(model: string) {
+  return new ChatOpenAI({
+    apiKey: requiredEnv("OPENAI_API_KEY"),
+    model,
+  });
+}
+
+export async function runItineraryPrompt(input: string): Promise<string> {
+  const provider = selectedProvider();
+  const model = selectedModel(provider);
+
+  let llm: ChatAnthropic | ChatOpenAI;
+  let llmWithTools:
+    | ReturnType<ChatAnthropic["bindTools"]>
+    | ReturnType<ChatOpenAI["bindTools"]>;
+
+  if (provider === "anthropic") {
+    llm = createAnthropicChatModel(model);
+    llmWithTools = llm.bindTools([lookupDestinationHighlights]);
+  } else {
+    llm = createOpenAIChatModel(model);
+    llmWithTools = llm.bindTools([lookupDestinationHighlights], {
+      // Force the first turn to produce a tool call so the demo always exercises tool tracing.
+      tool_choice: {
+        type: "function",
+        function: { name: TOOL_NAME },
+      },
+    });
+  }
+
+  const messages = [new SystemMessage(SYSTEM_PROMPT), new HumanMessage(input)];
+
+  // First LLM call: ask the model to select and populate the destination lookup tool.
+  const toolCallResult = await withSpan("itinerary.llm.tool_selection", () =>
+    llmWithTools.invoke(messages)
+  );
+  const toolCalls = toolCallResult.tool_calls ?? [];
+
+  if (toolCalls.length === 0) {
+    return stringifyMessageContent(toolCallResult.content);
+  }
+
+  const toolMessages = await Promise.all(
+    toolCalls.map(async (toolCall) => {
+      const toolResult = await withSpan("itinerary.tool.lookup_destination_highlights", () =>
+        (
+          lookupDestinationHighlights as unknown as {
+            invoke(call: ToolCall): Promise<string | ToolMessage>;
+          }
+        ).invoke(toolCall)
+      );
+
+      return ToolMessage.isInstance(toolResult)
+        ? toolResult
+        : new ToolMessage({
+            content: stringifyToolMessageContent(toolResult),
+            tool_call_id: toolCall.id ?? "",
+            name: toolCall.name,
+          });
+    })
+  );
+
+  const followupMessages = [
+    ...messages,
+    toolCallResult,
+    ...toolMessages,
+    new HumanMessage("Use the tool result to answer the original request concisely."),
+  ];
+
+  // Second LLM call: feed the tool response back to the model and record the final user-facing answer.
+  const result = await withSpan("itinerary.llm.followup", () =>
+    llm.invoke(followupMessages)
+  );
+
+  return stringifyMessageContent(result.content);
+}
diff --git a/examples/langchain-itinerary/src/app/layout.tsx b/examples/langchain-itinerary/src/app/layout.tsx
new file mode 100644
index 0000000..b2587c4
--- /dev/null
+++ b/examples/langchain-itinerary/src/app/layout.tsx
@@ -0,0 +1,19 @@
+import type { Metadata } from "next";
+import "./globals.css";
+
+export const metadata: Metadata = {
+  title: "Pocket Trip Pal",
+  description: "A tiny quirky chat interface for itinerary daydreaming.",
+};
+
+export default function RootLayout({
+  children,
+}: Readonly<{
+  children: React.ReactNode;
+}>) {
+  return (
+    <html lang="en">
+      <body>{children}</body>
+    </html>
+  );
+}
diff --git a/examples/langchain-itinerary/src/app/page.tsx b/examples/langchain-itinerary/src/app/page.tsx
new file mode 100644
index 0000000..02751a9
--- /dev/null
+++ b/examples/langchain-itinerary/src/app/page.tsx
@@ -0,0 +1,21 @@
+import { ChatClient } from "./chat-client";
+
+export default function Home() {
+  return (
+    <main className="page">
+      <section className="shell">
+        <div className="header">
+          <p className="eyebrow">Pocket Trip Pal</p>
+          <h1>Chatty itinerary doodler</h1>
+        </div>
+
+        <p className="subtitle">
+          In-memory chat with server-side LangChain calls through a traced API route.
+        </p>
+
+        {/* Client state is isolated here; secrets, tools, and tracing stay on the server route. */}
+        <ChatClient />
+      </section>
+    </main>
+  );
+}
diff --git a/examples/langchain-itinerary/src/instrumentation.ts b/examples/langchain-itinerary/src/instrumentation.ts
new file mode 100644
index 0000000..8fb2cda
--- /dev/null
+++ b/examples/langchain-itinerary/src/instrumentation.ts
@@ -0,0 +1,49 @@
+import { context, trace } from "@opentelemetry/api";
+import { AsyncLocalStorageContextManager } from "@opentelemetry/context-async-hooks";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
+import { BasicTracerProvider, BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { initializeOTEL } from "langsmith/experimental/otel/setup";
+
+export async function register() {
+  if (process.env.NEXT_RUNTIME === "edge") {
+    return;
+  }
+
+  // Next.js calls this once per server runtime; skip tracing entirely unless an OTLP sink is configured.
+  if (!process.env.OTEL_EXPORTER_OTLP_ENDPOINT) {
+    return;
+  }
+
+  // Dev reloads can evaluate this module more than once, but OTEL globals can only be set once.
+  if ((globalThis as { __otelInitialized?: boolean }).__otelInitialized) {
+    return;
+  }
+
+  // PromptLayer accepts the API key as an OTLP header; normalize the env var into the exporter shape.
+  const promptLayerApiKey = process.env.OTEL_EXPORTER_OTLP_HEADERS
+    ?.replace("X-API-KEY=", "")
+    .trim();
+  const headers: Record<string, string> | undefined = promptLayerApiKey
+    ? { "X-API-KEY": promptLayerApiKey }
+    : undefined;
+
+  const exporter = new OTLPTraceExporter({
+    url: process.env.OTEL_EXPORTER_OTLP_ENDPOINT,
+    headers,
+  });
+  const provider = new BasicTracerProvider({
+    spanProcessors: [new BatchSpanProcessor(exporter)],
+  });
+  const contextManager = new AsyncLocalStorageContextManager();
+  contextManager.enable();
+  // The context manager keeps manually-created spans parented to the LangChain request flow.
+  context.setGlobalContextManager(contextManager);
+  trace.setGlobalTracerProvider(provider);
+  // LangSmith's OTEL bridge translates LangChain callback runs into OTEL spans on this provider.
+  initializeOTEL({
+    globalTracerProvider: provider,
+    globalContextManager: contextManager,
+    skipGlobalContextManagerSetup: true,
+  });
+  (globalThis as { __otelInitialized?: boolean }).__otelInitialized = true;
+}
diff --git a/examples/langchain-itinerary/tsconfig.json b/examples/langchain-itinerary/tsconfig.json
new file mode 100644
index 0000000..cf9c65d
--- /dev/null
+++ b/examples/langchain-itinerary/tsconfig.json
@@ -0,0 +1,34 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts",
+    "**/*.mts"
+  ],
+  "exclude": ["node_modules"]
+}
diff --git a/examples/openai-agents-sdk/.env.example b/examples/openai-agents-sdk/.env.example
new file mode 100644
index 0000000..0fbfd7f
--- /dev/null
+++ b/examples/openai-agents-sdk/.env.example
@@ -0,0 +1,8 @@
+# Required for OpenAI API calls.
+OPENAI_API_KEY=
+
+# Required for PromptLayer tracing.
+PROMPTLAYER_API_KEY=
+
+# Optional. Defaults to gpt-5.
+OPENAI_MODEL=gpt-5
diff --git a/examples/openai-agents-sdk/.gitignore b/examples/openai-agents-sdk/.gitignore
new file mode 100644
index 0000000..5a4d2e5
--- /dev/null
+++ b/examples/openai-agents-sdk/.gitignore
@@ -0,0 +1,24 @@
+.env
+.env.*
+!.env.example
+
+.venv/
+venv/
+env/
+
+__pycache__/
+*.py[cod]
+*.egg-info/
+build/
+dist/
+
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.coverage
+htmlcov/
+uv.lock
+
+.DS_Store
+.idea/
+.vscode/
diff --git a/examples/openai-agents-sdk/README.md b/examples/openai-agents-sdk/README.md
new file mode 100644
index 0000000..f16b2e3
--- /dev/null
+++ b/examples/openai-agents-sdk/README.md
@@ -0,0 +1,50 @@
+# PromptLayer OpenAI Agents SDK Example
+
+Minimal CLI example using PromptLayer's OpenAI Agents SDK tracing integration.
+
+This example follows the PromptLayer OpenAI Agents SDK integration pattern and exports traces to `https://api.promptlayer.com/v1/traces`:
+
+```python
+from agents import Agent, Runner
+from promptlayer.integrations.openai_agents import instrument_openai_agents
+
+processor = instrument_openai_agents()
+
+agent = Agent(
+    name="PromptLayer Demo Agent",
+    instructions="You are concise and practical.",
+    model="gpt-5",
+)
+
+result = await Runner.run(agent, "Say hello.")
+processor.force_flush()
+```
+
+## Setup
+
+```bash
+cd examples/openai-agents-sdk
+python -m venv .venv
+source .venv/bin/activate
+pip install -e .
+cp .env.example .env
+```
+
+Edit `.env`, then run:
+
+```bash
+python main.py
+```
+
+You can also pass a custom message:
+
+```bash
+python main.py "What is the weather in Tokyo?"
+```
+
+## Notes
+
+- `instrument_openai_agents()` must run before the first agent run.
+- `force_flush()` sends buffered spans to PromptLayer before the request returns.
+- The demo includes `get_demo_weather` and `embed_text` function tools, so tool-call spans are easy to trigger.
+- `embed_text` calls the OpenAI embeddings API with `text-embedding-3-small`. The OpenAI Agents SDK currently surfaces that work as a function-tool span, not as a separate native embedding span.
diff --git a/examples/openai-agents-sdk/main.py b/examples/openai-agents-sdk/main.py
new file mode 100644
index 0000000..a875047
--- /dev/null
+++ b/examples/openai-agents-sdk/main.py
@@ -0,0 +1,103 @@
+import asyncio
+import os
+from argparse import ArgumentParser
+
+from agents import Agent, ModelSettings, Runner, function_tool
+from dotenv import load_dotenv
+from openai import OpenAI
+from openai.types.shared.reasoning import Reasoning
+from promptlayer.integrations.openai_agents import instrument_openai_agents
+
+
+DEFAULT_MODEL = "gpt-5"
+DEFAULT_MESSAGE = (
+    "Use the embedding tool to embed exactly this text: "
+    "PromptLayer OpenAI embedding trace probe. Then report the embedding "
+    "dimensions and token count."
+)
+EMBEDDING_MODEL = "text-embedding-3-small"
+
+openai_client = OpenAI()
+
+
+@function_tool
+def get_demo_weather(city: str) -> str:
+    """Return demo weather for a city."""
+    forecasts = {
+        "new york": "New York is 61F and cloudy.",
+        "san francisco": "San Francisco is 58F and breezy.",
+        "tokyo": "Tokyo is 72F with light rain.",
+        "london": "London is 55F and overcast.",
+    }
+    return forecasts.get(city.strip().lower(), f"{city} is 68F and clear in the demo forecast.")
+
+
+@function_tool
+def embed_text(text: str) -> str:
+    """Embed text with OpenAI embeddings and return metadata about the result."""
+    response = openai_client.embeddings.create(
+        model=EMBEDDING_MODEL,
+        input=text,
+    )
+    embedding = response.data[0].embedding
+    return (
+        f"embedding model: {response.model}; "
+        f"dimensions: {len(embedding)}; "
+        f"prompt tokens: {response.usage.prompt_tokens}"
+    )
+
+
+def required_env(name: str) -> str:
+    value = os.getenv(name, "").strip()
+    if not value:
+        raise RuntimeError(f"Missing {name}. Add it to .env or export it.")
+    return value
+
+
+async def run_agent(message: str) -> str:
+    required_env("OPENAI_API_KEY")
+    required_env("PROMPTLAYER_API_KEY")
+
+    processor = instrument_openai_agents()
+    model = os.getenv("OPENAI_MODEL", DEFAULT_MODEL)
+    agent = Agent(
+        name="PromptLayer Demo Agent",
+        instructions=(
+            "You are concise and practical. "
+            "If the user asks for weather, call get_demo_weather before answering. "
+            "If the user asks to embed text or asks about embedding metadata, call embed_text before answering."
+        ),
+        model=model,
+        model_settings=ModelSettings(
+            reasoning=Reasoning(summary="auto"),
+            response_include=["reasoning.encrypted_content"],
+        ),
+        tools=[get_demo_weather, embed_text],
+    )
+
+    try:
+        result = await Runner.run(agent, message)
+        return str(result.final_output)
+    finally:
+        processor.force_flush()
+        processor.shutdown()
+
+
+def parse_args() -> str:
+    parser = ArgumentParser(description="Run an OpenAI Agents SDK example with PromptLayer tracing.")
+    parser.add_argument(
+        "message",
+        nargs="?",
+        default=DEFAULT_MESSAGE,
+        help="Message to send to the agent.",
+    )
+    return parser.parse_args().message
+
+
+def main() -> None:
+    load_dotenv()
+    print(asyncio.run(run_agent(parse_args())))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/openai-agents-sdk/pyproject.toml b/examples/openai-agents-sdk/pyproject.toml
new file mode 100644
index 0000000..a4f1caa
--- /dev/null
+++ b/examples/openai-agents-sdk/pyproject.toml
@@ -0,0 +1,16 @@
+[project]
+name = "promptlayer-openai-agents-example"
+version = "0.1.0"
+description = "Minimal PromptLayer OpenAI Agents SDK tracing example"
+requires-python = ">=3.9"
+dependencies = [
+    "promptlayer[openai-agents]",
+    "python-dotenv>=1.2.0",
+]
+
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+py-modules = ["main"]
diff --git a/examples/pydantic-ai-chat/.env.example b/examples/pydantic-ai-chat/.env.example
new file mode 100644
index 0000000..fb78200
--- /dev/null
+++ b/examples/pydantic-ai-chat/.env.example
@@ -0,0 +1,17 @@
+# Required for Anthropic model calls.
+ANTHROPIC_API_KEY=
+
+# Required for OpenAI model calls and the default embeddings demo.
+OPENAI_API_KEY=
+
+# Required for PromptLayer OTLP trace export.
+PROMPTLAYER_API_KEY=
+OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=https://api.promptlayer.com/v1/traces
+
+# Optional defaults.
+OTEL_SERVICE_NAME=pydantic-ai-promptlayer-demo
+PYDANTIC_AI_MODEL=anthropic:claude-sonnet-4-6
+PYDANTIC_AI_THINKING=medium
+PYDANTIC_AI_EMBEDDING_MODEL=openai:text-embedding-3-small
+SEND_TO_LOGFIRE=false
+ENABLE_HTTPX_CAPTURE=false
diff --git a/examples/pydantic-ai-chat/.gitignore b/examples/pydantic-ai-chat/.gitignore
new file mode 100644
index 0000000..cfeae31
--- /dev/null
+++ b/examples/pydantic-ai-chat/.gitignore
@@ -0,0 +1,9 @@
+.env
+.venv/
+uv.lock
+__pycache__/
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.coverage
+htmlcov/
diff --git a/examples/pydantic-ai-chat/README.md b/examples/pydantic-ai-chat/README.md
new file mode 100644
index 0000000..943f978
--- /dev/null
+++ b/examples/pydantic-ai-chat/README.md
@@ -0,0 +1,100 @@
+# Pydantic AI Chat App With PromptLayer OTel
+
+Minimal local Pydantic AI web chat app that forwards Pydantic AI OpenTelemetry traces to PromptLayer.
+
+## Structure
+
+- `app.py` defines the chat agent, weather tool, dynamic embedding context, and telemetry setup.
+- `embeddings.py` contains the native Pydantic AI embeddings demo.
+
+## Stack
+
+- Python 3.11+
+- `uv`
+- `pydantic-ai-slim[web,openai,anthropic,logfire]`
+- `logfire`
+- OpenTelemetry OTLP HTTP exporter
+- PromptLayer OTLP ingest
+
+## Setup
+
+```bash
+cp .env.example .env
+```
+
+Fill in:
+
+- `ANTHROPIC_API_KEY` for the default Anthropic chat model
+- `OPENAI_API_KEY` for OpenAI chat models and the default embeddings demo
+- `PROMPTLAYER_API_KEY`
+- `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=https://api.promptlayer.com/v1/traces`
+- `SEND_TO_LOGFIRE=true` if you also want to send traces to Logfire
+- `PYDANTIC_AI_MODEL` to choose a Pydantic AI model
+- `PYDANTIC_AI_THINKING` to control reasoning effort
+- `PYDANTIC_AI_EMBEDDING_MODEL` if you want to override the embeddings demo model
+
+The app validates the API key that matches `PYDANTIC_AI_MODEL`. For example,
+`anthropic:*` requires `ANTHROPIC_API_KEY`, while `openai:*`,
+`openai-chat:*`, and `openai-responses:*` require `OPENAI_API_KEY`.
+
+Install dependencies:
+
+```bash
+uv sync
+```
+
+Run the local web chat:
+
+```bash
+uv run uvicorn app:app --port 7932
+```
+
+Open the local URL printed by Uvicorn.
+
+## Telemetry
+
+By default, the app forwards Pydantic AI OpenTelemetry traces to PromptLayer at `https://api.promptlayer.com/v1/traces` when these env vars are configured:
+
+- `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=https://api.promptlayer.com/v1/traces`
+- `OTEL_EXPORTER_OTLP_HEADERS=X-API-KEY=<PROMPTLAYER_API_KEY>`
+- `OTEL_SERVICE_NAME=pydantic-ai-promptlayer-demo`
+
+Logfire export is optional. To also send traces to Logfire, set this in `.env`:
+
+```bash
+SEND_TO_LOGFIRE=true
+```
+
+Leave `SEND_TO_LOGFIRE` unset to skip Logfire export.
+
+Then authenticate locally:
+
+```bash
+uv run logfire auth
+```
+
+PromptLayer should show a trace after you send a chat message. Tool calls appear as child spans when the model invokes `get_weather`.
+
+## Embeddings Demo
+
+To see how native embeddings appear inside an agent run without using a tool, send a question like this:
+
+```text
+Use embeddings to find the local demo topic closest to "how are traces exported to PromptLayer?"
+```
+
+```text
+Use embeddings to search for "what part of the demo uses tools?"
+```
+
+```text
+Use embeddings to find the closest topic for "how does semantic search compare text?"
+```
+
+PromptLayer should show the agent run with native Pydantic AI embedding spans and the chat model span. The embedding spans use `gen_ai.operation.name=embeddings`.
+
+Raw HTTP capture is disabled by default because it can include prompt and response content. Enable it only when you need provider-level request debugging:
+
+```bash
+ENABLE_HTTPX_CAPTURE=true uv run uvicorn app:app --port 7932
+```
diff --git a/examples/pydantic-ai-chat/app.py b/examples/pydantic-ai-chat/app.py
new file mode 100644
index 0000000..edfc708
--- /dev/null
+++ b/examples/pydantic-ai-chat/app.py
@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+"""Local Pydantic AI web app wired to PromptLayer through OpenTelemetry."""
+
+import os
+from pathlib import Path
+
+import logfire
+from dotenv import load_dotenv
+from opentelemetry import trace
+from pydantic_ai import Agent, RunContext
+from pydantic_ai.models import parse_model_id
+
+from embeddings import search_demo_embeddings
+
+
+PROMPTLAYER_SERVICE_NAME = "pydantic-ai-promptlayer-demo"
+PROMPTLAYER_TRACE_ENDPOINT = "https://api.promptlayer.com/v1/traces"
+BASE_DIR = Path(__file__).resolve().parent
+ENV_FILE = BASE_DIR / ".env"
+TRUTHY = {"1", "true", "yes"}
+FALSY = {"0", "false", "no"}
+THINKING_LEVELS = {"minimal", "low", "medium", "high", "xhigh"}
+MODEL_API_KEYS = {
+    "anthropic": ("ANTHROPIC_API_KEY",),
+    "openai": ("OPENAI_API_KEY",),
+    "openai-chat": ("OPENAI_API_KEY",),
+    "openai-responses": ("OPENAI_API_KEY",),
+}
+
+
+load_dotenv(dotenv_path=ENV_FILE, override=True)
+
+
+def env_enabled(name: str) -> bool:
+    return os.getenv(name, "").lower() in TRUTHY
+
+
+def required_env(name: str) -> str:
+    value = os.getenv(name, "").strip()
+    if not value:
+        raise RuntimeError(f"Missing {name}. Add it to {ENV_FILE} or export it.")
+    return value
+
+
+def thinking_setting() -> dict[str, bool | str]:
+    """Configure model reasoning through Pydantic AI's unified thinking setting."""
+    raw_value = required_env("PYDANTIC_AI_THINKING").lower()
+    if raw_value in TRUTHY:
+        return {"thinking": True}
+    if raw_value in FALSY:
+        return {"thinking": False}
+    if raw_value in THINKING_LEVELS:
+        return {"thinking": raw_value}
+    raise ValueError(
+        "PYDANTIC_AI_THINKING must be one of: true, false, "
+        f"{', '.join(sorted(THINKING_LEVELS))}"
+    )
+
+
+def selected_model() -> str:
+    return required_env("PYDANTIC_AI_MODEL")
+
+
+def validate_model_api_key(model: str) -> None:
+    provider, _model_name = parse_model_id(model)
+    if provider is None:
+        raise ValueError(
+            f"Could not infer provider for PYDANTIC_AI_MODEL={model!r}. "
+            "Use an explicit provider prefix like 'anthropic:' or 'openai:'."
+        )
+
+    required_keys = MODEL_API_KEYS.get(provider)
+    if not required_keys or any(os.getenv(key) for key in required_keys):
+        return
+
+    formatted_keys = " or ".join(required_keys)
+    raise ValueError(
+        f"PYDANTIC_AI_MODEL={model!r} uses provider {provider!r}, "
+        f"so set {formatted_keys} in {ENV_FILE} or your shell environment."
+    )
+
+
+def configure_telemetry() -> None:
+    """Configure Pydantic AI instrumentation for PromptLayer and optional Logfire export."""
+    if promptlayer_api_key := os.getenv("PROMPTLAYER_API_KEY"):
+        os.environ.setdefault(
+            "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT",
+            PROMPTLAYER_TRACE_ENDPOINT,
+        )
+        os.environ.setdefault(
+            "OTEL_EXPORTER_OTLP_HEADERS",
+            f"X-API-KEY={promptlayer_api_key}",
+        )
+        os.environ.setdefault(
+            "OTEL_SERVICE_NAME",
+            PROMPTLAYER_SERVICE_NAME,
+        )
+
+    logfire.configure(send_to_logfire=env_enabled("SEND_TO_LOGFIRE"))
+    logfire.instrument_pydantic_ai()
+
+    if env_enabled("ENABLE_HTTPX_CAPTURE"):
+        logfire.instrument_httpx(capture_all=True)
+
+
+configure_telemetry()
+MODEL = selected_model()
+validate_model_api_key(MODEL)
+
+agent = Agent(
+    MODEL,
+    model_settings=thinking_setting(),
+    instructions=(
+        "You are a concise local demo assistant. Use tools when they help, "
+        "and keep answers practical."
+    ),
+)
+
+
+@agent.tool
+def get_weather(_ctx: RunContext[None], city: str) -> str:
+    """Tiny demo tool that tags its span with PromptLayer prompt metadata."""
+    span = trace.get_current_span()
+    span.set_attribute("promptlayer.prompt.name", "pydantic-chat-weather-demo")
+    span.set_attribute("promptlayer.prompt.label", "development")
+    return f"The weather in {city} is sunny and 72F."
+
+
+@agent.instructions
+async def embedding_context(ctx: RunContext[None]) -> str:
+    """Inject semantic-search context when the user asks about embeddings."""
+    if not isinstance(ctx.prompt, str) or "embedding" not in ctx.prompt.lower():
+        return ""
+
+    result = await search_demo_embeddings(ctx.prompt)
+    return (
+        "Embedding demo context: the user's prompt is closest to "
+        f"{result.matched_item.title!r} with similarity {result.similarity:.3f}. "
+        f"Topic text: {result.matched_item.text}"
+    )
+
+
+app = agent.to_web(
+    instructions=(
+        "This is a local development chat app. If the user asks about weather, "
+        "call the weather tool. If embedding demo context is available, use it "
+        "to answer the user."
+    )
+)
diff --git a/examples/pydantic-ai-chat/embeddings.py b/examples/pydantic-ai-chat/embeddings.py
new file mode 100644
index 0000000..556270c
--- /dev/null
+++ b/examples/pydantic-ai-chat/embeddings.py
@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+"""Small native Pydantic AI embeddings demo used by the chat agent."""
+
+import os
+from collections.abc import Sequence
+
+from pydantic import BaseModel, Field
+from pydantic_ai import Embedder
+
+
+DEFAULT_EMBEDDING_MODEL = "openai:text-embedding-3-small"
+
+
+class DemoKnowledgeItem(BaseModel):
+    id: str
+    title: str
+    text: str
+
+
+class EmbeddingSearchResult(BaseModel):
+    query: str
+    matched_item: DemoKnowledgeItem
+    similarity: float = Field(ge=-1, le=1)
+    embedding_model: str
+    embedded_document_count: int
+
+
+DEMO_KNOWLEDGE_ITEMS = (
+    DemoKnowledgeItem(
+        id="telemetry",
+        title="OpenTelemetry export",
+        text=(
+            "This app configures Pydantic AI instrumentation and exports "
+            "OpenTelemetry traces to PromptLayer through OTLP."
+        ),
+    ),
+    DemoKnowledgeItem(
+        id="weather_tool",
+        title="Weather tool",
+        text=(
+            "The weather tool is an agent tool that adds PromptLayer prompt "
+            "metadata to the current span and returns demo weather."
+        ),
+    ),
+    DemoKnowledgeItem(
+        id="embeddings",
+        title="Embedding search",
+        text=(
+            "Embedding search converts text into vectors, compares vectors with "
+            "cosine similarity, and finds semantically related content."
+        ),
+    ),
+)
+
+
+_embedder: Embedder | None = None
+
+
+def get_embedder() -> Embedder:
+    """Create the instrumented embedder lazily so env vars load before use."""
+    global _embedder
+
+    if _embedder is None:
+        _embedder = Embedder(
+            os.getenv("PYDANTIC_AI_EMBEDDING_MODEL", DEFAULT_EMBEDDING_MODEL),
+            instrument=True,
+        )
+
+    return _embedder
+
+
+def cosine_similarity(left: Sequence[float], right: Sequence[float]) -> float:
+    dot_product = sum(a * b for a, b in zip(left, right))
+    left_norm = sum(value * value for value in left) ** 0.5
+    right_norm = sum(value * value for value in right) ** 0.5
+    if left_norm == 0 or right_norm == 0:
+        return 0
+    return dot_product / (left_norm * right_norm)
+
+
+async def search_demo_embeddings(query: str) -> EmbeddingSearchResult:
+    """Embed the query and local demo topics, then return the closest topic."""
+    embedder = get_embedder()
+    query_result = await embedder.embed_query(query)
+    documents_result = await embedder.embed_documents([item.text for item in DEMO_KNOWLEDGE_ITEMS])
+    query_embedding = query_result.embeddings[0]
+
+    scored_items = [
+        (cosine_similarity(query_embedding, document_embedding), item)
+        for item, document_embedding in zip(DEMO_KNOWLEDGE_ITEMS, documents_result.embeddings)
+    ]
+    similarity, matched_item = max(scored_items, key=lambda scored_item: scored_item[0])
+
+    return EmbeddingSearchResult(
+        query=query,
+        matched_item=matched_item,
+        similarity=similarity,
+        embedding_model=query_result.model_name,
+        embedded_document_count=len(DEMO_KNOWLEDGE_ITEMS),
+    )
diff --git a/examples/pydantic-ai-chat/pyproject.toml b/examples/pydantic-ai-chat/pyproject.toml
new file mode 100644
index 0000000..1c93270
--- /dev/null
+++ b/examples/pydantic-ai-chat/pyproject.toml
@@ -0,0 +1,15 @@
+[project]
+name = "pydantic-ai-chat"
+version = "0.1.0"
+description = "Minimal Pydantic AI web chat app exporting OpenTelemetry traces to PromptLayer."
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "logfire>=4.15.1",
+    "opentelemetry-exporter-otlp-proto-http>=1.38.0",
+    "pydantic-ai-slim[anthropic,logfire,openai,web]>=1.25.0",
+    "python-dotenv>=1.2.1",
+]
+
+[tool.uv]
+package = false
diff --git a/features/integrations.mdx b/features/integrations.mdx
index 15484ba..0b3114d 100644
--- a/features/integrations.mdx
+++ b/features/integrations.mdx
@@ -113,6 +113,60 @@ Once configured, PromptLayer will capture Claude Code sessions, LLM calls, tool
 
 For troubleshooting and additional details on the direct plugin install path, see the [PromptLayer Claude Code plugin repository](https://github.com/MagnivOrg/promptlayer-claude-plugins).
 
+## OpenAI Agents SDK
+
+PromptLayer supports the OpenAI Agents SDK in both [JavaScript](https://openai.github.io/openai-agents-js/) and [Python](https://openai.github.io/openai-agents-python/), allowing you to export agent traces directly to PromptLayer with a native PromptLayer trace processor.
+
+To set up:
+
+1. Install the required packages
+
+<CodeGroup>
+```bash JavaScript
+npm install promptlayer @openai/agents
+```
+
+```bash Python
+pip install "promptlayer[openai-agents]"
+```
+</CodeGroup>
+
+2. Register PromptLayer tracing before your first agent run:
+
+<CodeGroup>
+```ts JavaScript
+import { instrumentOpenAIAgents } from "promptlayer/openai-agents";
+
+const processor = await instrumentOpenAIAgents();
+```
+
+```python Python
+from promptlayer.integrations.openai_agents import instrument_openai_agents
+
+instrument_openai_agents()
+```
+</CodeGroup>
+
+3. Flush tracing before process exit so PromptLayer receives the final spans:
+
+<CodeGroup>
+```ts JavaScript
+await processor.forceFlush();
+await processor.shutdown();
+```
+
+```python Python
+# Optional - if you created your own tracer provider
+tracer_provider.force_flush()
+tracer_provider.shutdown()
+```
+</CodeGroup>
+
+4. Set your environment variables:
+
+- `OPENAI_API_KEY`
+- `PROMPTLAYER_API_KEY`
+
 ## Vercel AI SDK
 
 PromptLayer supports integration with the [Vercel AI SDK](https://ai-sdk.dev/docs), allowing you to export OpenTelemetry traces from your application directly to PromptLayer.
@@ -206,7 +260,7 @@ Once configured, PromptLayer will capture Pydantic AI agent runs, LLM calls, too
 
 PromptLayer supports ingesting [LangChain](https://js.langchain.com/) traces through [LangSmith's OpenTelemetry bridge](https://docs.langchain.com/langsmith/trace-with-opentelemetry). For new JavaScript applications where you can choose the framework, use the [Vercel AI SDK](#vercel-ai-sdk) integration because its OpenTelemetry spans map more directly into PromptLayer. This is also aligned with LangChain / LangSmith's JavaScript observability path: their docs provide a first-party [Vercel AI SDK tracing guide](https://docs.langchain.com/langsmith/trace-with-vercel-ai-sdk). Use this LangChain / LangSmith path when you already have a LangChain application.
 
-LangChain's native spans can be sparse or framework-shaped rather than LLM-call-shaped. For best PromptLayer results, add manual child spans around important route, LLM, and tool boundaries and include GenAI attributes such as `gen_ai.operation.name`, `gen_ai.system`, `gen_ai.request.model`, `gen_ai.prompt`, and `gen_ai.completion`.
+LangSmith's OTEL bridge creates LangChain spans automatically. Add manual spans for application-specific work, custom tool data, or extra inputs and outputs that should appear in PromptLayer traces.
 
 To set up:
 
@@ -263,83 +317,27 @@ initializeOTEL({
 });
 ```
 
-4. Add manual spans for LLM and tool boundaries when you need request logs to be complete
+4. Optionally add manual spans for application-specific data
 
 ```ts
 import { trace } from "@opentelemetry/api";
 
-await trace.getTracer("langchain-app").startActiveSpan("myapp.llm.call", async (span) => {
+await trace.getTracer("langchain-app").startActiveSpan("app.workflow_step", async (span) => {
   try {
-    span.setAttribute("langsmith.span.kind", "llm");
-    span.setAttribute("gen_ai.operation.name", "chat");
-    span.setAttribute("gen_ai.system", "openai");
-    span.setAttribute("gen_ai.request.model", "gpt-4o-mini");
-    span.setAttribute("gen_ai.prompt", JSON.stringify(messages));
+    span.setAttribute("app.operation", "retrieve_context");
+    span.setAttribute("app.input", JSON.stringify(input));
 
-    const result = await llm.invoke(messages);
+    const result = await runApplicationStep(input);
 
-    span.setAttribute("gen_ai.completion", String(result.content));
+    span.setAttribute("app.result_count", result.items.length);
+    return result;
   } finally {
     span.end();
   }
 });
 ```
 
-Once configured, PromptLayer will capture LangChain and LangSmith spans. Manual GenAI attributes make LLM calls, tool calls, inputs, and outputs easier for PromptLayer to render as request logs. Thinking blocks from extended thinking models in LangChain completions are captured and preserved in the request log view.
-
-## OpenAI Agents SDK
-
-PromptLayer supports the OpenAI Agents SDK in both [JavaScript](https://openai.github.io/openai-agents-js/) and [Python](https://openai.github.io/openai-agents-python/), allowing you to export agent traces directly to PromptLayer with a native PromptLayer trace processor.
-
-To set up:
-
-1. Install the required packages
-
-<CodeGroup>
-```bash JavaScript
-npm install promptlayer @openai/agents
-```
-
-```bash Python
-pip install "promptlayer[openai-agents]"
-```
-</CodeGroup>
-
-2. Register PromptLayer tracing before your first agent run:
-
-<CodeGroup>
-```ts JavaScript
-import { instrumentOpenAIAgents } from "promptlayer/openai-agents";
-
-const processor = await instrumentOpenAIAgents();
-```
-
-```python Python
-from promptlayer.integrations.openai_agents import instrument_openai_agents
-
-instrument_openai_agents()
-```
-</CodeGroup>
-
-3. Flush tracing before process exit so PromptLayer receives the final spans:
-
-<CodeGroup>
-```ts JavaScript
-await processor.forceFlush();
-await processor.shutdown();
-```
-
-```python Python
-# Optional - if you created your own tracer provider
-tracer_provider.force_flush()
-tracer_provider.shutdown()
-```
-</CodeGroup>
-
-4. Set your environment variables:
-
-- `OPENAI_API_KEY`
-- `PROMPTLAYER_API_KEY`
+Once configured, PromptLayer will capture LangChain and LangSmith spans. PromptLayer renders request logs from LangSmith and LangChain LLM attributes, including model metadata, messages, outputs, token counts, and thinking blocks from extended thinking models.
 
 ## OpenRouter