@iflow-mcp/ansvar-systems-german-law-mcp/dist/src/mcp-stdio.js

German legal research MCP server with statutes, case law, and preparatory works from gesetze-im-internet.de

#!/usr/bin/env node
/**
 * MCP stdio wrapper for German Law MCP Server
 *
 * This file provides a standard MCP stdio interface that bridges
 * MCP protocol messages to the ToolCall format expected by the shell.
 */
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
import { LawMcpShell } from "./shell/shell.js";
import { BUILTIN_ADAPTERS } from "./adapters/index.js";
import { getCapabilities } from "./db/german-law-db.js";
const shell = LawMcpShell.fromAdapters(BUILTIN_ADAPTERS.map(adapter => {
    if (adapter.country.code === "de") {
        return {
            ...adapter,
            getDbCapabilities: () => getCapabilities(),
        };
    }
    return adapter;
}));
const server = new Server({
    name: "german-law-mcp",
    version: "0.4.0",
}, {
    capabilities: {
        tools: {},
    },
});
server.setRequestHandler(ListToolsRequestSchema, async () => {
    const definitions = shell.getToolDefinitions();
    return {
        tools: definitions.map(def => ({
            name: def.name,
            description: def.description,
            inputSchema: def.inputSchema,
        })),
    };
});
server.setRequestHandler(CallToolRequestSchema, async (request) => {
    const toolName = request.params.name;
    const args = (request.params.arguments ?? {});
    try {
        const result = await shell.handleToolCall({
            name: toolName,
            arguments: args,
        });
        if (result.ok) {
            return {
                content: [
                    {
                        type: "text",
                        text: JSON.stringify(result.data, null, 2),
                    },
                ],
            };
        }
        else {
            return {
                content: [
                    {
                        type: "text",
                        text: JSON.stringify(result.error, null, 2),
                    },
                ],
                isError: true,
            };
        }
    }
    catch (error) {
        const message = error instanceof Error ? error.message : String(error);
        return {
            content: [
                {
                    type: "text",
                    text: `Error: ${message}`,
                },
            ],
            isError: true,
        };
    }
});
async function main() {
    const transport = new StdioServerTransport();
    await server.connect(transport);
}
main().catch((error) => {
    console.error("Fatal error:", error);
    process.exit(1);
});