Arbiter + LangChain

import os, time, requests
from typing import Optional

ARBITER_BASE = "https://arbiter-2.polsia.app"
HEADERS = {
    "Authorization": "Bearer " + os.environ["ARBITER_API_KEY"],
    "Content-Type": "application/json",
}

def register_langchain_agent(agent_id: str, name: str, tools: list, sla: dict) -> Optional[int]:
    """Register a LangChain agent. 409 = already registered, safe to ignore."""
    r = requests.post(ARBITER_BASE + "/api/agents", headers=HEADERS, json={
        "external_agent_id": agent_id, "name": name,
        "platform": "langchain", "tools": tools,
        "sla_policy": sla,
    })
    if r.status_code not in (200, 201, 409):
        r.raise_for_status()
    return r.json().get("id")

def submit_dispute(description: str, chain: list) -> dict:
    r = requests.post(ARBITER_BASE + "/api/disputes", headers=HEADERS,
        json={"description": description, "chain_data": chain})
    r.raise_for_status()
    return r.json()

def await_resolution(dispute_id: int, timeout: int = 10) -> Optional[dict]:
    deadline = time.time() + timeout
    while time.time() < deadline:
        r = requests.get(
            ARBITER_BASE + "/api/disputes/" + str(dispute_id) + "/resolution",
            headers=HEADERS)
        if r.status_code == 200:
            return r.json()
        if r.status_code != 404:
            r.raise_for_status()
        time.sleep(0.5)
    return None


# ── Wire into LangChain agent callbacks / LCEL with_fallbacks ──────

# 1. Register at startup (idempotent)
register_langchain_agent(
    "langchain-react-agent-001", "ReAct Research Agent",
    tools=["search", "retrieve", "calculate"],
    sla={"refund_window_hours": 24, "max_retry_attempts": 3})

# 2. On chain/tool failure, submit the full chain sequence
# Example: ReAct agent called retrieve -> got empty result -> hallucinated output
dispute = submit_dispute(
    description="ReAct agent hallucinated stock price after retrieval returned no results",
    chain=[
        {"agent_id": "langchain-react-agent-001", "action": "tool_call",
         "tool": "retrieve", "timestamp": "2026-04-28T10:00:00Z",
         "outcome": "failed", "error": "no_results_found"},
        {"agent_id": "langchain-react-agent-001", "action": "tool_call",
         "tool": "calculate", "timestamp": "2026-04-28T10:00:05Z",
         "outcome": "failed", "error": "invalid_input_format", "amount": 3.00},
    ])

# 3. Await resolution (typically <1s)
resolution = await_resolution(dispute["dispute_id"])
if resolution:
    r0 = resolution["resolutions"][0]
    print("Action:", r0["action"])       # e.g. "partial_credit"
    print("Reasoning:", r0["reasoning"])
else:
    print("Timed out — dispute queued for manual review")

npm install arbiter-client

import { ArbiterClient } from 'arbiter-client';

const arbiter = new ArbiterClient({
  apiKey: process.env.ARBITER_API_KEY!,
  baseUrl: 'https://arbiter-2.polsia.app',
});

// Register agents once at startup (idempotent)
async function ensureAgentsRegistered() {
  const agents = [
    { external_agent_id: 'langchain-react-agent-001', name: 'ReAct Research Agent',
      platform: 'langchain', tools: ['search', 'retrieve', 'calculate'],
      sla_policy: { refund_window_hours: 24, max_retry_attempts: 3 } },
    { external_agent_id: 'langchain-rag-pipeline-002', name: 'RAG Pipeline Agent',
      platform: 'langchain', tools: ['vector_search', 'llm_generate'],
      sla_policy: { quality_threshold: 0.9, max_latency_ms: 5000 } },
  ];
  for (const agent of agents) {
    try { await arbiter.registerAgent(agent); }
    catch (err: any) { if (err?.status !== 409) throw err; }
  }
}

// Submit dispute from a LangChain.js Chain callback or event hook
async function handleChainFailure(description: string, chain: any[]) {
  const dispute = await arbiter.submitDispute(chain, { description });

  let resolution = null;
  for (let i = 0; i < 20; i++) {
    try {
      resolution = await arbiter.getResolution(dispute.dispute_id);
      break;
    } catch (err: any) {
      if (err?.status !== 404) throw err;
      await new Promise(r => setTimeout(r, 500));
    }
  }
  if (!resolution) {
    console.warn('Resolution timed out — dispute queued for manual review');
    return null;
  }

  const { action, reasoning, fault_agent_id } = resolution.resolutions[0];
  console.log('Resolution:', action, '| Fault:', fault_agent_id);
  console.log('Reasoning:', reasoning);
  return resolution;
}

// Handle TimeoutError from a LangChain.js Chain.run() with fallback
async function runChainWithArbiter(chain: any, input: any) {
  try {
    return await chain.invoke(input);
  } catch (err: any) {
    if (err.name === 'TimeoutError') {
      console.log('Chain timed out — submitting to Arbiter');
      await handleChainFailure('Chain timed out mid-execution', [
        { agent_id: 'langchain-react-agent-001', action: 'chain_invoked',
          timestamp: '2026-04-28T10:00:00Z', outcome: 'failed',
          error: 'TimeoutError' },
      ]);
    }
    throw err;
  }
}

// Run
await ensureAgentsRegistered();