Webhooks

{
  "requestId": "req_abc123def456",
  "secret": "your-secret-key-here",
  "status": "error",
  "browserWindowId": "window_xyz789",
  "response": {
    "text": "Failed to complete the task due to network timeout."
  },
  "createdAt": "2024-11-21T10:00:00.000000+00:00",
  "completedAt": "2024-11-21T10:02:30.000000+00:00",
  "usage": {
    "actions": 8,
    "credits": 3
  }
}

{
  "requestId": "req_abc123def456",
  "secret": "your-secret-key-here",
  "status": "input-required",
  "browserWindowId": "window_xyz789",
  "response": {
    "text": "The task requires authentication. Please log in to continue."
  },
  "createdAt": "2024-11-21T10:00:00.000000+00:00",
  "completedAt": "2024-11-21T10:00:15.000000+00:00",
  "usage": {
    "actions": 3,
    "credits": 1
  }
}

{
  "requestId": "req_abc123def456",
  "secret": "your-secret-key-here",
  "status": "success",
  "browserWindowId": "window_xyz789",
  "response": {
    "text": "Successfully extracted job information.",
    "structuredOutput": {
      "title": "Senior Software Engineer",
      "company": "TechCorp Inc.",
      "location": "San Francisco, CA",
      "salary": "$150,000 - $200,000",
      "remote": true
    }
  },
  "createdAt": "2024-11-21T10:00:00.000000+00:00",
  "completedAt": "2024-11-21T10:00:52.000000+00:00",
  "usage": {
    "actions": 15,
    "credits": 6
  }
}

from fastapi import FastAPI, Request, HTTPException
from pydantic import BaseModel
from typing import Any, Literal, Mapping
import os

app = FastAPI()

class RemoteDispatchUsage(BaseModel):
    actions: int
    credits: int

class WebhookPayload(BaseModel):
    requestId: str
    secret: str | None
    status: Literal["input-required", "success", "error"]
    browserWindowId: str | None
    response: Mapping[str, Any]
    createdAt: str
    completedAt: str
    usage: RemoteDispatchUsage | None

@app.post("/api/narada/webhook")
async def handle_webhook(request: Request, payload: WebhookPayload):
    # Verify authentication - check Authorization header from callback_headers
    auth_header = request.headers.get("authorization")
    expected_token = os.getenv('WEBHOOK_TOKEN')
    if auth_header and expected_token:
        if auth_header != f"Bearer {expected_token}":
            raise HTTPException(status_code=401, detail="Invalid authorization header")

    # Also verify the secret if provided
    expected_secret = os.getenv('NARADA_CALLBACK_SECRET')
    if expected_secret and payload.secret != expected_secret:
        raise HTTPException(status_code=401, detail="Invalid secret")

    # Process the webhook payload
    print(f"Task {payload.requestId} completed with status: {payload.status}")

    if payload.status == "success":
        print(f"Response: {payload.response.get('text')}")
        handle_success(payload)
    elif payload.status == "error":
        print(f"Task failed: {payload.response.get('text')}")
        handle_error(payload)
    elif payload.status == "input-required":
        print(f"Input required: {payload.response.get('text')}")
        handle_input_required(payload)

    # Always respond with 200 to acknowledge receipt
    return {"received": True}

def handle_success(payload: WebhookPayload):
    # Your success handling logic
    pass

def handle_error(payload: WebhookPayload):
    # Your error handling logic
    pass

def handle_input_required(payload: WebhookPayload):
    # Your input handling logic
    pass