formal-ai 0.299.0

Formal symbolic AI implementation with OpenAI-compatible APIs
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

use serde_json::{json, Value};

use crate::server::ApiHttpResponse;
use crate::solver::UniversalSolver;

const PROTOCOL_VERSION: &str = "2025-06-18";

pub fn handle_mcp_request(body: &str, solver: &UniversalSolver) -> ApiHttpResponse {
    let Ok(request) = serde_json::from_str::<Value>(body) else {
        return json_rpc_error(&Value::Null, -32700, "Parse error");
    };
    let id = request.get("id").cloned().unwrap_or(Value::Null);
    if request.get("jsonrpc").and_then(Value::as_str) != Some("2.0") {
        return json_rpc_error(&id, -32600, "Invalid Request");
    }
    let Some(method) = request.get("method").and_then(Value::as_str) else {
        return json_rpc_error(&id, -32600, "Invalid Request");
    };

    match method {
        "initialize" => {
            let protocol_version = request
                .pointer("/params/protocolVersion")
                .and_then(Value::as_str)
                .unwrap_or(PROTOCOL_VERSION);
            json_rpc_result(
                &id,
                &json!({
                    "protocolVersion": protocol_version,
                    "capabilities": { "tools": {} },
                    "serverInfo": {
                        "name": "formal-ai",
                        "version": env!("CARGO_PKG_VERSION")
                    },
                    "instructions": mcp_text("mcp_instructions")
                }),
            )
        }
        "notifications/initialized" | "ping" => json_rpc_result(&id, &json!({})),
        "tools/list" => json_rpc_result(
            &id,
            &json!({
                "tools": [{
                    "name": "formal_ai_chat",
                    "description": mcp_text("mcp_tool_description"),
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "prompt": {
                                "type": "string",
                                "description": mcp_text("mcp_prompt_description")
                            }
                        },
                        "required": ["prompt"],
                        "additionalProperties": false
                    }
                }]
            }),
        ),
        "tools/call" => call_tool(&request, &id, solver),
        _ => json_rpc_error(&id, -32601, "Method not found"),
    }
}

fn call_tool(request: &Value, id: &Value, solver: &UniversalSolver) -> ApiHttpResponse {
    if request.pointer("/params/name").and_then(Value::as_str) != Some("formal_ai_chat") {
        return json_rpc_error(id, -32601, "Tool not found");
    }
    let Some(prompt) = request
        .pointer("/params/arguments/prompt")
        .and_then(Value::as_str)
    else {
        return json_rpc_error(id, -32602, "prompt must be a string");
    };
    let answer = solver.solve(prompt);
    json_rpc_result(
        id,
        &json!({
            "content": [{ "type": "text", "text": answer.answer }],
            "isError": false
        }),
    )
}

fn mcp_text(intent: &str) -> String {
    crate::seed::response_for(intent, "en").unwrap_or_default()
}

fn json_rpc_result(id: &Value, result: &Value) -> ApiHttpResponse {
    json_response(&json!({ "jsonrpc": "2.0", "id": id, "result": result }))
}

fn json_rpc_error(id: &Value, code: i64, message: &str) -> ApiHttpResponse {
    json_response(&json!({
        "jsonrpc": "2.0",
        "id": id,
        "error": { "code": code, "message": message }
    }))
}

fn json_response(value: &Value) -> ApiHttpResponse {
    ApiHttpResponse {
        status_code: 200,
        content_type: "application/json",
        body: value.to_string(),
    }
}