Full Control 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 here

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

// pw.chat({...}) is a direct method, not pw.chat(...).
// Either pass `prompt: "..."` for a single-turn message, or
// `messages: [...]` for multi-turn / system-prompted chats.
const result = await pw.chat({
  messages: [{ role: 'user', content: 'What is the capital of France?' }],
  model:    'gpt-4o-mini',
});
console.log('answer:           ', result.answer);
console.log('governanceAction: ', result.governanceAction);   // allow|rewrite|block|regenerate

node test_promptwall.mjs

curl https://api.prompt-wall.com/v1/chat \
  -H "Authorization: Bearer pk_live_xxxxxxxx" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o-mini",
    "messages": [{"role": "user", "content": "What is the capital of France?"}]
  }'

PROMPTWALL_API_KEY=pk_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

import 'dotenv/config';

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

const pw = new PromptWall({
  apiKey: process.env.PROMPTWALL_API_KEY!,
  timeoutMs: 30_000,
});

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

export interface ChatMessage {
  role: 'system' | 'user' | 'assistant' | 'tool';
  content: string;
  name?: string;
}

export interface ChatInput {
  messages: ChatMessage[];
  model: string;
  userId?: string;
  sessionId?: string;
  metadata?: Record<string, unknown>;
  // any other LLM kwargs (temperature, maxTokens, tools, ...)
  [extra: string]: unknown;
}

export interface ChatResult {
  answer: string;
  governance: Decision;
  reasons: { policy: string; severity: string; stage: 'pre' | 'post' }[];
  model: string;
  usage: { promptTokens: number; completionTokens: number };
  requestId: string;
}

export async function chat(input: ChatInput): Promise<ChatResult> {
  return pw.chat(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 { chat, PromptWallError } from '../lib/promptwall';   // ← replaces openai import

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

export async function answer(prompt: string, userId: string) {
  try {
    const result = await chat({                              // ← single call
      messages: [{ role: 'user', content: prompt }],
      model: 'gpt-4o-mini',
      userId,
    });

    if (result.governance === 'block') return SAFE_FALLBACK;
    return result.answer;
  } catch (err) {
    if (err instanceof PromptWallError) return SAFE_FALLBACK;
    throw err;
  }
}

package promptwall

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

var chatClient = &http.Client{Timeout: 35 * time.Second}

type Message struct {
    Role    string `json:"role"`
    Content string `json:"content"`
}

type ChatRequest struct {
    Model     string                 `json:"model"`
    Messages  []Message              `json:"messages"`
    UserID    string                 `json:"user_id,omitempty"`
    SessionID string                 `json:"session_id,omitempty"`
    Metadata  map[string]interface{} `json:"metadata,omitempty"`
    Extra     map[string]interface{} `json:"-"` // marshalled into root
}

type ChatResponse struct {
    OK         bool   `json:"ok"`
    RequestID  string `json:"request_id"`
    Governance string `json:"governance"`
    Stage      string `json:"stage,omitempty"`
    Answer     string `json:"answer"`
    Reasons    []struct {
        Policy   string `json:"policy"`
        Severity string `json:"severity"`
    } `json:"reasons"`
    Usage struct {
        PromptTokens     int `json:"prompt_tokens"`
        CompletionTokens int `json:"completion_tokens"`
    } `json:"usage"`
}

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

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

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

require 'net/http'
require 'json'

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

  def self.create(messages:, model:, user_id: nil, session_id: nil,
                  metadata: nil, **llm_kwargs)
    http = Net::HTTP.new(ENDPOINT.host, ENDPOINT.port)
    http.use_ssl = true
    http.read_timeout = 35

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

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

using System.Net.Http.Json;

public record ChatResult(
    bool ok, string request_id, string governance,
    string? stage, string? answer,
    List<ChatReason> reasons, ChatUsage usage);

public record ChatReason(string policy, string severity);
public record ChatUsage(int prompt_tokens, int completion_tokens);

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

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

<?php
namespace App;

use GuzzleHttp\Client;

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

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