From LangSmith Traces
to Financial Actions

import os, requests
from typing import Any, Dict, List, Optional
from langchain.callbacks.base import BaseCallbackHandler
from langsmith import RunTree

PURPLEFLEA_API_KEY = os.environ["PURPLEFLEA_API_KEY"]  # pf_live_...
ESCROW_BASE        = "https://escrow.purpleflea.com"
ESCROW_AMOUNT_USDC = 10.0   # fund per task
QUALITY_THRESHOLD  = 0.75   # min LangSmith eval score to release


class PurpleFleasEscrowCallback(BaseCallbackHandler):
    """
    LangSmith callback that creates a Purple Flea escrow when a chain
    starts and releases (or refunds) it based on the chain outcome.
    The LangSmith run_id is stored as escrow metadata for a full audit
    trail across both platforms.
    """

    def __init__(self, agent_id: str, counterparty_agent_id: str):
        self.agent_id = agent_id
        self.counterparty = counterparty_agent_id
        self.escrow_ids: Dict[str, str] = {}  # run_id → escrow_id

    def _headers(self) -> Dict:
        return {
            "Authorization": f"Bearer {PURPLEFLEA_API_KEY}",
            "Content-Type": "application/json"
        }

    def on_chain_start(
        self,
        serialized: Dict[str, Any],
        inputs: Dict[str, Any],
        run_id: Any = None,
        **kwargs
    ):
        # Create escrow when chain begins
        resp = requests.post(
            f"{ESCROW_BASE}/api/escrow/create",
            headers=self._headers(),
            json={
                "from_agent_id": self.agent_id,
                "to_agent_id":   self.counterparty,
                "amount_usdc":   ESCROW_AMOUNT_USDC,
                "metadata": {
                    "langsmith_run_id":  str(run_id),
                    "chain_name":        serialized.get("name", "unknown"),
                    "task_description":  str(inputs)[:200],
                }
            }
        )
        if resp.ok:
            escrow_id = resp.json()["escrow_id"]
            self.escrow_ids[str(run_id)] = escrow_id
            print(f"[PF] Escrow created: {escrow_id} for run {run_id}")

    def on_chain_end(
        self,
        outputs: Dict[str, Any],
        run_id: Any = None,
        **kwargs
    ):
        escrow_id = self.escrow_ids.pop(str(run_id), None)
        if not escrow_id:
            return
        # Release escrow on successful chain completion
        resp = requests.post(
            f"{ESCROW_BASE}/api/escrow/{escrow_id}/release",
            headers=self._headers(),
            json={"released_by": self.agent_id}
        )
        print(f"[PF] Escrow {escrow_id} released: {resp.status_code}")

    def on_chain_error(
        self,
        error: Exception,
        run_id: Any = None,
        **kwargs
    ):
        escrow_id = self.escrow_ids.pop(str(run_id), None)
        if not escrow_id:
            return
        # Refund escrow on chain error
        resp = requests.post(
            f"{ESCROW_BASE}/api/escrow/{escrow_id}/refund",
            headers=self._headers(),
            json={
                "reason": f"chain_error: {type(error).__name__}"
            }
        )
        print(f"[PF] Escrow {escrow_id} refunded after error: {resp.status_code}")


# Usage
from langchain.chains import LLMChain
from langchain_openai import ChatOpenAI
from langchain.prompts import ChatPromptTemplate

callback = PurpleFleasEscrowCallback(
    agent_id="agent-alpha-001",
    counterparty_agent_id="agent-beta-002"
)

chain = LLMChain(
    llm=ChatOpenAI(model="gpt-4o"),
    prompt=ChatPromptTemplate.from_template("{task}"),
    callbacks=[callback]   # ← attach the callback
)

result = chain.invoke({"task": "Analyze this dataset and summarize findings"})
# Escrow created at start, released at end — automatically.

import os, requests
from langsmith import Client, evaluate
from langsmith.evaluation import LangChainStringEvaluator

ls_client  = Client()
pf_headers = {
    "Authorization": f"Bearer {os.environ['PURPLEFLEA_API_KEY']}",
    "Content-Type": "application/json"
}

QUALITY_THRESHOLD = 0.75  # 0.0 – 1.0; below this = refund
PARTIAL_THRESHOLD = 0.50  # between this and quality = 50% release


def quality_gate_release(escrow_id: str, dataset_name: str, agent_fn):
    """
    Run LangSmith evaluation against agent output.
    Release escrow in full, partial, or refund based on score.
    """
    # 1. Run LangSmith evaluation
    eval_results = evaluate(
        agent_fn,
        data=dataset_name,
        evaluators=[
            LangChainStringEvaluator("criteria", config={
                "criteria": {
                    "accuracy":     "Is the answer factually correct?",
                    "completeness": "Does it fully address the question?",
                    "coherence":    "Is the response well-structured?",
                }
            })
        ],
        experiment_prefix="quality-gate-run",
    )

    # 2. Aggregate scores across all criteria
    scores = [
        r["evaluation_results"]["results"][0].score
        for r in eval_results._results
        if r.get("evaluation_results")
    ]
    avg_score = sum(scores) / len(scores) if scores else 0.0
    print(f"[Quality Gate] Average score: {avg_score:.3f}")

    # 3. Trigger escrow action based on score band
    if avg_score >= QUALITY_THRESHOLD:
        # Full release
        resp = requests.post(
            f"https://escrow.purpleflea.com/api/escrow/{escrow_id}/release",
            headers=pf_headers,
            json={"score": avg_score, "action": "full_release"}
        )
        print(f"[PF] Full release: {resp.status_code}")
        return "released"

    elif avg_score >= PARTIAL_THRESHOLD:
        # Partial release (50%); refund remainder
        resp = requests.post(
            f"https://escrow.purpleflea.com/api/escrow/{escrow_id}/release",
            headers=pf_headers,
            json={"score": avg_score, "action": "partial", "pct": 50}
        )
        print(f"[PF] Partial release (50%): {resp.status_code}")
        return "partial"

    else:
        # Score too low — full refund
        resp = requests.post(
            f"https://escrow.purpleflea.com/api/escrow/{escrow_id}/refund",
            headers=pf_headers,
            json={
                "reason": f"quality_score={avg_score:.3f} below threshold={QUALITY_THRESHOLD}"
            }
        )
        print(f"[PF] Refunded (score too low): {resp.status_code}")
        return "refunded"


# Example usage
outcome = quality_gate_release(
    escrow_id="esc_abc123",
    dataset_name="my-agent-tasks",
    agent_fn=lambda x: my_agent.invoke(x["question"])
)
print(f"Payment outcome: {outcome}")