Guardrails — content checking for LLM calls

import OpenAI from "openai";
import { zespan } from "@zespan/sdk";

zespan.init({ apiKey: process.env.ZESPAN_API_KEY! });

const openai = zespan.wrapOpenAI(new OpenAI(), {
  guardrails: true,
});

import os
import zespan

zespan.init(api_key=os.environ["ZESPAN_API_KEY"])
zespan.patch_openai(guardrails=True)

import openai  # import after patching
client = openai.OpenAI()

const openai = zespan.wrapOpenAI(new OpenAI(), {
  guardrails: {
    pre: true,          // Check prompt before sending to LLM
    post: true,         // Check completion before returning to app
    failClosed: false,  // If guardrail service errors, allow the call through
  },
});

zespan.patch_openai(
    guardrails={
        "pre": True,            # Check prompt before sending to LLM
        "post": True,           # Check completion before returning to app
        "fail_closed": False,   # If guardrail service errors, allow the call through
    },
)

import { zespan, GuardrailBlockedError } from "@zespan/sdk";
import OpenAI from "openai";

zespan.init({ apiKey: process.env.ZESPAN_API_KEY! });

const openai = zespan.wrapOpenAI(new OpenAI(), {
  guardrails: { pre: true, post: true, failClosed: false },
});

async function generateResponse(userMessage: string): Promise<string> {
  try {
    const response = await openai.chat.completions.create({
      model: "gpt-4o",
      messages: [{ role: "user", content: userMessage }],
    });
    return response.choices[0].message.content ?? "";
  } catch (err) {
    if (err instanceof GuardrailBlockedError) {
      console.warn(`Guardrail blocked ${err.phase} content:`, err.results);
      // Return a safe fallback rather than exposing the block reason
      return "I'm sorry, I can't help with that request.";
    }
    throw err;
  }
}

import os
import zespan
from zespan import GuardrailBlockedError
import openai

zespan.init(api_key=os.environ["ZESPAN_API_KEY"])
zespan.patch_openai(guardrails={"pre": True, "post": True, "fail_closed": False})

client = openai.OpenAI()

def generate_response(user_message: str) -> str:
    try:
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=[{"role": "user", "content": user_message}],
        )
        return response.choices[0].message.content or ""
    except GuardrailBlockedError as err:
        print(f"Guardrail blocked {err.phase} content:", err.results)
        # Return a safe fallback rather than exposing the block reason
        return "I'm sorry, I can't help with that request."

// Anthropic with post-only check and fail-closed
const anthropic = zespan.wrapAnthropic(new Anthropic(), {
  guardrails: { pre: false, post: true, failClosed: true },
});

// LangChain with full guardrails
import { ZespanCallbackHandler } from "@zespan/sdk";
const handler = new ZespanCallbackHandler({
  guardrails: { pre: true, post: true, failClosed: false },
});

# Anthropic with post-only check and fail-closed
zespan.patch_anthropic(guardrails={"pre": False, "post": True, "fail_closed": True})

# LangChain with full guardrails
from zespan import ZespanCallbackHandler
handler = ZespanCallbackHandler(
    guardrails={"pre": True, "post": True, "fail_closed": False},
)

import { zespan } from "@zespan/sdk";

zespan.init({ apiKey: process.env.ZESPAN_API_KEY! });

const result = await zespan.getClient().checkGuardrails({
  text: retrievedChunks.join("\n"),
  phase: "pre",
  traceId: span.traceId,
  spanId: span.spanId,
  operation: "rag-retrieval",
  agentName: "ResearchAgent",
});

if (!result.allowed) {
  throw new Error(
    `Retrieval blocked: ${result.results.map((r) => r.reason).join(", ")}`
  );
}

import os
import zespan

zespan.init(api_key=os.environ["ZESPAN_API_KEY"])

result = zespan.check_guardrails(
    text="\n".join(retrieved_chunks),
    phase="pre",
    trace_id=span.trace_id,
    span_id=span.span_id,
    operation="rag-retrieval",
)

if not result["allowed"]:
    reasons = [r.get("reason") for r in result["results"] if r.get("reason")]
    raise RuntimeError(f"Retrieval blocked: {', '.join(reasons)}")