Events 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();

// events.send is a passthrough — keys go to the API verbatim
// (use snake_case to match the API contract).
await pw.events.send({
  prompt:            "What is the capital of France?",
  answer:            "Paris is the capital of France.",
  model:             "gpt-4o-mini",
  prompt_tokens:     8,
  completion_tokens: 6,
});
console.log("event sent — check the dashboard");

node test_promptwall.mjs

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

export async function answer(prompt: string, userId: string) {
  const completion = await openai.chat.completions.create({...});   // unchanged
  const text = completion.choices[0].message.content ?? '';
  returnToUser(text);                                                // unchanged

  void pw.events.send({                            // ← line 2 (don't await)
    prompt,
    answer:            text,
    model:             completion.model,
    prompt_tokens:     completion.usage?.prompt_tokens     ?? 0,
    completion_tokens: completion.usage?.completion_tokens ?? 0,
    user_id:           userId,
  });
}

curl https://api.prompt-wall.com/v1/events \
  -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 } from '@promptwall/node';

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

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

export async function logInteraction(input: LogInteractionInput): Promise<void> {
  // Fire-and-forget. Never throws — Events mode is purely
  // observability and must not affect production code paths.
  try {
    await pw.events.send(input);
  } catch (err) {
    console.warn('[promptwall] events.send failed:', err);
  }
}

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 { logInteraction } from '../lib/promptwall';   // ← added

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 }],
  });
  const text = completion.choices[0].message.content ?? '';

  // Fire-and-forget — don't await. The user already has their answer.
  void logInteraction({                                // ← added
    prompt, answer: text, model: completion.model,
    promptTokens: completion.usage?.prompt_tokens ?? 0,
    completionTokens: completion.usage?.completion_tokens ?? 0,
    userId,
  });

  return text;
}

package promptwall

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

var httpClient = &http.Client{Timeout: 5 * time.Second}

type Event 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"`
    Metadata         map[string]interface{} `json:"metadata,omitempty"`
}

func Send(e Event) error {
    body, err := json.Marshal(e)
    if err != nil { return err }
    req, _ := http.NewRequest("POST",
        "https://api.prompt-wall.com/v1/events",
        bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer "+os.Getenv("PROMPTWALL_API_KEY"))
    req.Header.Set("Content-Type", "application/json")
    resp, err := httpClient.Do(req)
    if err != nil { return err }
    resp.Body.Close()
    return nil
}

require 'net/http'
require 'json'

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

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

    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, metadata: metadata,
    }.compact.to_json
    http.request(req)
  rescue StandardError => e
    Rails.logger.warn "[promptwall] failed: #{e.message}" if defined?(Rails)
  end
end

using System.Net.Http.Json;

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

    public static async Task SendAsync(object evt) {
        try {
            var req = new HttpRequestMessage(HttpMethod.Post, "/v1/events") {
                Content = JsonContent.Create(evt),
            };
            req.Headers.Add("Authorization", $"Bearer {ApiKey}");
            await http.SendAsync(req);
        } catch (Exception ex) {
            Console.Error.WriteLine($"[promptwall] {ex.Message}");
        }
    }
}

<?php
namespace App;

use GuzzleHttp\Client;

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

    public static function send(array $event): void {
        try {
            self::$client ??= new Client([
                'base_uri' => 'https://api.prompt-wall.com',
                'timeout'  => 5.0,
            ]);
            self::$client->post('/v1/events', [
                'headers' => [
                    'Authorization' => 'Bearer ' . getenv('PROMPTWALL_API_KEY'),
                    'Content-Type'  => 'application/json',
                ],
                'json' => $event,
            ]);
        } catch (\Throwable $e) {
            error_log('[promptwall] ' . $e->getMessage());
        }
    }
}