MCP Advanced Features

ComposioClient client = new ComposioClient("your-api-key");

// List available apps
List<ComposioClient.ComposioApp> apps = client.listApps();
// ComposioApp(name, description, logoUrl, connected)

// List tools for an app
List<ComposioClient.ComposioTool> tools = client.listTools("github");
// ComposioTool(name, description, appName, inputSchema)

// Execute a tool
JsonNode result = client.executeTool("github_create_issue",
    Map.of("title", "Bug report", "body", "Details..."));

// Check connection status
ComposioClient.ConnectionStatus status = client.getConnectionStatus("github");
// ConnectionStatus(appName, connected, authMethod)

ComposioAuthBridge bridge = new ComposioAuthBridge("your-api-key");

// Verify API key validity (makes a test API call)
if (bridge.verifyApiKey()) {
    Map<String, String> headers = bridge.getAuthHeaders();
    // {"X-API-Key": "...", "Accept": "application/json"}
}

ComposioClient client = new ComposioClient("api-key");
ComposioDiscovery discovery = new ComposioDiscovery(client);

// Discover all tools as MCP definitions
List<McpToolDefinition> allTools = discovery.discoverTools();

// Discover tools for a specific app
List<McpToolDefinition> githubTools = discovery.discoverTools("github");

// Convert to MCP registry entries (one per Composio app)
List<McpServerEntry> entries = discovery.toServerEntries();

McpClient mcpClient = McpClient.create(transport);
mcpClient.connect();
mcpClient.initialize();

Neo4jMcpClient neo4j = new Neo4jMcpClient(mcpClient);

// Execute Cypher queries
JsonNode result = neo4j.executeCypher("MATCH (n:Person) RETURN n LIMIT 10");

// Explore the schema
JsonNode labels = neo4j.listNodeLabels();
JsonNode schema = neo4j.getSchema();

// Check availability
boolean available = neo4j.isAvailable();
// true when mcpClient.isConnected() && mcpClient.isInitialized()

McpClient mcpClient = McpClient.create(transport);
mcpClient.connect();
mcpClient.initialize();

PostgresMcpClient postgres = new PostgresMcpClient(mcpClient);

// Execute SQL queries
JsonNode result = postgres.executeQuery("SELECT * FROM users LIMIT 10");

// Explore schema
JsonNode tables = postgres.listTables();
JsonNode description = postgres.describeTable("users");

boolean available = postgres.isAvailable();

McpClient client = McpClient.create(transport);
client.connect();
client.initialize();

// Generate manifest
TnsAIGooseExtension.ExtensionManifest manifest =
    TnsAIGooseExtension.generateManifest(client);
// ExtensionManifest(name, version, description, tools)
// ExtensionTool(name, description, inputSchema)

// Export as JSON (place in Goose's extension directory)
String json = TnsAIGooseExtension.toJson(manifest);

{
  "name": "deploy-app",
  "description": "Deploy an application",
  "steps": [
    {
      "tool": "build_project",
      "params": { "target": "production" },
      "output": "buildResult"
    },
    {
      "tool": "deploy",
      "params": { "artifact": "{{buildResult}}" }
    }
  ]
}

// Parse a recipe
GooseRecipeParser.Recipe recipe = GooseRecipeParser.parse(jsonContent);
// Recipe(name, description, steps)
// RecipeStep(tool, params, outputVariable)

// Convert to MCP tool call parameter maps
List<Map<String, Object>> mcpCalls = GooseRecipeParser.toMcpCalls(recipe);
// Each map: {"name": "tool_name", "arguments": {...}}

McpClient mcpClient = McpClient.create(transport);
mcpClient.connect();
mcpClient.initialize();

StripeMcpClient stripe = new StripeMcpClient(mcpClient);

// Payments
JsonNode payment = stripe.createPaymentIntent(2000, "usd"); // amount in cents
JsonNode payments = stripe.listPayments(10);

// Account
JsonNode balance = stripe.getBalance();

// Customers
JsonNode customers = stripe.listCustomers(10);
JsonNode newCustomer = stripe.createCustomer("Jane Doe", "jane@example.com");

StripePaymentTool tool = new StripePaymentTool(stripeMcpClient);

// Execute by operation name
JsonNode result = tool.execute("get_balance", Map.of());
JsonNode payment = tool.execute("create_payment_intent",
    Map.of("amount", 2000, "currency", "usd"));

// List supported operations
List<String> ops = tool.listOperations();
// ["create_payment_intent", "list_payments", "get_balance",
//  "list_customers", "create_customer"]

@RegisterExtension
McpServerTestKit testKit = new McpServerTestKit();

@Test
void testToolExecution() throws Exception {
    // Configure mock tool responses
    testKit.getServer().whenToolReturns("echo",
        objectMapper.createObjectNode().put("text", "hello"));

    // Assert tool exists
    testKit.assertToolExists("echo");

    // Assert tool returns expected result
    testKit.assertToolReturns("echo", Map.of("msg", "hi"),
        result -> result.has("text"));
}

MockMcpServer server = new MockMcpServer("test-server", "1.0.0");

// Register tool handlers
server.whenTool("calculate", args -> {
    int a = (int) args.get("a");
    int b = (int) args.get("b");
    return objectMapper.createObjectNode().put("result", a + b);
});

// Static tool response
server.whenToolReturns("echo", resultNode);

// Tool that simulates an error
server.whenToolThrows("fail", -32000, "Something went wrong");

// Register resources
server.whenResource("file://data.txt", "file contents");

// Register prompts
server.whenPrompt("greeting", promptResultNode);

// Process a raw JSON-RPC message
String response = server.processMessage(jsonRpcRequest);

McpTokenManager tokenManager = new McpTokenManager();
// ... store tokens after OAuth flow ...

OAuthMcpTransport transport = OAuthMcpTransport.builder()
    .delegate(new SSETransport.Builder().sseEndpoint("...").build())
    .tokenManager(tokenManager)
    .serverUrl("https://mcp.example.com")
    .tokenEndpoint("https://auth.example.com/token")
    .clientId("my-client")
    .build();

McpClient client = new McpClient(transport);
client.connect();

// Query token state
Optional<String> bearerToken = transport.getBearerToken(); // "Bearer eyJ..."
boolean authenticated = transport.isAuthenticated();

PkceFlow.PkceChallenge challenge = PkceFlow.generateChallenge();
// PkceChallenge(codeVerifier, codeChallenge, codeChallengeMethod="S256")

String authUrl = PkceFlow.buildAuthorizationUrl(
    "https://auth.example.com/authorize",
    "my-client-id",
    "http://localhost:8080/callback",
    "openid profile",          // scope
    "random-state-for-csrf",   // state
    challenge
);
// User visits authUrl, authorizes, callback receives code

PkceFlow.TokenResponse token = PkceFlow.exchangeCode(
    "https://auth.example.com/token",
    "my-client-id",
    authCode,
    "http://localhost:8080/callback",
    challenge.codeVerifier()
);
// TokenResponse(accessToken, refreshToken, tokenType, expiresIn, scope, obtainedAt)

PkceFlow.TokenResponse refreshed = PkceFlow.refreshToken(
    "https://auth.example.com/token",
    "my-client-id",
    token.refreshToken()
);

// Check token state
boolean expired = token.isExpired();
boolean expiringSoon = token.isExpiringSoon(Duration.ofMinutes(5));