Verify mode — full integration

npm init -y                 # only if you don't already have a package.json
npm install @promptwall/node

process.env.PROMPTWALL_API_KEY = "pk_live_xxxxxxxx";   // paste your real key

import { PromptWall } from '@promptwall/node';
const pw = new PromptWall();

const prompt = "What is the capital of France?";
const answer = "Paris is the capital of France.";

// pw.verify({...}) is a direct method, not pw.verify(...).
// Required: prompt, answer. Optional: toolResult, verifiedSourceUsed.
const result = await pw.verify({ prompt, answer });
console.log('governance:', result.governance);   // allow | rewrite | block | regenerate
console.log('answer:    ', result.answer);        // may be rewritten

node test_promptwall.mjs

import { PromptWall } from '@promptwall/node';
const pw = new PromptWall();

let answer = await yourExistingLlmCall(prompt);   // ← stays unchanged

const result = await pw.verify({ prompt, answer });

if (result.governance === 'block') {
  return "Sorry, I can't share that.";
}
return result.answer;   // safe — already rewritten by PromptWall if needed

curl https://api.prompt-wall.com/v1/verify \
  -H "Authorization: Bearer pk_live_xxxxxxxx" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "What is the capital of France?",
    "answer": "Paris is the capital of France.",
    "model":  "gpt-4o-mini",
    "prompt_tokens": 8,
    "completion_tokens": 6
  }'

PROMPTWALL_API_KEY=pk_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

import 'dotenv/config';

import { PromptWall, PromptWallError } from '@promptwall/node';

// Singleton — instantiate once at module load.
const pw = new PromptWall({
  apiKey: process.env.PROMPTWALL_API_KEY!,
  timeoutMs: 2000,
});

export type Decision = 'allow' | 'block' | 'rewrite';

export interface VerifyResult {
  governance: Decision;
  reasons: { policy: string; severity: 'low' | 'medium' | 'high' | 'critical' }[];
  rewritten?: string;
  requestId: string;
}

export interface VerifyInput {
  prompt: string;
  answer: string;
  model: string;
  promptTokens: number;
  completionTokens: number;
  userId?: string;
  sessionId?: string;
  toolResult?: string;
  metadata?: Record<string, unknown>;
}

export async function verifyAnswer(input: VerifyInput): Promise<VerifyResult> {
  // Throws PromptWallError on network / timeout / 5xx.
  // Decide your fallback policy in the caller.
  return pw.verify(input);
}

export { PromptWallError };

import OpenAI from 'openai';
const openai = new OpenAI();

export async function answer(prompt: string, userId: string) {
  const completion = await openai.chat.completions.create({
    model: 'gpt-4o-mini',
    messages: [{ role: 'user', content: prompt }],
  });
  return completion.choices[0].message.content ?? '';
}

import OpenAI from 'openai';
import { verifyAnswer, PromptWallError } from '../lib/promptwall';   // ← added

const openai = new OpenAI();

const SAFE_FALLBACK =
  "Sorry — I can't share that. Please contact support if you need help.";

export async function answer(prompt: string, userId: string) {
  const completion = await openai.chat.completions.create({
    model: 'gpt-4o-mini',
    messages: [{ role: 'user', content: prompt }],
  });
  const text = completion.choices[0].message.content ?? '';

  try {                                                              // ← added
    const result = await verifyAnswer({
      prompt,
      answer: text,
      model: completion.model,
      promptTokens: completion.usage?.prompt_tokens ?? 0,
      completionTokens: completion.usage?.completion_tokens ?? 0,
      userId,
    });

    if (result.governance === 'block')   return SAFE_FALLBACK;
    if (result.governance === 'rewrite') return result.rewritten!;
    return text; // allow
  } catch (err) {
    if (err instanceof PromptWallError) {
      // Fail-open vs fail-closed — pick based on your risk profile.
      return text;
    }
    throw err;
  }
}

package promptwall

import (
    "bytes"
    "encoding/json"
    "errors"
    "net/http"
    "os"
    "time"
)

var verifyClient = &http.Client{Timeout: 2 * time.Second}

type VerifyRequest struct {
    Prompt           string                 `json:"prompt"`
    Answer           string                 `json:"answer"`
    Model            string                 `json:"model"`
    PromptTokens     int                    `json:"prompt_tokens"`
    CompletionTokens int                    `json:"completion_tokens"`
    UserID           string                 `json:"user_id,omitempty"`
    SessionID        string                 `json:"session_id,omitempty"`
    ToolResult       string                 `json:"tool_result,omitempty"`
    Metadata         map[string]interface{} `json:"metadata,omitempty"`
}

type VerifyResponse struct {
    OK         bool   `json:"ok"`
    RequestID  string `json:"request_id"`
    Governance string `json:"governance"` // allow | block | rewrite
    Rewritten  string `json:"rewritten,omitempty"`
    Reasons    []struct {
        Policy   string `json:"policy"`
        Severity string `json:"severity"`
    } `json:"reasons"`
}

func Verify(req VerifyRequest) (*VerifyResponse, error) {
    body, _ := json.Marshal(req)
    httpReq, _ := http.NewRequest("POST",
        "https://api.prompt-wall.com/v1/verify",
        bytes.NewReader(body))
    httpReq.Header.Set("Authorization", "Bearer "+os.Getenv("PROMPTWALL_API_KEY"))
    httpReq.Header.Set("Content-Type", "application/json")

    resp, err := verifyClient.Do(httpReq)
    if err != nil { return nil, err }
    defer resp.Body.Close()
    if resp.StatusCode >= 400 {
        return nil, errors.New("promptwall verify: " + resp.Status)
    }

    var out VerifyResponse
    if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
        return nil, err
    }
    return &out, nil
}

require 'net/http'
require 'json'

class PromptWallVerify
  ENDPOINT = URI('https://api.prompt-wall.com/v1/verify')

  def self.check(prompt:, answer:, model:, prompt_tokens:,
                 completion_tokens:, user_id: nil, session_id: nil,
                 tool_result: nil, metadata: nil)
    http = Net::HTTP.new(ENDPOINT.host, ENDPOINT.port)
    http.use_ssl = true
    http.read_timeout = 2

    req = Net::HTTP::Post.new(ENDPOINT.path,
      'Authorization' => "Bearer #{ENV['PROMPTWALL_API_KEY']}",
      'Content-Type'  => 'application/json',
    )
    req.body = {
      prompt: prompt, answer: answer, model: model,
      prompt_tokens: prompt_tokens, completion_tokens: completion_tokens,
      user_id: user_id, session_id: session_id,
      tool_result: tool_result, metadata: metadata,
    }.compact.to_json

    res = http.request(req)
    JSON.parse(res.body)
  end
end

using System.Net.Http.Json;

public record VerifyResult(
    bool ok, string request_id, string governance,
    string? rewritten,
    List<VerifyReason> reasons);

public record VerifyReason(string policy, string severity);

public static class PromptWallVerify {
    private static readonly HttpClient http = new() {
        BaseAddress = new Uri("https://api.prompt-wall.com"),
        Timeout = TimeSpan.FromSeconds(2),
    };
    private static readonly string ApiKey =
        Environment.GetEnvironmentVariable("PROMPTWALL_API_KEY")!;

    public static async Task<VerifyResult> CheckAsync(object body) {
        var req = new HttpRequestMessage(HttpMethod.Post, "/v1/verify") {
            Content = JsonContent.Create(body),
        };
        req.Headers.Add("Authorization", $"Bearer {ApiKey}");
        var resp = await http.SendAsync(req);
        resp.EnsureSuccessStatusCode();
        return (await resp.Content.ReadFromJsonAsync<VerifyResult>())!;
    }
}

<?php
namespace App;

use GuzzleHttp\Client;

class PromptWallVerify {
    private static ?Client $client = null;

    public static function check(array $body): array {
        self::$client ??= new Client([
            'base_uri' => 'https://api.prompt-wall.com',
            'timeout'  => 2.0,
        ]);
        $resp = self::$client->post('/v1/verify', [
            'headers' => [
                'Authorization' => 'Bearer ' . getenv('PROMPTWALL_API_KEY'),
                'Content-Type'  => 'application/json',
            ],
            'json' => $body,
        ]);
        return json_decode((string) $resp->getBody(), true);
    }
}