Calera WebMCP — In-Browser AI Agent Protocol (W3C Draft)

import os
import httpx
from langchain.tools import tool
from langchain_openai import ChatOpenAI
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain_core.prompts import ChatPromptTemplate

@tool
def get_sec_metric_exact(ticker: str, metric: str, fiscal_year: int) -> dict:
    """Extract exact, audited US-GAAP metrics from FinanceSec (hosted REST, not in-browser WebMCP)."""
    response = httpx.post(
        "https://financesec.api.caleralabs.com/api/query",
        headers={
            "X-License-Key": os.environ["FINSEC_API_KEY"],
            "Content-Type": "application/json",
        },
        json={"query": f"{ticker.upper()} {metric} FY{fiscal_year}", "low_tokens": True},
    )
    return response.json()

tools = [get_sec_metric_exact]
llm = ChatOpenAI(model="gpt-4o", temperature=0.0)

prompt = ChatPromptTemplate.from_messages([
    ("system", "Ground all numerical assertions in FinanceSec facts. Treat SAFE_REFUSAL as honesty."),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
])

agent = create_tool_calling_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

result = executor.invoke({"input": "Extract NVIDIA's FY2025 Revenues and verify the proof hash."})
print(result["output"])

import os
from crewai import Agent, Task, Crew
from crewai.tools import tool
import httpx

@tool("Calera SEC Ground Truth Tool")
def calera_sec_query(ticker: str, metric: str, fiscal_year: int) -> str:
    """Queries audited US-GAAP financial facts from FinanceSec hosted REST."""
    res = httpx.post(
        "https://financesec.api.caleralabs.com/api/query",
        headers={
            "X-License-Key": os.environ["FINSEC_API_KEY"],
            "Content-Type": "application/json",
        },
        json={"query": f"{ticker} {metric} FY{fiscal_year}"},
    )
    if res.status_code == 200:
        data = res.json()
        return f"Verified Ground Truth: {data}"
    return "SAFE_REFUSAL: Ground truth evidence not present in SEC database."

financial_analyst = Agent(
    role="Principal Financial Valuation Auditor",
    goal="Verify corporate performance metrics against audited 10-K instance filings.",
    backstory="You are an SEC compliance officer who relies exclusively on cryptographic XBRL extractions.",
    tools=[calera_sec_query],
    verbose=True
)

audit_task = Task(
    description="Audit NVIDIA FY2025 Revenues and calculate YoY growth against FY2024.",
    expected_output="A structured report detailing exact audited revenue and proof hashes.",
    agent=financial_analyst
)

crew = Crew(agents=[financial_analyst], tasks=[audit_task])
crew.kickoff()

import os
from autogen import AssistantAgent, UserProxyAgent, register_function
import httpx

def calera_get_metric(ticker: str, metric: str, fiscal_year: int) -> dict:
    return httpx.post(
        "https://financesec.api.caleralabs.com/api/query",
        headers={
            "X-License-Key": os.environ["FINSEC_API_KEY"],
            "Content-Type": "application/json",
        },
        json={"query": f"{ticker} {metric} FY{fiscal_year}"},
    ).json()

analyst = AssistantAgent(
    name="Financial_Analyst",
    llm_config={"config_list": [{"model": "gpt-4o", "api_key": os.environ["OPENAI_API_KEY"]}]},
    system_message="Use the calera_get_metric tool to verify all SEC 10-K numbers."
)

user_proxy = UserProxyAgent(
    name="User_Proxy",
    human_input_mode="NEVER",
    max_consecutive_auto_reply=2,
    code_execution_config=False
)

register_function(
    calera_get_metric,
    caller=analyst,
    executor=user_proxy,
    name="calera_get_metric",
    description="Extracts audited SEC EDGAR financial metrics with SHA-256 proof seals."
)

user_proxy.initiate_chat(analyst, message="Verify Apple (AAPL) FY2024 Net Income.")

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

const transport = new StreamableHTTPClientTransport(
  new URL("https://finsec.caleralabs.com/mcp"),
  { requestInit: { headers: { "X-License-Key": "clabs_live_YOUR_KEY" } } }
);

const mcpClient = new Client({ name: "claude-finsec-agent", version: "1.0.0" }, { capabilities: {} });
await mcpClient.connect(transport);

const tools = await mcpClient.listTools();
console.log("Connected to Calera MCP Tools:", tools.tools.map(t => t.name));

const result = await mcpClient.callTool({
  name: "query_financial_sec",
  arguments: { query: "What was Apple's FY2023 revenue?" }
});
console.log(result);

import { chromium } from "playwright";

async function runWebMCPAgent() {
  const browser = await chromium.launch({ headless: false });
  const context = await browser.newContext();
  const page = await context.newPage();

  await page.goto("https://finsec.caleralabs.com/webmcp-docs");

  // Execute WebMCP tool directly in the browser's modelContext
  const result = await page.evaluate(async () => {
    const harness = (window as any).__calera_webmcp;
    return await harness.executeTool("calera.sec.get-metric-exact", {
      ticker: "NVDA",
      metric: "Revenues",
      fiscalYear: 2025
    });
  });

  console.log("In-Browser WebMCP Extraction:", result);
  console.log("SHA-256 Proof:", result.proofHash);

  await browser.close();
}

runWebMCPAgent();