VERDANT SDK

from verdant import VerdantClient
import openai

client = VerdantClient(api_key="vd_live_...")

result = await client.wrap(
    fn=openai.chat.completions.create,
    context_type="hiring",
    input_text=user_prompt,
    model="gpt-4o",
    messages=[{"role": "user", "content": user_prompt}],
)

# Pass to your product
print(result.output)        # Clean AI response for your user
print(result.trust_score)   # 0–100 composite score
print(result.flags)         # ["proxy_language_detected"]
print(result.explanation)   # "Role phrasing may disadvantage..."
print(result.audit)         # Full reasoning chain JSON

from verdant import VerdantClient

# Just your VERDANT key. Provider keys (Claude, Gemini) live server-side —
# managed from the dashboard Settings page.
client = VerdantClient(api_key="vd_live_...")

# run() executes the pipeline on the hosted API over HTTP and returns the
# same result object as wrap().
result = await client.run(
    context_type="hiring",
    input_text="Should we shortlist this candidate from Kano?",
)

print(result.output)        # Response generated server-side
print(result.trust_score)   # 0–100 composite score
print(result.flags)         # ["proxy_language_detected"]
print(result.explanation)   # Plain-language rationale

result = await client.wrap(fn=my_ai_call, context_type="hiring", ...)
audit = result.audit

# Top-level audit fields
audit.request_id       # UUID — unique per pipeline run
audit.created_at       # UTC timestamp
audit.context_type     # "hiring", "lending", etc.
audit.input_text       # The input you provided
audit.output_text      # Stringified AI output
audit.model_name       # "claude-sonnet-4-6"
audit.duration_ms      # Pipeline execution time
audit.error            # None if successful, error string if failed

# Per-stage outputs
audit.stages.intent.detected_intent     # e.g. "candidate_evaluation"
audit.stages.intent.confidence          # 0.0–1.0
audit.stages.baseline.baseline_name     # e.g. "ng_hiring_v3"
audit.stages.baseline.baseline_version  # e.g. "3.1"
audit.stages.bias.severity              # "low" | "medium" | "high" | "critical"
audit.stages.bias.matched_patterns      # ["proxy_language", ...]
audit.stages.explanation.caveats        # ["Limited context provided", ...]
audit.stages.trust.score_breakdown      # {"bias": 38.0, "explanation": 28.5, ...}
audit.stages.trust.risk_level           # "low" | "medium" | "high" | "critical"

from verdant import VerdantClient

client = VerdantClient(api_key="vd_live_...")

# Your existing rules-based function — no AI involved
def legacy_lending_rules(applicant_data: dict) -> dict:
    if applicant_data["location"] == "Rural" and applicant_data["gender"] == "Female":
        return {"status": "rejected", "reason": "High risk demographic profile"}
    return {"status": "approved", "limit": 50000}

applicant = {"name": "Amina", "location": "Rural", "gender": "Female"}

# Wrap it exactly like an AI call
result = await client.wrap(
    fn=legacy_lending_rules,
    context_type="lending",
    input_text=str(applicant),
    applicant_data=applicant,
)

print(result.output)       # {"status": "rejected", ...}
print(result.trust_score)  # Low — bias detected
print(result.flags)        # ["demographic_bias", "gender_proxy"]

from verdant import VerdantClient

client = VerdantClient(api_key="vd_live_...")

# You already have the output from somewhere else
my_existing_output = "The candidate is rejected due to cultural fit concerns."

# Option 1: Lambda wrapper (quick one-liner)
result = await client.wrap(
    fn=lambda **kwargs: my_existing_output,
    context_type="hiring",
    input_text="Evaluate this candidate for the analyst role.",
)

# Option 2: Async function wrapper (if you prefer explicit code)
async def existing_output(**kwargs):
    return my_existing_output

result = await client.wrap(
    fn=existing_output,
    context_type="hiring",
    input_text="Evaluate this candidate for the analyst role.",
)

print(result.trust_score)  # Pipeline runs on the value as-is
print(result.flags)        # Any bias flags detected in the text
print(result.explanation)  # Plain-language reasoning

from verdant import VerdantClient

client = VerdantClient(api_key="vd_live_...")

async def flaky_ai_call(**kwargs):
    raise ConnectionError("API timeout")

# VERDANT catches the crash — your app stays up
result = await client.wrap(
    fn=flaky_ai_call,
    context_type="lending",
    input_text="Evaluate this loan application.",
)

print(result.output)       # "" (empty — no upstream output)
print(result.trust_score)  # ≤ 15 (capped to critical)
print(result.flags)        # []
print(result.explanation)  # "...The wrapped AI call failed: API timeout."

# The audit still records everything
print(result.audit.stages.trust.risk_level)  # "critical"
print(result.audit.stages.trust.alerts)      # ["Wrapped function call failed"]
print(result.audit.error)                    # "API timeout"

# Every SDK-facing endpoint requires your VERDANT API key as a Bearer token.
# Generate one from the dashboard: Settings -> API keys -> Generate key.

# Run pipeline via REST API
curl -X POST https://verdant-be.onrender.com/pipeline/run \
  -H "Authorization: Bearer vd_live_..." \
  -H "Content-Type: application/json" \
  -d '{
    "input_text": "Evaluate this candidate",
    "context_type": "hiring",
    "metadata": {}
  }'

# Fetch audit logs
curl https://verdant-be.onrender.com/audits?limit=10&context_type=hiring \
  -H "Authorization: Bearer vd_live_..."

# Get a specific audit
curl https://verdant-be.onrender.com/audits/550e8400-e29b-41d4-a716-446655440000 \
  -H "Authorization: Bearer vd_live_..."

# Generate NDPR compliance report
curl https://verdant-be.onrender.com/reports/ndpr?days=30 \
  -H "Authorization: Bearer vd_live_..."

# Manually dispatch webhooks for an audit
curl -X POST "https://verdant-be.onrender.com/webhooks/dispatch?audit_id=550e8400-...&force=true" \
  -H "Authorization: Bearer vd_live_..."

# Webhook POST payload (sent automatically on low trust)
{
  "event": "verdant.audit.low_trust",
  "timestamp": "2026-07-08T22:30:00+00:00",
  "audit": {
    "audit_id": "550e8400-e29b-41d4-a716-446655440000",
    "context_type": "hiring",
    "trust_score": 28,
    "flags": ["proxy_language_detected", "demographic_bias"],
    "explanation": "The output uses language proxies...",
    "stages": { ... }
  }
}

# Headers included with every webhook
# X-Verdant-Event: verdant.audit.low_trust
# X-Verdant-Timestamp: 2026-07-08T22:30:00+00:00
# X-Verdant-Audit-Id: 550e8400-...
# X-Verdant-Signature: sha256=abc123...  (HMAC-SHA256)

# Your VERDANT API key — from the dashboard: Settings → API keys.
# This is all the SDK needs.
VERDANT_API_KEY=vd_live_...

# Provider keys (Claude, Gemini) are NOT set here — they live in the
# dashboard (Settings → Provider Keys) and are used server-side.