LlamaIndex Workflows + Signbee: RAG Contract Review to E-Signature (2026)

from typing import List, Literal, Optional
from pydantic import BaseModel, Field
from llama_index.core.workflow import (
    Event,
    StartEvent,
    StopEvent,
    InputRequiredEvent,
    HumanResponseEvent,
)

class ClauseFinding(BaseModel):
    clause_category: Literal[
        "limitation_of_liability",
        "indemnification",
        "payment_terms",
        "ip_ownership",
        "governing_law",
    ]
    original_excerpt: str = Field(description="Exact clause text extracted from counterparty draft")
    risk_level: Literal["LOW", "MEDIUM", "HIGH", "CRITICAL"]
    policy_violation_reason: str
    recommended_fallback_markdown: str = Field(
        description="Replacement clause in CommonMark matching company playbook"
    )

class ContractAuditReport(BaseModel):
    counterparty_name: str
    counterparty_signer_name: str
    counterparty_signer_email: str
    overall_risk_score: int = Field(ge=0, le=100)
    findings: List[ClauseFinding]

class ClausesExtractedEvent(Event):
    raw_markdown: str
    document_title: str

class PlaybookAuditEvent(Event):
    audit_report: ContractAuditReport
    raw_markdown: str
    document_title: str
    counsel_feedback: Optional[str] = None

class ApprovalRequiredEvent(InputRequiredEvent):
    document_title: str
    clean_contract_markdown: str
    overall_risk_score: int
    recipient_name: str
    recipient_email: str
    high_risk_count: int

class CounselDecisionEvent(HumanResponseEvent):
    approved: bool
    reviewer_name: str
    reviewer_email: str
    revision_notes: Optional[str] = None

import os
import hashlib
import httpx
from llama_index.core import VectorStoreIndex
from llama_index.core.llms import LLM
from llama_index.core.prompts import PromptTemplate
from llama_index.core.workflow import Workflow, Context, step, StartEvent, StopEvent
from events_and_models import (
    ContractAuditReport,
    ClausesExtractedEvent,
    PlaybookAuditEvent,
    ApprovalRequiredEvent,
    CounselDecisionEvent,
)

class ContractReviewAndSignWorkflow(Workflow):
    def __init__(
        self,
        llm: LLM,
        playbook_index: VectorStoreIndex,
        signbee_api_key: str,
        webhook_url: str,
        **kwargs,
    ):
        super().__init__(**kwargs)
        self.llm = llm
        self.retriever = playbook_index.as_retriever(similarity_top_k=5)
        self.signbee_api_key = signbee_api_key
        self.webhook_url = webhook_url

    @step
    async def parse_and_extract(
        self, ctx: Context, ev: StartEvent
    ) -> ClausesExtractedEvent:
        contract_markdown: str = ev.get("contract_markdown")
        document_title: str = ev.get("document_title", "Master Services Agreement")

        await ctx.store.set("document_title", document_title)
        await ctx.store.set("original_markdown", contract_markdown)

        return ClausesExtractedEvent(
            raw_markdown=contract_markdown,
            document_title=document_title,
        )

    @step
    async def audit_against_playbook(
        self, ctx: Context, ev: ClausesExtractedEvent
    ) -> PlaybookAuditEvent:
        # Retrieve company legal playbook fallback rules via semantic search
        playbook_nodes = await self.retriever.aretrieve(
            "limitation of liability cap indemnification IP ownership payment net terms"
        )
        playbook_context = "\n\n".join([n.node.get_content() for n in playbook_nodes])

        audit_prompt = PromptTemplate(
            "You are General Counsel auditing a counterparty contract against our Corporate Playbook.\n"
            "PLAYBOOK RULES:\n{playbook_context}\n\n"
            "COUNTERPARTY CONTRACT:\n{contract_markdown}\n\n"
            "Extract counterparty signer details, score risk (0-100), and provide CommonMark fallback clauses."
        )

        audit_report: ContractAuditReport = await self.llm.astructured_predict(
            ContractAuditReport,
            audit_prompt,
            playbook_context=playbook_context,
            contract_markdown=ev.raw_markdown,
        )

        await ctx.store.set("audit_report", audit_report.model_dump())
        return PlaybookAuditEvent(
            audit_report=audit_report,
            raw_markdown=ev.raw_markdown,
            document_title=ev.document_title,
        )

    @step
    async def draft_clean_contract(
        self, ctx: Context, ev: PlaybookAuditEvent
    ) -> ApprovalRequiredEvent:
        findings_json = ev.audit_report.model_dump_json(indent=2)
        feedback_note = ev.counsel_feedback or "No additional human feedback."

        draft_prompt = (
            f"Rewrite the following contract into a clean, execution-ready CommonMark agreement.\n"
            f"Incorporate all recommended_fallback_markdown replacements from this audit:\n{findings_json}\n"
            f"Additional Counsel Instructions: {feedback_note}\n"
            f"Include a summary table of amended clauses at the top.\n\n"
            f"ORIGINAL CONTRACT:\n{ev.raw_markdown}"
        )
        response = await self.llm.acomplete(draft_prompt)
        clean_markdown = response.text.strip()

        await ctx.store.set("clean_markdown", clean_markdown)
        high_risk_count = sum(
            1 for f in ev.audit_report.findings if f.risk_level in ("HIGH", "CRITICAL")
        )

        # Emit InputRequiredEvent subclass to pause execution for human review
        return ApprovalRequiredEvent(
            document_title=ev.document_title,
            clean_contract_markdown=clean_markdown,
            overall_risk_score=ev.audit_report.overall_risk_score,
            recipient_name=ev.audit_report.counterparty_signer_name,
            recipient_email=ev.audit_report.counterparty_signer_email,
            high_risk_count=high_risk_count,
        )

    @step
    async def dispatch_to_signbee(
        self, ctx: Context, ev: CounselDecisionEvent
    ) -> PlaybookAuditEvent | StopEvent:
        audit_dict = await ctx.store.get("audit_report")
        audit_report = ContractAuditReport(**audit_dict)
        document_title = await ctx.store.get("document_title")
        clean_markdown = await ctx.store.get("clean_markdown")

        # If counsel rejected the draft, loop back to re-draft with their revision notes
        if not ev.approved:
            return PlaybookAuditEvent(
                audit_report=audit_report,
                raw_markdown=clean_markdown,
                document_title=document_title,
                counsel_feedback=ev.revision_notes,
            )

        # Compute deterministic idempotency key from contract content
        content_hash = hashlib.sha256(clean_markdown.encode("utf-8")).hexdigest()[:16]
        idempotency_key = f"llamaindex-{content_hash}"

        payload = {
            "title": document_title,
            "markdown": clean_markdown,
            "sender_name": ev.reviewer_name,
            "sender_email": ev.reviewer_email,
            "recipient_name": audit_report.counterparty_signer_name,
            "recipient_email": audit_report.counterparty_signer_email,
            "expires_in_days": 14,
            "webhook_url": self.webhook_url,
        }

        async with httpx.AsyncClient(timeout=20.0) as client:
            res = await client.post(
                "https://signb.ee/api/v1/send",
                headers={
                    "Authorization": f"Bearer {self.signbee_api_key}",
                    "Content-Type": "application/json",
                    "X-Idempotency-Key": idempotency_key,
                },
                json=payload,
            )
            res.raise_for_status()
            receipt = res.json()

        return StopEvent(
            result={
                "status": "DISPATCHED",
                "signbee_document_id": receipt["id"],
                "verify_url": receipt["verify_url"],
                "recipient_email": audit_report.counterparty_signer_email,
                "approved_by": ev.reviewer_email,
            }
        )

import { Workflow, StartEvent, StopEvent, WorkflowEvent } from "@llamaindex/workflow";

export interface ApprovedContractData {
  title: string;
  markdown: string;
  senderName: string;
  senderEmail: string;
  recipientName: string;
  recipientEmail: string;
}

export class ContractApprovedEvent extends WorkflowEvent<ApprovedContractData> {}

export interface SignbeeReceipt {
  id: string;
  status: "PENDING" | "SIGNED";
  verify_url: string;
  expires_at: string;
}

export function createSignbeeLegalWorkflow(signbeeApiKey: string, webhookUrl: string) {
  const workflow = new Workflow<ApprovedContractData, SignbeeReceipt>();

  workflow.addStep(
    {
      inputs: [ContractApprovedEvent],
      outputs: [StopEvent],
    },
    async (context, event) => {
      const { title, markdown, senderName, senderEmail, recipientName, recipientEmail } =
        event.data;

      const response = await fetch("https://signb.ee/api/v1/send", {
        method: "POST",
        headers: {
          Authorization: `Bearer ${signbeeApiKey}`,
          "Content-Type": "application/json",
        },
        body: JSON.stringify({
          title,
          markdown,
          sender_name: senderName,
          sender_email: senderEmail,
          recipient_name: recipientName,
          recipient_email: recipientEmail,
          expires_in_days: 14,
          webhook_url: webhookUrl,
        }),
      });

      if (!response.ok) {
        const errorBody = await response.text();
        throw new Error(`Signbee dispatch failed (${response.status}): ${errorBody}`);
      }

      const receipt = (await response.json()) as SignbeeReceipt;
      return new StopEvent(receipt);
    }
  );

  return workflow;
}