Webhooks

curl --request POST \
  --url https://api.avidoai.com/v0/validate-webhook \
  --header 'Content-Type: application/json' \
  --header 'x-application-id: <application-id>' \
  --header 'x-api-key: <api-key>' \
  --data '{
  "signature": "abc123signature",
  "timestamp": 1687802842609,
  "body": {
    "prompt": "Write a concise onboarding email for new users.",
    "testId": "123e4567-e89b-12d3-a456-426614174000",
    "metadata": {
      "customerId": "1",
      "priority": "high"
    }
  }
}'

import express from 'express';
import Avido from '@avidoai/sdk-node';

const app = express();
// Use express.json() to parse the body — the SDK handles
// sending the parsed object for validation.
app.use(express.json());
const client = new Avido({
  applicationId: process.env.AVIDO_APPLICATION_ID!,
  apiKey: process.env.AVIDO_API_KEY!,
});

app.post('/avido/webhook', async (req, res) => {
  const signature = req.get('x-avido-signature');
  const timestamp = req.get('x-avido-timestamp');
  // Pass the full body as-is — do not pick specific fields before
  // validation. The body may contain additional fields such as
  // experiment data, and all fields are covered by the signature.
  const body = req.body;

  try {
    const { valid } = await client.validateWebhook.validate({
      signature,
      timestamp,
      body
    });
    if (!valid) return res.status(401).send('Invalid webhook');

    const result = await runAgent(body.prompt); // your LLM call

    // Send the trace linked to the test — pass testId from the webhook payload.
    // You do NOT need to set traceId; the server generates one automatically.
    await client.ingest.create({
      events: [
        {
          type: 'trace',
          timestamp: new Date().toISOString(),
          testId: body.testId,
          input: body.prompt,
          output: result,
        },
      ],
    });

    return res.status(200).send('OK');
  } catch (err) {
    console.error(err);
    return res.status(500).send('Internal error');
  }
});

import os
from datetime import datetime, timezone
from flask import Flask, request, jsonify
from avido import Avido

app = Flask(__name__)
client = Avido(
    application_id=os.environ["AVIDO_APPLICATION_ID"],
    api_key=os.environ["AVIDO_API_KEY"],
)

@app.route("/avido/webhook", methods=["POST"])
def handle_webhook():
    # Parse the full JSON body as-is. Do not discard or reshape
    # fields before validation — the signature covers the entire
    # payload, which may include additional fields like experiment data.
    body = request.get_json(force=True) or {}
    signature = request.headers.get("x-avido-signature")
    timestamp = request.headers.get("x-avido-timestamp")

    if not signature or not timestamp:
        return jsonify({"error": "Missing signature or timestamp"}), 400

    try:
        resp = client.validate_webhook.validate(
            signature=signature,
            timestamp=timestamp,
            body=body
        )
        if not resp.valid:
            return jsonify({"error": "Invalid webhook signature"}), 401
    except Exception as e:
        return jsonify({"error": str(e)}), 401

    result = run_agent(body.get("prompt"))  # your LLM pipeline

    # Send the trace linked to the test — pass testId from the webhook payload.
    # You do NOT need to set traceId; the server generates one automatically.
    client.ingest.create(
        events=[
            {
                "type": "trace",
                "timestamp": datetime.now(timezone.utc).isoformat(),
                "testId": body.get("testId"),
                "input": body.get("prompt"),
                "output": result,
            },
        ],
    )
    return jsonify({"status": "ok"}), 200

const { valid } = await client.validateWebhook.validate({
  signature,  // from x-avido-signature header
  timestamp,  // from x-avido-timestamp header
  body,       // the full parsed request body
});

resp = client.validate_webhook.validate(
    signature=signature,  # from x-avido-signature header
    timestamp=timestamp,  # from x-avido-timestamp header
    body=body,            # the full parsed request body
)
# resp.valid -> bool

app.post('/avido/webhook', async (req, res) => {
  // ... validation omitted for brevity ...
  const body = req.body;

  // Check if this test is part of an experiment
  if (body.experiment) {
    const { overrides } = body.experiment;

    // Apply overrides to each inference step in your pipeline.
    // The keys in `overrides` match the step names you defined in Avido.
    for (const [stepName, params] of Object.entries(overrides)) {
      // Example: override the model and system prompt
      // for your "response_generator" step
      applyStepConfig(stepName, params);
    }
  }

  const result = await runAgent(body.prompt); // your LLM call

  await client.ingest.create({
    events: [
      {
        type: 'trace',
        timestamp: new Date().toISOString(),
        testId: body.testId,
        input: body.prompt,
        output: result,
      },
    ],
  });

  return res.status(200).send('OK');
});

// Example helper — adapt to your framework / LLM client
function applyStepConfig(stepName: string, params: Record<string, unknown>) {
  // Look up the step in your pipeline config and merge overrides
  pipelineConfig[stepName] = {
    ...pipelineConfig[stepName],
    ...params,
  };
}

@app.route("/avido/webhook", methods=["POST"])
def handle_webhook():
    # ... validation omitted for brevity ...
    body = request.get_json(force=True) or {}

    # Check if this test is part of an experiment
    experiment = body.get("experiment")
    if experiment:
        overrides = experiment.get("overrides", {})

        # Apply overrides to each inference step in your pipeline.
        # The keys in `overrides` match the step names you defined in Avido.
        for step_name, params in overrides.items():
            # Example: override the model and system prompt
            # for your "response_generator" step
            apply_step_config(step_name, params)

    result = run_agent(body.get("prompt"))  # your LLM pipeline

    client.ingest.create(
        events=[
            {
                "type": "trace",
                "timestamp": datetime.now(timezone.utc).isoformat(),
                "testId": body.get("testId"),
                "input": body.get("prompt"),
                "output": result,
            },
        ],
    )
    return jsonify({"status": "ok"}), 200


# Example helper — adapt to your framework / LLM client
def apply_step_config(step_name: str, params: dict):
    # Look up the step in your pipeline config and merge overrides
    pipeline_config[step_name] = {**pipeline_config.get(step_name, {}), **params}