Google Gemini 2.5 Function Calling + Signbee: Multimodal Contract Signing (2026)

import {
  GoogleGenAI,
  Type,
  FunctionDeclaration,
  FunctionCallingConfigMode,
  createPartFromUri,
} from "@google/genai";

const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });

// 1. Define the deterministic Signbee contract dispatch tool schema
const sendSignbeeContractDeclaration: FunctionDeclaration = {
  name: "send_signbee_contract",
  description:
    "Drafts a legally binding CommonMark agreement from extracted commercial terms and dispatches an encrypted signing link via Signbee REST API.",
  parameters: {
    type: Type.OBJECT,
    properties: {
      title: {
        type: Type.STRING,
        description: "Official agreement title, e.g. 'Statement of Work — Acme Corp'",
      },
      markdown: {
        type: Type.STRING,
        description:
          "Complete CommonMark markdown contract including Parties, Scope of Work, Deliverables Table, Payment Terms, and Governing Law.",
      },
      sender_name: {
        type: Type.STRING,
        description: "Full legal name of the sender (Party A)",
      },
      sender_email: {
        type: Type.STRING,
        description: "Verified email address of the sender (Party A)",
      },
      recipient_name: {
        type: Type.STRING,
        description: "Full legal name of the client signer (Party B) extracted from the call",
      },
      recipient_email: {
        type: Type.STRING,
        description: "Email address of the client signer (Party B) extracted from the call",
      },
      expires_in_days: {
        type: Type.NUMBER,
        description: "Days until the signing link expires (default 14)",
      },
    },
    required: [
      "title",
      "markdown",
      "sender_name",
      "sender_email",
      "recipient_name",
      "recipient_email",
    ],
  },
};

export async function dispatchContractFromDiscoveryCall(audioFilePath: string) {
  // 2. Upload the discovery call MP3 to the Gemini File API
  const uploadedAudio = await ai.files.upload({
    file: audioFilePath,
    mimeType: "audio/mp3",
  });

  // 3. Invoke Gemini 2.5 Flash with native audio + deterministic function calling
  const response = await ai.models.generateContent({
    model: "gemini-2.5-flash",
    contents: [
      createPartFromUri(uploadedAudio.uri!, uploadedAudio.mimeType!),
      {
        text: "Listen to this discovery call recording between our sales director (Michael Beckett, michael@b2bee.ai) and the client. Extract the final agreed deliverables, milestone dates, and pricing, format a comprehensive Statement of Work in CommonMark markdown, and invoke send_signbee_contract.",
      },
    ],
    config: {
      systemInstruction:
        "You are an enterprise legal operations agent. Always use final amended figures if pricing changes during the conversation. Format pricing schedules as standard Markdown tables.",
      tools: [{ functionDeclarations: [sendSignbeeContractDeclaration] }],
      toolConfig: {
        functionCallingConfig: {
          mode: FunctionCallingConfigMode.ANY,
          allowedFunctionNames: ["send_signbee_contract"],
        },
      },
      temperature: 0.1,
    },
  });

  const functionCall = response.functionCalls?.[0];
  if (!functionCall || functionCall.name !== "send_signbee_contract") {
    throw new Error("Gemini 2.5 did not return a send_signbee_contract tool call");
  }

  // 4. Execute POST https://signb.ee/api/v1/send with the extracted arguments
  const signbeeRes = await fetch("https://signb.ee/api/v1/send", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${process.env.SIGNBEE_API_KEY}`,
    },
    body: JSON.stringify(functionCall.args),
  });

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

  return await signbeeRes.json();
}

import os
import httpx
from google import genai
from google.genai import types

client = genai.Client(api_key=os.environ["GEMINI_API_KEY"])

send_contract_tool = types.FunctionDeclaration(
    name="send_signbee_contract",
    description="Dispatches a legally binding agreement via the Signbee REST API.",
    parameters=types.Schema(
        type=types.Type.OBJECT,
        properties={
            "title": types.Schema(type=types.Type.STRING),
            "markdown": types.Schema(
                type=types.Type.STRING,
                description="Full CommonMark contract text including line-item table.",
            ),
            "sender_name": types.Schema(type=types.Type.STRING),
            "sender_email": types.Schema(type=types.Type.STRING),
            "recipient_name": types.Schema(type=types.Type.STRING),
            "recipient_email": types.Schema(type=types.Type.STRING),
            "total_contract_value_usd": types.Schema(
                type=types.Type.NUMBER,
                description="Numeric total contract value in USD for policy validation.",
            ),
        },
        required=[
            "title",
            "markdown",
            "sender_name",
            "sender_email",
            "recipient_name",
            "recipient_email",
            "total_contract_value_usd",
        ],
    ),
)

def process_vendor_quote_and_send(pdf_bytes: bytes) -> dict:
    response = client.models.generate_content(
        model="gemini-2.5-pro",
        contents=[
            types.Part.from_bytes(data=pdf_bytes, mime_type="application/pdf"),
            "Extract the vendor quote line items, counterparty details, and payment schedule from this PDF. Draft a Master Vendor Agreement in CommonMark and call send_signbee_contract.",
        ],
        config=types.GenerateContentConfig(
            tools=[types.Tool(function_declarations=[send_contract_tool])],
            tool_config=types.ToolConfig(
                function_calling_config=types.FunctionCallingConfig(
                    mode=types.FunctionCallingConfigMode.ANY,
                    allowed_function_names=["send_signbee_contract"],
                )
            ),
            temperature=0.0,
        ),
    )

    call = response.function_calls[0]
    args = dict(call.args)

    # Deterministic policy guardrail before calling Signbee API
    total_usd = float(args.pop("total_contract_value_usd", 0))
    if total_usd > 50000:
        raise ValueError(f"Contract value ${total_usd:,.2f} exceeds $50,000 autonomous limit.")

    with httpx.Client(timeout=10.0) as http:
        res = http.post(
            "https://signb.ee/api/v1/send",
            headers={"Authorization": f"Bearer {os.environ['SIGNBEE_API_KEY']}"},
            json=args,
        )
        res.raise_for_status()
        return res.json()

import crypto from "crypto";
import { NextRequest, NextResponse } from "next/server";

export async function POST(req: NextRequest) {
  const rawBody = await req.text();
  const signatureHeader = req.headers.get("x-signbee-signature") || "";
  const secret = process.env.SIGNBEE_WEBHOOK_SECRET!;

  // Compute expected HMAC-SHA256 digest over raw request body
  const expectedSignature = crypto
    .createHmac("sha256", secret)
    .update(rawBody, "utf8")
    .digest("hex");

  const isValid =
    signatureHeader.length === expectedSignature.length &&
    crypto.timingSafeEqual(
      Buffer.from(signatureHeader),
      Buffer.from(expectedSignature)
    );

  if (!isValid) {
    return NextResponse.json({ error: "Invalid HMAC signature" }, { status: 401 });
  }

  const event = JSON.parse(rawBody);
  if (event.type === "document.signed") {
    // event.data includes: id, title, sha256_hash, signed_pdf_url, verify_url
    console.log(`Contract ${event.data.id} sealed with SHA-256: ${event.data.sha256_hash}`);
  }

  return NextResponse.json({ received: true });
}